Java课件第八章-线程.ppt

1、第八章第八章 线程线程n 本章导读本章导读n1. Java中的线程n2. 线程的生命周期n3. 线程的优先级与调度管理n4. Thread的子类创建线程n5使用Runable接口n6线程的常用方法n7线程同步n8在同步方法中使用wait()、notify 和notifyAlln9线程的联合n10守护线程8.1 Java中的线程中的线程 程序是一段静态的代码，它是应用软件执行的蓝本。进程是程序的一次动态执行过程，它对应了从代码加载、执行至执行完毕的一个完整过程，这个过程也是进程本身从产生、发展至消亡的过程。线程是比进程更小的执行单位。一个进程在其执行过程中，可以产生多个线程，形成多条执行线索，每

2、条线索，即每个线程也有它自身的产生、存在和消亡的过程，也是一个动态的概念。为理解线程这个概念我们看一段程序：8.1 Java中的线程中的线程 Class Qution public static void main(String args) while(true) System.outprintln(“123”); while(true) System.outprintln(“abc”); 第2个while是不会执行的，但将如创建两个线程Java的虚拟机会负责使俩、个线程轮流执行。 Java应用程序总是从主类的main方法开始执行。当JVM加载代码，发现main方法之后，就会启动一个线程，这个

3、线程称作“主线程”，该线程负责执行main方法。那么，在main方法中再创建的线程，就称为主线程中的线程。如果main方法中没有创建其他的线程，那么当main方法执行完最后一个语句，即main方法返回时，JVM就会结束我们的Java应用程序。如果main方法中又创建了其他线程，那么JVM就要在主线程和其他线程之间轮流切换，保证每个线程都有机会使用CPU资源，main方法即使执行完最后的语句，JVM也不会结束我们的程序，JVM一直要等到主线程中的所有线程都结束之后，才结束我们的Java应用程序。返回8.2 线程的生命周期线程的生命周期 1线程的4种状态 在Java语言中，Thread类及其子类创

4、建的对象称作线程，新建的线程在它的一个完整的生命周期中通常要经历4种状态， （1）新建 （2）运行 线程创建后仅仅是占有了内存资源，在JVM管理的线程中还没有这个线程，此线程必须调用start（）方法（从父类继承的方法）通知JVM，这样JVM就会知道又有一个新一个线程排队等候切换了。 当JVM将CUP使用权切换给线程时，如果线程是Thread的子类创建的，该类中的run方法就立刻执行。所以我们必须在子类中重写父类的run方法，Thread类中的run()方法没有具体内容，程序要在Thread类的子类中重写run()方法来覆盖父类的run()方法，run方法规定了该线程的具体使命。 在线程没有结

5、束run方法之前，不要让线程再调用start方法，否则将发生ILLegalThreadStateException异常。（3）中断 有4种原因的中断：（a） JVM将CPU资源从当前线程切换给其他线程，使本线程让出CPU的使用权处于中断状态。（b）线程使用CPU资源期间，执行了sleep(int millsecond)方法，使当前线程进入休眠状态。sleep(int millsecond)方法是Thread类中的一个类方法，线程一旦执行了sleep(int millsecond)方法，就立刻让出CPU的使用权，使当前线程处于中断状态。经过参数millsecond指定的豪秒数之后，该线程就重新进

6、到线程队列中排队等待CPU资源，以便从中断处继续运行。 （c）线程使用CPU资源期间，执行了wait()方法，使得当前线程进入等待状态。等待状态的线程不会主动进到线程队列中排队等待CPU资源，必须由其他线程调用notify()方法通知它，使得它重新进到线程队列中排队等待CPU资源，以便从中断处继续运行。有关wait、noftify和notifyAll方法将在第8节详细讨论 (d) 线程使用CPU资源期间，执行某个操作进入阻塞状态，比如执行读/写操作引起阻塞。进入阻塞状态时线程不能进入排队队列，只有当引起阻塞的原因消除时，线程才重新进到线程队列中排队等待CPU资源，以便从原来中断处开始继续运行。

