java文件-千锋多线程

线程VS

进程创建和启动线程的方式实现Runnable接口继承自Thread类线程的状态转换线程的调度和优先级sleep,join,yieldsynchronized线程同步死锁问题线程间的通信wait

、notify/notifyAll生产者、消费者问题ThreadLocal线程局部变量守护线程接口回调进程(Process)每个独立运行着的程序称为一个进程.线程(Thread)线程是一个进程

的一条执行路径，Java虚拟机允许应用程序并发地运行多个执行路径线程是轻量级的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换的开销小。线程和进程的区别每个进程都有独立的代码和数据空间(进程上下文)，进程间的切换开销大线程:同一进程内的线程共享代码和数据空间，线程切换的开销小多进程:在操作系统中能同时运行多个任务(程序)多线程:在同一进程有多个并发任务在执行.多线程机制让系统能够更高效地利用CPU资源,同时让固定流程的程序变得更灵活.让一个程序可以同时干很多事情.3两种创建新线程的方式第一种：定义实现Runnable接口的类Runnable接口中只有一个方法public

void

run();用来定义线程运行体：。class

MyRun

implements

Runnable{ public

voidrun(){…}

}创建线程的实例的时候将这个类的实例作为参数传递到线程实例然后再启动：Thread

thread1

=

new

Thread(new

MyRun());thread1.start();第二种：将类 为Thread

的子类并重写run()方法class

MyThread

extends

Thread{ public

voidrun(){…}

}创建此线程类的实例并启动：MyThread

thread1

=

new

MyThread();thread1.start();4public

class

TestThread1{public

static

void

main(String[]

args)

{Runner

runner=new

Runner();//创建Runnable实现类的对象Threadthread1=

newThread(runner);thread1.start();for(int

i

=

0;

i<

100;

i++){System.out.println("-------MainThread:"

+

i);}}}class

Runner

implements

Runnable{public

void

run()

{for(int

i

=0;

i

<

100;i++){System.out.println("runner:"

+

i);}}}TestThread1.java5TestThread2.javapublic

class

TestThread2{public

static

void

main(String[]

args)

{MyThreadthread1

=newMyThread();thread1.start();for(int

i

=0;

i

<

100;i++){System.out.println("-------MainThread:"

+

i);}}}class

MyThread

extends

Thread{public

void

run()

{for(int

i

=0;

i

<

100;i++){System.out.println("MyThread:"

+

i);}}}6Java的线程是通过java.lang.Thread类来实现的。当程序启动运行时，JVM会产生一个线程(主线程)，主方法(main方法)就是在这个线程上运行的。可以通过创建Thread的实例来创建新的线程。每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的，方法run()称为线程体。通过调用Thread类的start()方法来启动一个线程。线程进入Runnable（可运行）状态，它将向线程调度器 这个线程。调用start()方法并不一定马上会执行这个线程，正如上面所说，它只是进入Runnable

而不是Running。同一个线程对象的start()方法只能调用一次,不能重复启动,无论线程是否已经结束.注意，不要直接在程序中调用线程的run()方法。7使用Runnable接口还可以从其他类继承；保持程序风格的一致性。直接继承Thread类不能再从其他类继承；编写简单，可以直接 线程使用实现Runnable接口的方式创建线程时可以为相同程序代码的多个线程提供共享的数据(见下页)public

class

MyRun

implements

Runnable{public

int

count=100;//共享的数据public

voidrun(){......}}...MyRun

r

=

newMyRun();//t1与t2共享了MyRun的对象Thread

t1

=

new

Thread(r);Thread

t2=

new

Thread(r);//t1.start();t2.start();...public

void

start()使该线程进入"就绪"("可运行")状态public

static

Thread

currentThread()返回对当前正在执行的线程对象的public

final

boolean

isAlive()测试线程是否处于活动状态public

Thread.State

getState()返回该线程的状态,返回Thread类的静态的 枚举类型public

final

String

getName()返回该线程的名称public

final

void

setName(String

name)改变线程名称public

final

void

setDaemon(boolean

on)将该线程标记为守护( )线程或用户线程10isAlive()判断一个子线程是否还“活着”Demo线程睡眠：Thread.sleep(long

millis)throws

InterruptedException

方法，使线程转到阻塞状态。millis参数设定睡眠的时间，以毫秒为单位。当睡眠结束后，就转为就绪（Runnable）状态。线程让步(礼让)：Thread.yield()静态方法，暂停当前正在执行的线程对象，把执行机会让给相同或者更高优先级的线程。但随后仍然可能继续执行.线程加入(合并/加塞)：join()

throws

InterruptedException

方法

在当前线

调用另一个线程的

join()方法，则当前线程转入WAITING状态，直到另一个线程运行结束，当前线程再由阻塞转为就绪状态。12TestThreadYield.javapublic

class

TestThreadYield

