Java语言程序设计第8章课件.ppt

《Java语言程序设计第8章课件.ppt》由会员分享，可在线阅读，更多相关《Java语言程序设计第8章课件.ppt（45页珍藏版）》请在三一办公上搜索。

1、第8章 线程,郑 莉,JAVA语言程序设计,1,第8章 线程郑 莉JAVA语言程序设计1,本讲内容,线程基础线程的概念Thread类Runnable接口资源共享和线程同步线程间的通信线程的生命周期线程的优先级程序举例,2,本讲内容线程基础2,线程的概念,进程：程序的一次执行线程：一个进程中的多个控制流通过多线程，一个进程表面上看同时可以执行一个以上的任务并发多数程序设计语言不支持并发，支持多线程要借助于操作系统“原语（primitives）”Java是第一个支持内置线程操作的主流编程语言,线 程 基 础,3,线程的概念进程：程序的一次执行线 程 基 础3,Thread类简介,线程类需要继承Th

2、read类Thread 的构造函数public Thread( String threadName )public Thread()在线程的run方法中编写线程的主要任务sleep 方法使线程休眠interrupt 方法中断一个运行中的线程 isAlive方法检查线程的状态setName方法设置线程名join方法等待线程结束，以执行当前线程,线 程 基 础,4,Thread类简介线程类需要继承Thread类线 程 基 础,例8_1 在新线程中计算整数的阶乘,public class Ex8_1 public static void main( String args ) System.out.

3、println(main thread starts); FactorialThread thread= new FactorialThread(10); thread.start(); System.out.println( new thread started,main thread ends ); / end main ,线 程 基 础,5,例8_1 在新线程中计算整数的阶乘public class,/ class FactorialThread controls thread executionclass FactorialThread extends Thread private i

4、nt num; public FactorialThread( int num ) this.num=num; public void run() int i=num; int result=1; while(i0) result=result*i; i=i-1; System.out.println(The factorial of +num+ is +result); System.out.println(new thread ends); ,6,/ class FactorialThread contr,运行结果如下：main thread startsnew thread starte

5、d,main thread endsThe factorial of 10 is 3628800new thread ends,7,运行结果如下：7,例8_2 创建3个新线程，每个线程睡眠任意0-6秒钟，然后结束。,ublic class Ex8_2 public static void main( String args ) /创建并命名每个线程 TestThread thread1 = new TestThread( thread1 ); TestThread thread2 = new TestThread( thread2 ); TestThread thread3 = new Tes

6、tThread( thread3 ); System.out.println( Starting threads ); thread1.start(); / 启动线程1 thread2.start(); / 启动线程2 thread3.start(); / 启动线程3 System.out.println( Threads started, main endsn ); ,线 程 基 础,8,例8_2 创建3个新线程，每个线程睡眠任意0-6秒钟，然后结,class TestThread extends Thread private int sleepTime; public TestThread

7、( String name )/构造函数 super( name ); /调用基类构造函数为线程命名 /获得随机休息毫秒数 sleepTime = ( int ) ( Math.random() * 6000 ); public void run() /线程启动并开始运行后要执行的方法 try System.out.println( getName() + going to sleep for + sleepTime ); Thread.sleep( sleepTime ); /线程休眠 catch ( InterruptedException exception ) ; /运行结束，给出提示

8、信息 System.out.println( getName() + finished ); ,9,class TestThread extends Threa,运行结果为：Starting threadsThreads started, main endsthread1 going to sleep for 3519thread2 going to sleep for 1689thread3 going to sleep for 5565thread2 finishedthread1 finishedthread3 finished,10,运行结果为：10,Runnable接口,如果希望一个

9、已经有基类的类支持多线程，则不能再继承Thread类了（Java不支持多继承）解决方法：使类实现Runnable接口，再与Thread类结合使用一个内部类提供Runnable的实现代码，将内部类的对象与Thread结合相对于Thread类，它更适合于多个线程处理同一资源,线 程 基 础,11,Runnable接口如果希望一个已经有基类的类支持多线程，则,例8_3 使用Runnable接口实现例8_1功能,public class Ex8_1 public static void main( String args ) System.out.println(main thread starts)

