第16章多线程ppt课件.ppt

《第16章多线程ppt课件.ppt》由会员分享，可在线阅读，更多相关《第16章多线程ppt课件.ppt（69页珍藏版）》请在三一文库上搜索。

1、第16章 多线程,本章要点,了解多线程在Windows系统的执行模式 掌握实现线程的两种方式 掌握线程的状态 掌握使线程进入各种状态的方法 掌握线程的优先级 掌握线程安全 掌握线程同步机制 掌握线程间的通信,第16章 多线程,1、线程简介 2、实现线程的两种方法 3、线程的生命周期 4、操作线程的方法 5、线程的优先级 6、线程同步 7、线程间的通信,主要内容,16.1 线程简介,世间万物会同时完成很多工作： 例如人体同时进行呼吸、血液循环、思考问题等活动； 用户既可以使用计算机听歌，也可以使用它打印文件， 而这些活动完全可以同时进行，这种思想在Java中被称为并发，而将并发完成的每一件事情称

2、为线程。,16.1 线程简介,在人们的生活中，并发机制非常重要，但是并不是所有的程序语言都支持线程。 在以往的程序中，多以一个任务完成后再进行下一个项目的模式进行开发，这样下一个任务的开始必须等待前一个任务的结束。 Java语言提供并发机制，程序员可以在程序中执行多个线程，每一个线程完成一个功能，并与其他线程并发执行，这种机制被称为多线程。,16.1 线程简介,Java中的多线程在每个操作系统中的运行方式也存在差异，在此着重说明多线程在Windows操作系统的运行模式。 Windows操作系统是多任务操作系统，它以进程为单位。 一个进程是一个包含有自身地址的程序，每个独立执行的程序都称为进程，

3、也就是正在执行的程序。,16.1 线程简介,进程是一个用来描述处于动态运行状态的应用程序的概念，即一个进程就是一个执行中的程序，每个进程都有一块自己独立的地址空间，并可以包含多个线程。这些线程将共享进程的地址空间及操作系统分配给这个进程的资源。 线程一般是指进程中的一个执行流，多线程是指在一个进程中同时运行多个不同线程，每个线程分别执行不同的任务。,16.1 线程简介,系统可以分配给每个进程一段有限的使用CPU的时间（也可以称为CPU时间片），CPU在这段时间中执行某个进程，然后下一个时间片又跳至另一个进程中去执行。 由于CPU转换较快，所以使得每个进程好像是同时执行一样。,16.1 线程简介

4、,Windows操作系统的执行模式,16.1 线程简介,一个线程则是进程中的执行流程，一个进程中可以同时包括多个线程，每个线程也可以得到一小段程序的执行时间，这样一个进程就可以具有多个并发执行的线程。 在单线程中，程序代码按调用顺序依次往下执行，如果需要一个进程同时完成多段代码的操作，就需要产生多线程。,16.2 实现线程的两种方式,16.2.1 继承Thread类 16.2.2 实现Runnable接口,16.2.1 继承Thread类,Thread类是java.lang包中的一个类，从这个类中实例化的对象代表线程，程序员启动一个新线程需要建立Thread实例。 Thread类中常用的两个构

5、造方法如下： public Thread(String threadName); public Thread(); 其中第一个构造方法是创建一个名称为threadName的线程对象。,16.2.1 继承Thread类,继承Thread类创建一个新的线程的语法如下： public class ThreadTest extends Thread /. ,16.2.1 继承Thread类,如果需要创建线程应该先定义一个Thread类的子类，并且覆盖其中的run()成员方法，将线程执行的程序代码写在其中。 Thread对象需要一个任务来执行，任务是指线程在启动时执行的工作，该工作的功能代码被写在run

6、()方法中。,16.2.1 继承Thread类,这个run()方法必须使用如下这种语法格式： public void run() /. 注意：尽管在Thread的子类中覆盖了run()成员方法，但用户不能直接调用它，而是需要通过调用Thread类中的start()方法间接地使用它。,16.2.1 继承Thread类注意,1）start()方法的调用后并不是立即执行多线程代码，而是使得该线程变为可运行态(Runnable)，什么时候运行是由操作系统决定的。 2）如果start()方法调用一个已经启动的线程，系统将抛出IllegalThreadStateException异常。,16.2.1 继承