7、 （4）死亡 处于死亡状态的线程不具有继续运行的能力。线程死亡的原因有二，一个是正常运行的线程完成了它的全部工作，即执行完run方法中的全部语句，结束了run方法。另一个原因是线程被提前强制性地终止，即强制run方法结束。所谓死亡状态就是线程释放了实体，即释放分配给线程对象的内存。 现在，我们看一个完整的例子1，通过分析运行结果阐述线程的4种状态。该例子中我们用Thread的子类：WriteWordThread创建了两个线程。 npublic class Example8_1n public static void main(String args )n WriteWordThread zha

8、ng,wang;n zhang=new WriteWordThread(张小红); /新建线程n wang=new WriteWordThread(JamsKeven); /新建线程n zhang.start(); /启动线程n for(int i=1;i=8;i+)n System.out.println(我是主线程中的语句);n n wang.start(); /启动线程n nnclass WriteWordThread extends Thread /Thread的子类负责创建线程对象n WriteWordThread(String s)n setName(s); /调用Thread类的

9、setName方法为线程起个名字n n public void run()n for(int i=1;i=8;i+)n System.out.println(我是一个线程，我的名字是+getName();n n n 上述程序在不同的计算机运行或在同一台计算机反复运行的结果不尽相同，输出结果依赖当前CPU资源的使用情况。为了使结果尽量不依赖于当前CPU资源的使用情况，我们应当让线程主动调用sleep方法让出CPU的使用权进入中断状态，如例子2所示： public class Example8_2 public static void main(String args ) WriteWordThr

10、ead zhang,wang; 返回 zhang=new WriteWordThread(张小红,200); /新建线程 wang=new WriteWordThread(JamsKeven,100); /新建线程 zhang.start(); /启动线程 wang.start(); /启动线程 class WriteWordThread extends Thread int n=0; WriteWordThread(String s,int n)返回 setName(s); /调用Thread类的方法setName为线程起个名字 this.n=n; public void run() for

11、(int i=1;i=8;i+) System.out.println(我是一个线程，我的名字是+getName(); try sleep(n); catch(InterruptedException e) 返回8.3 线程的优先级与调度管理线程的优先级与调度管理 Java虚拟机（JVM）中的线程调度器负责管理线程，调度器把线程的优先级分为10个级别，分别用Thread类中的类常量表示。每个Java线程的优先级都在常数1： Thread.MIN PRIORITY 到常数10： Thread.MAX_PRIORITY 的范围内。如果没有明确地设置线程的优先级别，每个线程的优先级都为常数5（包括主

12、线程）： Thread.NORM_PRIORITY， 线程的优先级可以通过setPriority（int grade）方法调整，这一方法需要一个int类型参数。如果此参数不在110的范围内，那么setPriority便产生一个lllegalArgumenException异常。getPriority方法返回线程的优先级。需要注意是，有些操作系统只能识别3个级别：1，5，10。返回8.4 Thread 的子类创建线程的子类创建线程 在Java语言中，用ThreadThread类或子类类或子类创建线程对象。这一节讲述怎样用Thread子类创建对象。 用户可以扩展 Thread类，但需要重写父类的r

13、un方法，其目的是规定线程的具体操作，否则线程就什么也不做，因为父类的run方法中没有任何操作语句。 下面例子3中除主线程外还有两个线程，这两个线程分别在命令行窗口的左侧和右侧顺序地一行一行地输出字符串。主线程负责判断输出的行数，当其中任何一个线程输出8行后，就结束进程。本例题中用到了System类中的类方法：exit(int n)，主线程使用该方法结束整个程序。 public class Example8_3 public static void main(String args ) 返回 Left left=new Left(); Right right=new Right(); left

14、.start(); right.start(); while(true) if(left.n=8|right.n=8) System.exit(0); class Left extends Thread int n=0; public void run() while(true) n+;返回8.4 Thread 的子类创建线程的子类创建线程 System.out.printf(n%s,我在左面写字); try sleep(int)(Math.random()*100)+100); catch(InterruptedException e) class Right extends Thread

15、int n=0; public void run()返回8.4 Thread 的子类创建线程的子类创建线程 while(true) n+; System.out.printf(n%40s,我在右面写字); try sleep(int)(Math.random()*100)+100); catch(InterruptedException e) 返回8.5 使用使用Runable接口接口 使用Thread子类创建线程的优点是：我们可以在子类中增加新的成员变量，使线程具有某种属性，也可以在子类中新增加方法，使线程具有某种功能。但是，Java不支持多继承，Thread类的子类不能再扩展其他的类。 1