10、; FactorialThread t=new FactorialThread(10); new Thread(t).start(); System.out.println( new thread started,main thread ends ); / end main ,线 程 基 础,12,例8_3 使用Runnable接口实现例8_1功能publi,/ class FactorialThread controls thread executionclass FactorialThread implements Runnable private int num; public Fact

11、orialThread( int num ) this.num=num; public void run() int i=num; int result=1; while(i0) result=result*i; i=i-1; System.out.println(The factorial of +num+ is +result); System.out.println(new thread ends); ,13,/ class FactorialThread contr,例8_4 使用Runnable接口实现例8_2功能,ublic class Ex8_4 public static vo

12、id main( String args ) /创建3个实现Runnable接口类的对象 TestThread thread1 = new TestThread(); TestThread thread2 = new TestThread(); TestThread thread3 = new TestThread(); System.out.println( Starting threads ); /分别以三个对象为参数创建三个新线程， /第二个参数为新线程命名并启动之 new Thread(thread1,Thread1).start(); new Thread(thread2,Threa

13、d2).start(); new Thread(thread3,Thread3).start(); System.out.println( Threads started, main endsn ); ,线 程 基 础,14,例8_4 使用Runnable接口实现例8_2功能publi,class TestThread implements Runnable private int sleepTime; public TestThread() /构造方法 /获得随机休息毫秒数 sleepTime = ( int ) ( Math.random() * 6000 ); public void r

14、un() /线程启动并开始运行后要执行的方法 try System.out.println( Thread.currentThread().getName() + going to sleep for + sleepTime ); Thread.sleep( sleepTime ); /线程休眠 catch ( InterruptedException exception ) ; /运行结束，给出提示信息 System.out.println( Thread.currentThread().getName() + finished ); ,15,class TestThread impleme

15、nts Ru,运行结果如下：Starting threadsThread1 going to sleep for 1487Thread2 going to sleep for 1133Threads started, main endsThread3 going to sleep for 2328Thread2 finishedThread1 finishedThread3 finished,16,运行结果如下：16,资源共享和线程同步,独立的同时运行的线程有时需要共享一些数据并且考虑到彼此的状态和动作。例如生产/消费问题：生产线程产生数据流，然后这些数据流再被消费线程消费。具体来说，假设一个

16、Java应用程序，其中有一个线程负责往文件写数据，另一个线程从同一个文件中往出都数据，因为涉及到同一个资源，这里是同一个文件，这两个线程必须保证某种方式的同步。当多个线程的执行代码来自同一个类的实例（若干个）时，即称它们共享相同的代码，当共享访问相同的对象时，即它们共享相同的数据。使用Runnable接口可以轻松实现多个线程共享相同数据，只要用同一个实现了Runnable接口的实例作为参数创建多个线程就可以了。,线 程 基 础,17,资源共享和线程同步独立的同时运行的线程有时需要共享一些数据并,例8_5 修改例8_4,/只用一个Runnable类型的对象为参数创建3个新线程。public cl

17、ass Ex8_5 public static void main( String args ) /只创建1个实现Runnable接口类的对象 TestThread thread = new TestThread(); System.out.println( Starting threads ); /只用一个Runnable类型对象为参数创建三个新线程， /命名并启动之 new Thread(thread,Thread1).start(); new Thread(thread,Thread2).start(); new Thread(thread,Thread3).start(); Syste

18、m.out.println( Threads started, main endsn ); ,线 程 基 础,18,例8_5 修改例8_4/只用一个Runnable类型的对象,class TestThread implements Runnable private int sleepTime; public TestThread()/构造函数 /获得随机休息毫秒数 sleepTime = ( int ) ( Math.random() * 6000 ); public void run() /线程启动并开始运行后要执行的方法 try System.out.println( Thread.cur

19、rentThread().getName() + going to sleep for + sleepTime ); Thread.sleep( sleepTime ); /线程休眠 catch ( InterruptedException exception ) ; /运行结束，给出提示信息 System.out.println( Thread.currentThread().getName() + finished ); ,19,class TestThread implements Ru,Starting threadsThread1 going to sleep for 966Thre