7、Thread类注意,main()方法线程启动由Java虚拟机负责，程序员负责启动自己的线程。语法如下： public static void main(String args) new ThreadTest().start(); ,public class MyThread extends Thread public void run() for(int n=1;n3;n+) for(int i=1;i4;i+) System.out.print(getName()+“(“+i+“) “); System.out.println(); System.out.println(“exit from

8、 “+getName(); ,创建两个线程对象，分别实现重复显示13数字的功能,public class Test public static void main(String args) Thread t1=new MyThread(); t1.setName(“T1“); Thread t2=new MyThread(); t2.setName(“T2“); t1.start(); t2.start(); System.out.println(“exit from “+Thread.currentThread().getName(); ,exit from main T2(1) T1(1)

9、 T1(2) T1(3) T2(2) T1(1) T1(2) T1(3) T2(3) exit from T1 T2(1) T2(2) T2(3) exit from T2,16.2.2 实现Runnable接口,到目前为止，线程都是通过扩展Thread类来创建的，如果程序员需要继承其他类(非Thread类)并使该程序可以使用线程，就需要使用Runnable接口。 实现Runnable接口的语法如下： public class MyThread extends Object implements Runnable,16.2.2 实现Runnable接口,实现Runnable接口的程序会创建一个

10、Thread对象，并将Runnable对象与Thread对象相关联。 Thread类中有如下两个构造方法： public Thread(Runnable r) public Thread(Runnable r,String name) 这两个构造方法的参数中都存在Runnable实例，使用以上构造方法就可以将Runnable实例与Thread实例相关联。,16.2.2 实现Runnable接口,使用Runnable接口启动新的线程的步骤如下： 1）建立Runnable对象。 2）使用参数为Runnable对象的构造方法创建Thread实例。 3）调用start()方法启动线程。,16.2.2

11、实现Runnable接口,16.2.2 实现Runnable接口,通过Runnable接口创建线程时首先需要编写一个实现Runnable接口的类，然后实例化该类的对象，这样就建立了Runnable对象； 接下来使用相应的构造方法创建Thread实例； 最后使用该实例调用Thread类中的Start()方法启动线程。,class MyThread2 implements Runnable private String name; public MyThread2(String name) this.name=name; public void run() for(int i=1;i10;i+)

12、System.out.println(name + “运行 : “+i); ,public static void main(String args) new Thread(new MyThread2(“th1“).start(); new Thread(new MyThread2(“th2“).start(); /*MyThread2 th1=new MyThread2(“th1“); Thread thobj1=new Thread(th1); MyThread2 th2=new MyThread2(“th2“); Thread thobj2=new Thread(th2); thobj1

13、.start(); thobj2.start();*/ ,16.2.2 实现Runnable接口,实现Runnable接口比继承Thread类所具有的优势： 适合多个相同的程序代码的线程去处理同一个资源 可以避免java中的单继承的限制 增加程序的健壮性，代码可以被多个线程共享，代码和数据独立,16.3 线程的生命周期,线程生命周期中的各种状态,16.3 线程的生命周期,线程具有生命周期，其中包含7种状态，分别为出生状态、就绪状态、运行状态、等待状态、休眠状态、阻塞状态和死亡状态。 出生状态就是用户在创建线程时处于的状态，在用户使用该线程实例调用start()方法之前线程都处于出生状态； 当用

14、户调用start()方法后，线程处于就绪状态（又被称为可执行状态）； 当线程得到系统资源后就进入运行状态。,16.3 线程的生命周期,一旦线程进入可执行状态，它会在就绪与运行状态下辗转，同时也有可能进入等待、休眠、阻塞或死亡状态。 当处于运行状态下的线程调用Thread类中的wait()方法，该线程处于等待状态，进入等待状态的线程必须调用Thread类中的notify()方法才能被唤醒，而notifyAll()方法是将所有处于等待状态下的线程唤醒；,16.3 线程的生命周期,当线程调用Thread类中的sleep()方法，则会进入休眠状态。 如果一个线程在运行状态下发出输入/输出请求，该线程将

15、进入阻塞状态，在其等待输入/输出结束时线程进入就绪状态，对于阻塞的线程来说，即使系统资源空闲，线程依然不能回到运行状态； 当线程的run()方法执行完毕时，线程进入死亡状态。,16.3 线程的生命周期,虽然多线程看起来像同时执行，但事实上在同一时间点上只有一个线程被执行，只是线程之间切换较快，所以才会使人产生线程是同时进行的假象。 在Windows操作系统中，系统会为每个线程分配一小段CPU时间片，一旦CPU时间片结束就会将当前线程换为下一个线程，即使该线程没有结束的情况下。,16.3 线程的生命周期,根据图16-5所示，可以总结出使线程进入阻塞状态有以下几种可能。 调用sleep()方法。

16、调用wait()方法。 等待输入/输出完成。,16.3 线程的生命周期,当线程处于阻塞状态后，可通过以下几种方式使线程再次进入就绪状态。 线程调用notify()方法。 线程调用notifyAll()方法。 线程调用interrupt()方法。 线程的休眠时间结束。 输入/输出结束。,16.4 操作线程的方法,16.4.1 线程的休眠 16.4.2 线程的加入 16.4.3 线程的中断 16.4.4 线程的礼让,16.4.1 线程的休眠,一种能控制线程行为的方法是调用sleep()方法，sleep()方法需要一个参数用于指定该线程休眠的时间，该时间使用毫秒为单位。 它通常是在run()方法内的

17、循环中被使用。 sleep()方法的语法如下： try Thread.sleep(2000); catch(InterruptedException e) e.printStackTrace(); ,public void run() System.out.println(“开始执行线程。“); System.out.println(“进入睡眠状态。“); try Thread.sleep(3000); catch (InterruptedException e) e.printStackTrace(); System.out.println(“线程结束。“); ,16.4.2 线程的加入,如

18、果当前某程序为多线程程序，假如存在一个线程A，现在需要插入线程B，并要求线程B先执行完毕，然后再继续执行线程A，此时可以使用Thread类中的join()方法来完成。 这就好比此时正在看电视，却突然有人上门收水费，必须付完水费后才能继续看电视。 当某个线程使用join()方法加入到另外一个线程时，另一个线程会等待该线程执行完毕再继续执行。,16.4.2 线程的加入,为什么要用join()方法 在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束， 但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之

19、后再结束，这个时候就要用到join()方法了。,class Thread1 extends Thread private String name; public Thread1(String name) this.name=name; public void run() for (int i = 0; i 3; i+) System.out.println(“子线程“+name + “运行:“ + i); try sleep(int) Math.random() * 10); catch (InterruptedException e) e.printStackTrace(); ,public

20、 static void main(String args) System.out.println(Thread.currentThread().getName()+ “主线程运行开始!“); Thread1 mTh1=new Thread1(“A“); Thread1 mTh2=new Thread1(“B“); mTh1.start(); mTh2.start(); System.out.println(Thread.currentThread().getName()+ “主线程运行结束!“); ,main主线程运行开始! main主线程运行结束! 子线程B运行 : 0 子线程A运行 :

21、0 子线程B运行 : 1 子线程A运行 : 1 子线程B运行 : 2 子线程A运行 : 2,public static void main(String args) Thread1 mTh1=new Thread1(“A“); Thread1 mTh2=new Thread1(“B“); mTh1.start(); mTh2.start(); try mTh1.join(); mTh2.join(); catch (InterruptedException e) e.printStackTrace(); ,main主线程运行开始! 子线程B运行 : 0 子线程B运行 : 1 子线程B运行 :

22、2 子线程A运行 : 0 子线程A运行 : 1 子线程A运行 : 2 main主线程运行结束!,16.4.3 线程的中断,以前使用stop()方法停止线程，但当前版本的JDK早已废除了stop()方法，同时也不建议使用stop()方法来停止一个线程的运行。 现在提倡在run()方法中使用无限循环的形式，然后使用一个布尔型标记控制循环的停止。,class ThreadTest extends Thread private int count = 10; public void run() while (true) System.out.print(count + “ “); if (-count

23、 = 0) return; ,16.4.4 线程的礼让,Thread类中使用yield()方法表示礼让，它只是给当前正处于运行状态下的线程一个提醒，告知它可以将资源礼让给其他线程。但这仅仅是一种暗示，没有任何一种机制保证当前线程会将资源礼让。 对于支持多任务的操作系统来说，不需要调用yeild()方法，因为操作系统会为线程自动分配CPU时间片来执行。,16.5 线程的优先级,每个线程都具有各自的优先级，线程的优先级可以在程序中表明该线程的重要性，如果有很多线程处于就绪状态，系统会根据优先级来决定首先使哪个线程进入运行状态。 但这并不意味着低优先级的线程得不到运行，而只是它运行的几率比较小，比如

24、垃圾回收线程的优先级就较低。,16.5 线程的优先级,Thread类中包含的静态成员变量代表了线程的某些优先级，比如Thread.MIN_PRIORITY（常数1）、Thread.MAX_PRIORITY（常数10）、Thread.NORM_PRIORITY（常数5）。 其中每个线程的优先级都在Thread.MIN_PRIORITY Thread.MAX_PRIORITY之间，在默认情况下其优先级都是Thread.NORM_ PRIORITY。每个新产生的线程都继承了父线程的优先级。,16.5 线程的优先级,在多任务操作系统中，每个线程都会得到一小段CPU时间片运行，在时间结束时，将轮换另一个

25、线程进入运行状态，这时系统会选择与当前线程优先级相同的线程予以运行。 系统始终选择就绪状态下优先级较高的线程进入运行状态。 线程的优先级可以使用setPriority()方法调整，如果使用该方法设置的优先级不在110之内，将产生一个IllegalArgumentException异常。,16.5 线程的优先级,16.5 线程的优先级,在图16-9中，优先级为5的线程A首先得到CPU时间片；当该时间结束后，轮换到与线程A相同优先级的线程B；当线程B的运行时间结束后，会继续轮换到线程A， 直到线程A与线程B都执行完毕，才会轮换到线程C；当线程C结束后，最后才会轮到线程D。,class MyThre

26、ad51 extends Thread public MyThread51(String name) super(name); public void run() for (int i=0; i5; i+) System.out.println(Thread.currentThread().getName() +“(“+Thread.currentThread().getPriority()+ “)“ +“, loop “+i); ,public static void main(String args) System.out.println(Thread.currentThread().ge

27、tName() +“(“+Thread.currentThread().getPriority()+ “)“); Thread t1=new MyThread51(“t1“); Thread t2=new MyThread51(“t2“); t1.setPriority(1); t2.setPriority(10); t1.start(); t2.start(); ,main(5) t1(1), loop 0 t1(1), loop 1 t1(1), loop 2 t1(1), loop 3 t1(1), loop 4 t2(10), loop 0 t2(10), loop 1 t2(10),

28、 loop 2 t2(10), loop 3 t2(10), loop 4,16.6 线程同步,16.6.1 线程安全 16.6.2 线程同步机制,16.6.1 线程安全,所以在编写多线程程序时，应该考虑到线程安全问题。实质上线程安全问题来源于两个线程同时存取单一对象的数据。 在一个时刻只能被一个线程访问的资源称为临界资源，而访问临界资源的那段代码被称为临界区。 临界区的使用必须互斥地进行，即一个线程在临界区中执行代码时，其他线程不能进入临界区。,16.6.1 线程安全,在代码中判断当前票数是否大于0，如果大于0则执行将该票出售给乘客功能， 但当两个线程同时访问这段代码时（假如这时只剩下一张票

29、），第一个线程将票售出，与此同时第二个线程也已经执行完成判断是否有票的操作，并得出结论票数大于0，于是它也执行售出操作，这样就会产生负数。,class ThreadSafeTest implements Runnable int num = 10; / 设置当前总票数 public void run() while (num 0) try Thread.sleep(100); catch (Exception e) e.printStackTrace(); System.out.println(“tickets“+num-); ,public static void main(String a

30、rgs) ThreadSafeTest t = new ThreadSafeTest(); Thread tA = new Thread(t); / 以该类对象分别实例化4个线程 Thread tB = new Thread(t); Thread tC = new Thread(t); Thread tD = new Thread(t); tA.start(); / 分别启动线程 tB.start(); tC.start(); tD.start(); ,tickets10 tickets8 tickets9 tickets7 tickets6 tickets4 tickets5 tickets

31、6 tickets3 tickets2 tickets1 tickets0 tickets-1 tickets-2,16.6.2 线程同步机制,如何解决资源共享的问题？ 基本上所有解决多线程资源冲突问题都会采用给定时间只允许一个线程访问共享资源，这时就需要给共享资源上一道锁。 为了解决多线程并发操作可能引起的数据混乱，在java中，引入对象“互斥锁”，以保证共享数据操作的完整性。,16.6.2 线程同步机制,1) 同步块 在Java中提供了同步机制，可以有效地防止资源冲突。 同步机制使用synchronized关键字。 synchronized (Object) ,Object为任意一个对象,

32、每个对象都存在一个标志位,并具有两个值,分别为0和1。 一个线程运行到同步块时首先检查该对象的标志位，如果为0状态，表明此同步块中存在其他线程在运行。 这时该线程就处于就绪状态，直到处于同步块中的线程执行完同步块中的代码为止。 这时该对象的标识位被设置为1，该线程才能执行同步块中的代码，并将Object对象的标识位设置为0，防止其他线程执行同步块中的代码。,public void run() synchronized (“) while (num 0) try Thread.sleep(100); catch (Exception e) e.printStackTrace(); System.

33、out.println(“tickets“+num-); ,16.6.2 线程同步机制,2) 同步方法 同步方法就是在方法前面修饰synchronized关键字的方法，其语法如下。 synchronized void f() 当某个对象调用了同步方法，该对象上的其他同步方法必须等待该同步方法执行完毕才能被执行。必须将每个能访问共享资源的方法修饰为synchronized，否则就会出错。,16.6.2 线程同步机制,无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁。 每个对象只有一个锁（lock）与之相关联。 实现同步是要很大的系统开销作为

34、代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。,16.7 线程间的通信,线程之间的通信使用wait()、notify()以及notifyAll()方法实现。 线程调用wait()方法后可以使该线程从运行状态进入就绪状态，sleep()方法也达到这样一个效果，那么两者究竟有何区别？ 从同步的角度上来说，调用sleep()方法的线程不释放锁，但调用wait()方法的线程释放锁。,16.7 线程间的通信,使用wait()方法有以下两种形式： wait(time) wait() 第一种形式的wait()方法与sleep()方法的含义相同，都是指在此时间之内暂停； 而第二种形式的wait()方法

35、会使线程永久无限地等待下去，需要使用notify()或者notifyAll()方法唤醒。,16.7 线程间的通信,notify()方法用来唤醒一个处于阻塞状态的线程，任何一个已经满足了被唤醒条件的线程都可能被唤醒。 notifyAll()方法可以唤醒所有处于等待状态的线程。,wait和sleep区别,共同点： 1. 他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。 2. wait()和sleep()都可以通过interrupt()方法 打断线程的暂停状态 ，从而使线程立刻抛出InterruptedException。,wait和sleep区别,如果线程A希望立即结束线程

36、B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep /join，则线程B会立刻抛出InterruptedException，在catch() 中直接return即可安全地结束线程。,wait和sleep区别,不同点： 1. Thread类的方法：sleep(),yield()等 Object的方法：wait()和notify()等 2. 每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。 sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。,wait和sleep区别,不同点： 3. wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用 4. sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常,