16、Runnable接口与目标对象 创建线程的另一个途径就是用Thread类直接创建线程对象。使用Thread创建线程对象时，通常使用的构造方法是： Thread（Runnable target）， 该构造方法中的参数是一个Runnable类型的接口，因此，在创建线程对象时必须向构造方法的参数传递一个实现Runnable接口类的实例，该实例对象称作所创线程的目标对象，当线程调用start方法后，一旦轮到它来享用CPU资源，目标对象就会自动调用接口中的run方法（接口回调），这一过程是自动实现的，用户程序只需要让线程调用start方法即可，也就是说，当线程被调度并转入运行状态时，所执行的就是run(

17、)方法中所规定的操作。 线程间可以共享相同的内存单元（包括代码与数据），并利用这些共享单元实现数据的交换、实时通讯与必要的同步操作。 对于thread(Runnable target)构造的线程使用同一目标对象的线程，目标对象的成员变量自然成为这些线程共享的数据单元。 下面的例子4中，两个线程：zhang和cheng，使用同一目标对象（Bank类对象）。两个线程共享目标对象的money。当money的值小于100时，线程zhang结束自己的run方法进入死亡状态；当money的值小于60时，线程cheng结束自己的run方法进入死亡状态。public class Example8_4 publ

18、ic static void main(String args ) String s1=会计,s2=出纳; Bank bank=new Bank(s1,s2); Thread zhang,cheng; zhang=new Thread(bank); cheng=new Thread(bank); /cheng和zhang是同一目标对象 zhang.setName(s1); /会计 cheng.setName(s2); /出纳 bank.setMoney(160); /线程的目标对象修改被线程共享的money zhang.start(); cheng.start(); class Bank im