20、ad2 going to sleep for 966Threads started, main endsThread3 going to sleep for 966Thread1 finishedThread2 finishedThread3 finished,20,Starting threads20,例8_6 用三个线程模拟三个售票口，总共出售200张票。,ublic class Ex8_6public static void main(String args) /新建一个售票类的对象SellTickets t=new SellTickets(); /用此对象作为参数创建3个新线程并启动n

21、ew Thread(t).start(); new Thread(t).start();new Thread(t).start();,线 程 基 础,21,例8_6 用三个线程模拟三个售票口，总共出售200张票。pu,class SellTickets implements Runnable /将共享的资源作为私有变量 private int tickets=200; public void run() while(tickets0) /直到没有票可售为止 System.out.println( Thread.currentThread().getName() + is selling tic

22、ket +tickets-); ,22,class SellTickets implements R,例8_7 用两个线程模拟存票、卖票过程,ublic class Ex8_7public static void main(String args) /新建一个票类对象，总票数作为参数 Tickets t=new Tickets(10); /以票类对象为参数创建存票线程对象，并启动 new Producer(t).start(); /以同一个票类对象为参数创建售票线程，并启动 new Consumer(t).start(); ,线 程 基 础,23,例8_7 用两个线程模拟存票、卖票过程publ

23、ic clas,class Tickets /票类int number=0; /票号int size; /总票数 /表示目前是否有票可售boolean available=false; /构造方法，传入总票数参数 public Tickets(int size)this.size=size; ,24,class Tickets /票类24,class Producer extends Thread /存票线程Tickets t=null;public Producer(Tickets t) /构造函数以一个票类对象为参数 this.t=t; public void run() /限制循环条件为