{public

static

void

main(String[]

args)

{System.out.println("主线程:"+Thread.currentThread().getName());Thread

thread1=new

Thread(new

MyThread2());thread1.start();Thread

thread2

=new

Thread(new

MyThread2());thread2.start();}}class

MyThread2

implements

Runnable{public

void

run()

{for(int

i

=0;

i

<

100;i++){System.out.println(Thread.currentThread().getName()+

":"

+

i);if(i

%

10

==

0){System.out.println(Thread.currentThread().getName()+“yield”);Thread.yield();/*线程让步*/

}}}}

13Thread.yieldpublic

class

TestThreadJoin

{public

static

void

main(String[]

args)

{Thread

thread1

=

new

Thread(newMyThread3());thread1.start();for

(int

i=

1;

i

<=100;

i++)

{System.out.println(Thread.currentThread().getName()

+

":"

+

i);if

(i

==

50)

{try{

thread1.join(); //线程合并}

catch

(InterruptedException

e)

{

e.printStackTrace();

}}}}}class

MyThread3

implements

Runnable{public

void

run(){for

(int

i

=

1;i<=50;i++){System.out.println(Thread.currentThread().getName()

+

":"

+

i);try

{

Thread.sleep(100);}

catch

(InterruptedException

e)

{ e.printStackTrac

()

}}}}TestThreadJoin.java14join练习设计一个线程类，在main()中创建并启动2个该类的子线程，一个子线程(“A”)每打印10个数字睡眠，另一个子线程(“B”)每打印20个睡眠,会用到的方法:Thread(Runnable ,

Stringname)getName()

,sleep()如果线程的run()方法中执行的是一个重复执行的循环，可以提供一个标记来控制循环是否继续执行。示例：TestThreadEnd.java(下页)对于正在执行的线程,interrupt()无法打断该线程的执行，但是可以获得该线程被中断的标志:Terrupted()得到true,调用后,中断标志将被清除(变为false)如果线程因为执行join(),sleep()或是wait()而进入了阻塞状态，此时要想停止它，可以使用interrupt()，程序会抛出InterruptedException异常而被catch()子句捕获,进行处理。示例：TestThreadEnd2.java(下页)如果程序因为输入/输出的等待而阻塞，基本上必须等待输入/输出的动作完成才能离开阻塞状态。无法用interrupt()方法来使得线程离开run()方法，要想离开，只能通过 一个异常。16public

classThreadEndTest

{public

static

void

main(String[]

args)

{SomeThread

some

=newSomeThread();Thread

thread1=

new

Thread(some);thread1.start();try

{Thread.sleep(500);}

catch

(InterruptedException

e)

{

e.printStackTrace();

}some.terimate();}}class

SomeThread

implements

Runnable

{private

boolean

flag=

true;this.flag

=

false;

}public

void

terimate()

{public

void

run()

{while

(flag)

{System.out.println("...run...");}}}TestThreadEnd.java17public

class

TestThreadEnd2

{public

static

void

main(String[]

args)

{Thread

thread1

=

new

Thread(newSomeThread2());thread1.start();try

{Thread.sleep(2000);}

catch

(InterruptedException

e)

{

e.printStackTrace();

}errupt();TestThreadEnd2.java}}class

SomeThread2

implements

Runnable{public

void

run(){System.out.println("sleep.........");try

{Thread.sleep(9999);}

catch

(InterruptedException

e)

{System.out.println("

interrupted...");e.printStackTrace();}}}18线程的状态：要想实现多线程，必须在主线

创建新的线程对象。任何线程都具有五种状态：创建、就绪、运行、阻塞、终止(停止)。19新建状态(New)新创建了一个线程对象。就绪状态(Runnable)线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。获取了CPU，执行程序代码时也属于就绪状态。运行状态(Running)执行run()。阻塞状态(Blocked)阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：同步阻塞：若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。运行的线程在获取对象的同步锁时,其他需要该锁的线程将进入同步阻塞状态.等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。结束状态(Dead)线程执行完了或者因异常退出了run()方法，该线程结束生命周2期0

。Java

提供一个线程调度器来 程序中启动后进入就绪状态的所有线程。优先级高的线程会获得较多的运行机会。Java

线程的优先级用整数表示，取值范围是1~10，Thread

类有以下三个静态常量：static

int

MAX_PRIORITYstatic

intMIN_PRIORITYstatic

intNORM_PRIORITY线程可以具有的最高优先级，取值为10。线程可以具有的最低优先级，取值为1。分配给线程的默认优先级，取值为5。Thread类的void

setPriority(int

newPriority)和int

getPriority()方法分别用来设置和获取线程的优先级。21public

class

TestPriority

{public

static

void

main(String[]

args)

{Thread

t0=

new

Thread(new

R());Thread

t1=

new

Thread(new

R());t0.setPriority(Thread.NORM_PRIORITY

+

5);t0.start();t1.start();}}class

R

implements

Runnable

{public

void

run()

{for

(int

i

=

0;

i

<

100;

i++)

{