19、plements Runnable /Bank类必须实现Runnable接口 private int money=0; String name1,name2; Bank(String s1,String s2) name1=s1; name2=s2; public void setMoney(int mount) money=mount; public void run() /接口中的方法 while(true) money=money-10; if(Thread.currentThread().getName().equals(name1) System.out.println(我是+nam

20、e1+现在有+money+元); if(money=100) System.out.println(name1+“进入死亡状态”); return; /如果money小于100，当前线程结束run方法 else if(Thread.currentThread().getName().equals(name2) System.out.println(我是+name2+现在有+money+元); if(money=4)n System.out.println(s1+线程进入死亡状态);n return;n n n else if(Thread.currentThread().getName().e

21、quals(s2)n i=i-1;n System.out.println(s2+线程的局部变量:+i);n if(i=-4)n System.out.println(s2+线程进入死亡状态);n return;n n n try Thread.sleep(800);n n catch(InterruptedException e) n n n8.6 线程的常用方法线程的常用方法 1start() 线程调用该方法将启动线程，使之从新建状态进入就绪队列排队，一旦轮到它来享用CPU资源时，就可以脱离创建它的主线程独立开始自己的生命周期了。 2run() Thread类的run()方法与Runnab

22、le接口中的run()方法的功能和作用相同，都用来定义线程对象被调度之后所执行的操作，都是系统自动调用而用户程序不得引用的方法。 3sleep(int millsecond) 优先级高的线程可以在它的run()方法中调用sleep方法来使自己放弃处理器资源，休眠一段时间。 4isAlive() 在线程的run方法结束之前，即没有进入死亡状态之前，线程调用isAlive()方法返回true，当线程进入死亡状态后（实体内存被释放），线程仍可以调用方法isAlive（），这时返回的值是false。（线程未调用线程未调用startstart方法之前，调用方法之前，调用isAliveisAlive()(

23、)方法返回方法返回false).false). 需要注意的是，一个已经运行的线程在没有进入死亡状态时，不要再给线程分配实体，由于线程只能引用最后分配的实体，先前的实体就会成为“垃圾”，并且不会被垃圾收集机收集掉。 现在让我们看一个例子，在下面的例子7中一个线程每隔1秒钟在命令行窗口输出机器的当前时间，在输出3秒之后，该线程又被分配了实体，新实体又开始运行。这时，我们在命令行每秒钟能看见两行当前时间，因为垃圾实体仍然在工作 。public class Example8_7 public static void main(String args ) A a=new A(); a.thread.st

24、art(); class A implements Runnable Thread thread; int n=0; A() thread=new Thread(this); public void run() while(true) n+; System.out.println(new java.util.Date(); try Thread.sleep(1000); catch(InterruptedException e) if(n=3) thread=new Thread(this); thread.start(); 5currentThread() currentThread（）方法

25、是Thread类中的类方法，可以用类名调用，该方法返回当前正在使用CPU资源的线程。 6interrupt() intertupt方法经常用来“吵醒”休眠的线程。当一些线程调用sleep方法处于休眠状态时，一个使用 CPU资源的其它线程在执行过程中，可以让休眠的线程分别调用interrupt 方法“吵醒”自己，即导致休眠的线程发生InterruptedException异常，从而结束休眠，重新排队等待CPU资源。 在下面的例子8中，有3个线程：zhangXiao、zhengMing和teacher，其中2个线程：zhangXiao和zhengMing准备休眠10秒钟后，再分别输出“早上好！”和

26、“good morning！”。teacher线程在输出3句“上课”后，“吵醒”休眠的线程：zhangXiao和zhengMing。 public class Example8_8 public static void main(String args) ClassRoom room=new ClassRoom(); room.zhangXiao.start();返回 room.zhengMing.start(); room.teacher.start(); class ClassRoom implements Runnable Thread zhangXiao,zhengMing,teach

27、er;返回 ClassRoom() teacher=new Thread(this); zhangXiao=new Thread(this); zhangXiao.setName(张小); zhengMing=new Thread(this); zhengMing.setName(郑明); teacher.setName(刘老师); public void run() Thread thread=Thread.currentThread(); if(thread=zhangXiao|thread=zhengMing)返回try System.out.println(thread.getName

28、()+休息10秒后再说问候); Thread.sleep(10000); catch(InterruptedException e) System.out.println(thread.getName()+被吵醒了);返回 System.out.println(thread.getName()+说:早上好！); else if(thread=teacher) for(int i=1;i=3;i+) System.out.println(thread.getName()+说:t上课!);返回 try Thread.sleep(500); catch(InterruptedException e)

29、 zhengMing.interrupt(); /吵醒zhengMing zhangXiao.interrupt(); /吵醒zhangXiao 返回8.7 线程同步线程同步 两个或多个线程访问同一个变量时就要注意同步问题： 线程同步是指多个线程要执行一个synchronized修饰的方法，如果一个线程A占有CPU资源期间，使用的synchronized方法正在被调用执行，那么在该synchronized方法返回之前，即synchronized方法调用执行完毕之前，其他占有CPU资源的线程一旦调用这个synchronized方法就会引起堵塞，堵塞的线程要一直等到堵塞的原因消除（ synchro

30、nized方法返回），再排队等待CPU资源，以便使用这个同步方法。 在下面的例子9中有两个线程：accountant和cashier，他俩共同拥有一个帐本。他俩都可以使用saveOrTake（int number）对帐本进行访问，会计使用saveOrTake方法时，向帐本上写入存钱记录；出纳使用saveOrTake方法时，向帐本写入取钱记录。因此，当会计正在使用saveOrTake方法时，出纳被禁止使用，反之也是这样。public class Example8_9 public static void main(String args ) String accountantName=会计,ca

31、shierName=出纳; Bank bank=new Bank(accountantName,cashierName);返回 Thread accountant,cashier; accountant=new Thread(bank); cashier=new Thread(bank); accountant.setName(accountantName); cashier.setName(cashierName); accountant.start(); cashier.start(); 返回class Bank implements Runnable int money=300; Str

32、ing accountantName,cashierName; public Bank(String s1,String s2) accountantName=s1; cashierName=s2; public void run() saveOrTake(30); /线程占有CPU资源期间调用了同步方法 返回public synchronized void saveOrTake(int number) /同步方法 if(Thread.currentThread().getName().equals(accountantName) for(int i=1;i=3;i+) money=money

33、+number; 返回 try Thread.sleep(1000); /存入30万稍歇一下,出纳仍不能使用该方法 catch(InterruptedException e) System.out.println(我是+accountantName+目前帐上有+money+万); 返回 else if(Thread.currentThread().getName().equals(cashierName) for(int i=1;i=2;i+) money=money-number/2; try Thread.sleep(1000); catch(InterruptedException e)

34、 System.out.println(我是+cashierName+目前帐上有+money+万); 返回8.8 在同步方法中使用在同步方法中使用wait()、notify和和notifyall wait（）、notify（）和notifyAll（）都是Object类中的final方法，被所有的类继承，且不允许重写的方法。 当一个线程使用的同步方法中用到某个变量，而此变量又需要其它线程修改后才能符合本线程的需要，那么可以在同步方法中使用wait（）方法。使用wait（）方法可以中断方法的执行，使本线程等待，暂时让出CPU的使用权，并允许其它线程使用这个同步方法。其它线程如果在使用这个同步方法时

35、不需要等待，那么它使用完这个同步方法的同时，应当用notifyAll（）方法通知所有的由于使用这个同步方法而处于等待的线程结束等待。 在下面的例子10中，模拟3个人排队买票，每人买1张票。售票员只有1张五元的钱，电影票五元钱一张。张某拿1张二十元的人民币排在孙某前面买票，孙某拿1张十元的人民币排在赵的前面买票，赵某拿1张五元的人民币排在最后。那么，最终的卖票次序应当是孙、赵、张 。public class Example8_10public class Example8_10 public static void main(String args public static void main

36、(String args) String s1= String s1=张三张三,s2=,s2=孙大名孙大名,s3=,s3=赵中堂赵中堂; Cinema canemaCinema canema=new Cinema(s1,s2,s3);=new Cinema(s1,s2,s3); Thread zhang,sun,zhao Thread zhang,sun,zhao; ; 返回 zhang=new Thread(canemazhang=new Thread(canema);); sun=new Thread(canema sun=new Thread(canema);); zhao=new Th

37、read(canema zhao=new Thread(canema);); zhang.setName(s1); zhang.setName(s1); sun.setName(s2); sun.setName(s2); zhao.setName(s3); zhao.setName(s3); zhang.start zhang.start();(); sun.start sun.start();(); zhao.start zhao.start();(); class Cinema implements Runnableclass Cinema implements Runnable / /实

38、现实现RunnableRunnable接接口的类（电影院）口的类（电影院） TicketSellerTicketSeller seller; / seller; /电影院的售票员电影院的售票员返回 String name1,name2,name3; / String name1,name2,name3; /买票人的名字买票人的名字( (线程的名字线程的名字) ) Cinema(StringCinema(String s1,String s2,String s3) s1,String s2,String s3) seller=new TicketSeller seller=new TicketS

39、eller();(); name1=s1; name1=s1; name2=s2; name2=s2; name3=s3; name3=s3; public void run() public void run() if(Thread.currentThread().getName().equals(nameif(Thread.currentThread().getName().equals(name1)1)返回 seller.sellTicket(20); seller.sellTicket(20); else else if(Thread.currentThread().getName()

40、.equals(namif(Thread.currentThread().getName().equals(name2)e2) seller.sellTicket(10); seller.sellTicket(10); else else if(Thread.currentThread().getName().equals(namif(Thread.currentThread().getName().equals(name3)e3) seller.sellTicket(5); seller.sellTicket(5); 返回class TicketSellerclass TicketSelle

41、r / /负责卖票的类负责卖票的类 int fiveNumberint fiveNumber=1,tenNumber=0,twentyNumber=0; =1,tenNumber=0,twentyNumber=0; public synchronized void sellTicket(int public synchronized void sellTicket(int receiveMoneyreceiveMoney) String s=Thread.currentThread().getName String s=Thread.currentThread().getName();();

42、if(receiveMoney if(receiveMoney=5)=5) fiveNumber fiveNumber=fiveNumber+1; =fiveNumber+1; System.out.println(s System.out.println(s+给售票员给售票员5 5元钱元钱, ,售售票员卖给票员卖给+s+s+一张票一张票, ,不必找赎不必找赎);); else if(receiveMoneyelse if(receiveMoney=10)=10)返回 while(fiveNumber while(fiveNumber1)1) try System.out.println(s

43、try System.out.println(s+给售票给售票员员1010元钱元钱);); System.out.printlnSystem.out.println(售票员请售票员请+s+s+靠边等一会靠边等一会);); wait(); / wait(); /如果线程占有如果线程占有CPUCPU期期间执行了间执行了wait()wait()，就进入中断状态，就进入中断状态 System.out.println(sSystem.out.println(s+结束等结束等待待, ,继续买票继续买票);); catch(InterruptedExceptioncatch(InterruptedExcep

44、tion e) e) fiveNumber fiveNumber=fiveNumber-1;=fiveNumber-1; tenNumber tenNumber=tenNumber+1;=tenNumber+1;返回 System.out.println(s System.out.println(s+给售票员给售票员1010元钱元钱, ,售售票员卖给票员卖给+s+s+一张票一张票, ,找赎找赎5 5元元);); else if(receiveMoneyelse if(receiveMoney=20)=20) while(fiveNumber while(fiveNumber1|tenNumbe

45、r1)1|tenNumber1) try System.out.println(s try System.out.println(s+给售票员给售票员2020元钱元钱);); System.out.printlnSystem.out.println(售票员请售票员请+s+s+靠边等一会靠边等一会);); wait(); / wait(); /如果线程占有如果线程占有CPUCPU期间期间执行了执行了wait()wait()，就进入中断状态，就进入中断状态 System.out.println(sSystem.out.println(s+结束等待结束等待, ,继续买票继续买票);); catch(

46、InterruptedExceptioncatch(InterruptedException e) e)返回 fiveNumber fiveNumber=fiveNumber-1;=fiveNumber-1; tenNumber tenNumber=tenNumber-1;=tenNumber-1; twentyNumber twentyNumber=twentyNumber+1;=twentyNumber+1; System.out.println(s System.out.println(s+给售票员给售票员2020元钱元钱, ,售票员卖给售票员卖给+s+s+一张票一张票, ,找赎找赎15

47、15元元);); notifyAllnotifyAll();(); 返回8.9 挂起、恢复和终止线程 n挂起：有时候两个线程，不涉及需要调用同一个同步方法，但线程也可能需要临时停止，即所谓挂起一个线程，就是暂时让出CPU的使用权，暂时停止执行，但停止的时间不确定，不能使用sleep方法，停止线程。n 线程如果有目标对象，那么当前线程在占用CPU期间，只要调用wait()方法流可以挂起一个线程。为了恢复这个挂起的线程，其它线程在占有CPU资源期间让挂起线程的目标对象在同步方法中调用 notifyAll(); 方法即可。8.9 挂起、恢复和终止线程 n线程如果没有目标对象（用thread子类创建的

48、线程）那么当前线程在占用CPU期间，只要在某个同步方法中调用wait()方法就可以挂起一个线程。n恢复线程只需调用notifyAll（）即可。n终止线程只需结束run（）方法即可。8.9 挂起、恢复和终止线程 n在下面的例子11中，线程thread每隔一秒钟输出一个整数，输出3个整数后，该线程挂起；主线程负责恢复thread线程继续执行。npublic class Example8_11n public static void main(String args)n A target=new A(); /线程thread的目标对象 n Thread thread=new Thread(targe

49、t);8.9 挂起、恢复和终止线程 n thread.setName(张三);n thread.start();n while(target.getStop()=false)n System.out.println(我是主线程,负责恢复+thread.getName()+线程); n target.restart(); /恢复thread线程n n8.9 挂起、恢复和终止线程 nclass A implements Runnablen int number=0;n boolean stop=false;n boolean getStop()8.9 挂起、恢复和终止线程 n return sto

50、p;n n public void run()n while(true)n number+;n System.out.println(Thread.currentThread().getName()+的number=+number);8.9 挂起、恢复和终止线程 n if(number=3)n try System.out.println(Thread.currentThread().getName()+被挂起);n stop=true;n hangUP();/挂起线程n System.out.println(Thread.currentThread().getName()+恢复执行);8.9