24、存票序号小于总票数 while(t.number)t.size) System.out.println(Producer puts ticket +(+t.number); t.available=true; /可以卖票 ,25,class Producer extends Thread,class Consumer extends Thread /售票线程Tickets t=null;int i=0;public Consumer(Tickets t) /构造函数以一个票类对象为参数 this.t=t;public void run() while(it.size) /循环条件为售票序号小于

25、总票数 if(t.available=true ,26,class Consumer extends Thread,运行结果Producer puts ticket 1Producer puts ticket 2Producer puts ticket 3Producer puts ticket 4Producer puts ticket 5Producer puts ticket 6Producer puts ticket 7Producer puts ticket 8Consumer buys ticket 1Consumer buys ticket 2Consumer buys tick

26、et 3Consumer buys ticket 4Consumer buys ticket 5Consumer buys ticket 6Consumer buys ticket 7Consumer buys ticket 8Producer puts ticket 9Producer puts ticket 10死机（进入死循环）,27,运行结果27,错误原因,假如售票线程运行到t.available=false之前，CPU切换到执行存票线程，存票线程将available置为true，但再次切换到售票线程后，售票线程执行t.available=false，则由于售票号目前还是8，小于总票数

27、，且存票线程已经结束不再能将t.available置为true，则售票线程陷入了死循环。,线 程 基 础,28,错误原因假如售票线程运行到t.available=false,线程同步（Synchronization）,Java 使用的同步机制是监视器，支持线程的互斥与同步互斥：许多线程在同一个共享数据上操作而互不干扰，同一时刻只能有一个线程访问该共享数据。因此有些方法或程序段在同一时刻只能被一个线程执行，称之为监视区。协作：多个线程可以有条件地同时操作共享数据执行监视区代码的线程在条件满足的情况下可以允许其它线程进入监视区。,线 程 基 础,29,线程同步（Synchronization）Ja

28、va 使用的同,线程间的通信,线程同步关键字synchronized用于指定需要同步的代码段或方法，也就是监视区。wait() 当前状态不适合本线程执行时，进入等待状态notify()随机唤醒一个等待的线程，本线程继续执行。notifyAll()唤醒所有等待的线程，本线程继续执行。,线 程 基 础,30,线程间的通信线程同步关键字synchronized线 程,线程间的通信,线程被唤醒以后，还要等发出唤醒消息者释放监视器，这期间关键数据仍可能被改变。被唤醒线程的线程可能有多个。（使用notifyAll时）。被唤醒的线程开始执行时，一定要判断当前状态是否适合自己运行。,线 程 基 础,31,线程

29、间的通信线程被唤醒以后，还要等发出唤醒消息者释放监视器，,例8_8 实现例8_7功能。,将同步方法放在共享的资源类Tickets中。public class Ex8_8public static void main(String args) Tickets t=new Tickets(10); new Producer(t).start(); new Consumer(t).start();,线 程 基 础,32,例8_8 实现例8_7功能。将同步方法放在共享的资源类Tic,class Tickets int size; /票总数 int number=0; /存票序号 int i=0; /售

30、票序号 boolean available=false; /是否有待售的票 public Tickets(int size) this.size=size; public synchronized void put() /同步代码块，实现存票的功能 System.out.println(Producer puts ticket +(+number); available=true; public synchronized void sell() /同步代码块，实现售票的功能 if(available=true ,33,class Tickets33,class Consumer extends

31、 Thread Tickets t=null; /构造方法，使两线程共享票类对象public Consumer(Tickets t) this.t=t; public void run() /如果售票数小于限定总量，则不断售票 while(t.it.size)t.sell(); ,34,class Consumer extends Thread3,例8_9 每存入一张票，就售一张票，售出后，再存入,public class Ex8_8public static void main(String args)Tickets t=new Tickets(10);new Producer(t).sta

32、rt();new Consumer(t).start();,线 程 基 础,35,例8_9 每存入一张票，就售一张票，售出后，再存入publi,class Ticketsint size;int number=0;int i=0;boolean available=false;public Tickets(int size) this.size=size; public synchronized void put() if(available) /如果还有存票待售，则存票线程等待 trywait(); catch(Exception e) System.out.println(Producer

33、 puts ticket +(+number); available=true; notify();./存票后唤醒售票线程开始售票,36,class Tickets36,ublic synchronized void sell() if(!available) /如果没有存票，则售票线程等待 trywait(); catch(Exception e) if(i=number) System.out.println(Consumer buys ticket +(+i); if(i=number) try Thread.sleep(1); catch(Exception e) available=

34、false; notify(); /售票后唤醒存票线程开始存票,37,public synchronized void sell,class Producer extends ThreadTickets t=null;public Producer(Tickets t)this.t=t;public void run()while(t.numbert.size)t.put();,38,class Producer extends Thread3,class Consumer extends ThreadTickets t=null;public Consumer(Tickets t)this.

35、t=t;public void run()while(t.it.size)t.sell();,39,class Consumer extends Thread3,运行结果如下：Producer puts ticket 1Consumer buys ticket 1Producer puts ticket 2Consumer buys ticket 2Producer puts ticket 3Consumer buys ticket 3Producer puts ticket 4Consumer buys ticket 4Producer puts ticket 5Consumer buys

36、ticket 5Producer puts ticket 6Consumer buys ticket 6Producer puts ticket 7Consumer buys ticket 7Producer puts ticket 8Consumer buys ticket 8Producer puts ticket 9Consumer buys ticket 9Producer puts ticket 10Consumer buys ticket 10,40,运行结果如下：40,守护（Daemon）线程,为了辅助其它线程而运行的线程不妨碍程序终止“垃圾回收”便是一个守护线程用setDaem

37、on方法将线程设置为守护线程,线 程 基 础,41,守护（Daemon）线程为了辅助其它线程而运行的线程线 程,例8_10 创建一个无限循环的守护线程,public class Ex8_10public static void main(String args)ThreadTest t=new ThreadTest();t.setDaemon(true);t.start();class ThreadTest extends Threadpublic void run()while(true) ,42,例8_10 创建一个无限循环的守护线程public clas,线程的状态,诞生状态线程刚刚被创

38、建就绪状态线程的 start 方法已被执行线程已准备好运行运行状态处理机分配给了线程，线程正在运行阻塞状态（Blocked）在线程发出输入/输出请求且必须等待其返回，或遇到用synchronized标记的方法而未获得其监视器暂时不能进入执行时休眠状态（Sleeping）执行sleep方法而进入休眠死亡状态线程已完成或退出,线程的生命周期,43,线程的状态诞生状态线程的生命周期43,44,44,线程优先级与调度,Java 线程优先级（ priority ）取值范围 1-10时间片（Timeslicing）每个线程被赋予一定的处理机时间总是调度最高优先级的线程运行,45,线程优先级与调度Java 线程优先级（ priority ）,