《线程和多线程》PPT课件.ppt

第13章 线 程,线程和多线程,线程的概念在程序开始投入运行时，系统从程序入口开始按语句的顺序(其中包括顺序、分支和循环)完成相应指令直至结尾，从出口退出，同时整个程序结束。这样的语句结构称之为进程，或者说进程就是程序在处理机中的一次运行。,线程的概念,一个进程既包括其所要执行的指令，也包括了执行指令所需的任何系统资源，如CPU、内存空间、I/O端口等，不同进程所占用的系统资源相对独立。,线程的概念,目前所流行的操作系统中，大部分都是支持多任务的(如Windows 3.X，Windows NT，Windows 95，OS/2及UNIX的各个版本)，这实际就是一种多进程的概念每一个任务就是一个进程。,线程的概念,线程是比进程单位更小的执行单位，在形式上同进程十分相似都是用一个顺序执行的语句序列来完成特定的功能。线程没有入口，也没有出口，因此其自身不能自动运行，而必须栖身于某一进程之中，由进程触发执行。,线程的概念,在系统资源的使用上，属于同一进程的所有线程共享该进程的系统资源，但是线程之间切换的速度比进程切换要快得多。,线程的概念,从微观上讲，一个时间里只能有一个作业被执行，在宏观上可使多个作业被同时执行，即等同于要让多台计算机同时工作，使系统资源特别是CPU的利用率得到提高，从而提高了整个程序的执行效率。,线程的概念,为了达到多线程的效果，Java语言把线程或执行环境（execution context）当作一种拥有自己的程序代码和数据的对CPU的封装单位，由虚拟机提供控制。Java类库中的类java.lang.Thread允许创建并控制所创建的线程。,线程的结构,下图是线程运行机制示意图：,线程的结构,线程包含三个主要部分:虚拟CPU本身，CPU执行的代码，代码操作的数据。,线程的结构,在Java中，虚拟CPU体现于Thread类中。当一个线程被构造时，它由构造方法参数、执行代码、操作数据来初始化。,创建线程一继承Thread类,将一个类定义为Thread的子类，那么这个类就可以用来表示线程。应用这种形式的构造方法创建线程对象时不用给出任何参数。这个类中有一个至关重要的方法public void run()，这个方法称为线程体，它是整个线程的核心，线程所要完成任务的代码都定义在线程体中，实际上不同功能的线程之间的区别就在于它们线程体的不同。,程序13-1,public class myThread extends Threadpublic void run()while(running)/执行若干操作sleep(100);public static void main(String args)Thread t=new myThread();/执行若干操作,创建线程二实现Runnable接口,Runnable是Java中用以实现线程的接口，从根本上讲，任何实现线程功能的类都必须实现该接口。Runnable接口中只定义了一个方法就是run()方法，也就是线程体。,创建线程二实现Runnable接口,Thread第二种构造方法中包含有一个Runnable实例的参数，这就是说，必须定义一个实现Runnable接口的类并产生一个该类的实例，对该实例的引用就是适合于这个构造方法的参数。,程序 13-2,public class xyz implements Runnableint i;public void run()while(true)System.out.println(Hello+i+);,程序 13-2,可以构造一个线程如下：Runnable r=new xyz();Thread t=new Thread(r);,线程运行环境,关于两种创建线程方法的讨论,1.适用于采用实现Runnable接口方法的情况因为Java只允许单继承，如果一个类已经继承了Thread，就不能再继承其他类。比如对于Applet程序，由于必须继承了java.applet.Applet，因此就只能采取这种实现接口的方法。由于某些原因而几次被迫采用实现Runnable接口的方法，可能会出于保持程序风格的一贯性而继续使用这种方法。,关于两种创建线程方法的讨论,2.适用于采用继承Thread方法的情况当一个run()方法置于Thread类的子类中时，this实际上引用的是控制当前运行系统 的Thread实例，所以，代码不必写得繁琐：Thread.currentThread().suspend();可简单地写为：suspend();,线程的启动,必须通过方法start()来启动线程，start()方法也在Thread类中。,线程的调度,在一台只具有一个CPU的机器上，CPU在同一时间只能分配给一个线程做一件事。当有多于一个的线程工作时，在Java中，线程调度通常是抢占式，而不是时间片式。抢占式调度是指可能有多个线程准备运行，但只有一个在真正运行。,线程的调度,一个线程获得执行权，这个线程将持续运行下去，直到它运行结束或因为某种原因而阻塞，或者有另一个高优先级线程就绪（这种情况称为低优先级线程被高优先级线程所抢占）。,线程的调度,一个线程被阻塞的原因：因为执行了Thread.sleep()调用，故意让它暂停一段时间；因为需要等待一个较慢的外部设备，例如磁盘或用户。,线程的调度,所有被阻塞的线程按次序排列，组成一个阻塞队列。所有就绪但没有运行的线程则根据其优先级排入一个就绪队列。,线程的调度,当CPU空闲时，如果就绪队列不空，就绪队列中第一个具有最高优先级的线程将运行。当一个线程被抢占而停止运行时，它的运行态被改变并放到就绪队列的队尾；,线程的调度,一个被阻塞（可能因为睡眠或等待I/O设备）的线程就绪后通常也放到就绪队列的队尾。,程序 13-3,public class xyz implements Runnablepublic void run()while(true)/执行若干操作/给其他线程运行的机会tryThread.sleep(10);catch(InterruptedException e)/该线程为其他线程所中断,程序13-3,sleep()是类Thread中的静态方法，因此可以通过Thread.sleep(x)直接引用。参数x指定了线程在再次启动前必须休眠的最小时间，是以毫秒为单位的。同时该方法可能引发中断异常InterruptedException，因此要进行捕获和处理。,程序13-3,除sleep()方法以外，类Thread中的另一个方法yield()可以给其他同等优先级线程一个运行的机会。如果在就绪队列中有其他同优先级的线程，yield()把调用者放入就绪队列尾，并允许其他线程运行；如果没有这样的线程，则yield()不做任何工作。,程序13-3,sleep()调用允许低优先级进程运行，而yield()方法只给同优先级进程以运行机会。,线程的基本控制,结束线程当一个线程从run()方法的结尾处返回时，它自动消亡并不能再被运行，可以将其理解为自然死亡;利用stop()方法强制停止，可以将其理解为强迫死亡，这种方法必须用于Thread类的特定实例中。,程序 13-4,public class xyz implements Runnable/执行线程的主要操作public class ThreadTestpublic static void main(String args)Runnable r=new xyz();Threadt=new Thread(r);t.start();/进行其他操作if(time_to_kill)t.stop();,程序 13-5,可以利用Thread类中的静态方法currentThread()来引用正在运行的线程public class xyz implements Runnablepublic void run()while(true)/执行线程的主要操作if(time_to_die)Thread.currentThread().stop();,检查线程,可以利用方法isAlive()来获取一个线程的活动状态。活动状态不意味着这个线程正在执行，而只说明这个线程已被启动，并且既没有运行stop()，也尚未运行完方法run()。,挂起线程,有几种方法可以用来暂停一个线程的运行。在挂起之后，必须重新唤醒线程进入运行。,挂起线程的方法,1.sleep()它用于暂时停止一个线程的执行。线程不是休眠期满后就立刻被唤醒。重新调度只在以下几种情况下才会发生：被唤醒的线程具有更高的优先级。正在执行的线程因为其他原因被阻塞。程序处于支持时间片的系统中。,挂起线程的方法,2.suspend()和resume()强制挂起线程，而不指定休眠时间，由其他线程负责唤醒其继续执行。线程中有一对方法用于完成此功能，这就是suspend()和resume()。,程序13-6,class xyz implements Runnablepublic void run()/执行线程的主要操作/暂停线程运行Thread.currnetThread().suspend();/继续运行,程序 13-6,class Usexyzpublic static void main(String args)Runnable r=new xyz();Thread t=new Thread(r);t.start();/*暂停当前线程运行，以使xyz的实例得以运行*/Thread.sleep(1000);/*xyz实例被suspend()方法暂停，将控制权返还给主线程，并由主线程重新唤醒线程t*/t.resume();Thread.yield();,程序13-6,线程t在运行到suspend()以后被强制挂起，暂停运行，直到主线程调用t.resume()时才被重新唤醒。一个线程可以被任何一条语句代码所挂起，只要它具有该线程的操作权，即引用它的变量。一个线程只能被不同于它自身的线程所唤醒。,挂起线程的方法,3.join()方法join()将引起现行线程等待，直至方法join所调用的线程结束。,程序13-7,public void timeout()/暂停该线程，等候其他线程(tt)结束tt.join();/其他线程结束后，继续进行该线程,程序13-7说明,这样，在执行方法timeout()以后，现行的线程将被阻塞，直到tt运行结束。join()方法在调用时也可以使用一个以毫秒计的时间值：void join(long timeout);此时join方法将挂起现行线程timeout毫秒，或直到调用的线程结束，实际挂起时间以二者中时间较少的为准。,同步问题,class Stackint idx=0;char data=new char6;public void push(char c)dataidx=c;idx+;public char pop()idx-;return dataidx;,问题的提出,现在设想有两个线程都具有对这个类的同一个对象的引用，一个线程正在把数据推入栈中，而另一个与这个线程独立的线程，正在弹出栈中元素。,问题的提出,问题：假设线程a负责加入字符，线程b负责移出字符。线程a刚刚加入了一个字符，但是尚未递增索引值，由于某种原因，恰恰这时它被抢占了。那么此时该对象代表的数据模式将出现错误。buffer|p|q|r|idx=2,问题的提出,如果线程a被及时唤醒，还没有什么危险，但是如果此时线程b正在等待移出一个字符，当线程a处于等待状态时，线程b就得到了运行机会。这样，在进入方法pop()时，数据状态已经是错误的。pop()方法将继续递减索引值：buffer|p|q|r|idx=1,问题的提出,如果线程a继续运行将得到什么结果：线程a从push()方法中被打断的地方继续运行，递增了索引值，因此有：buffer|p|q|r|inx=2将再也读不到字母“r”了。,问题的提出,可以选择的一种解决方法是禁止线程a在完成代码关键部分时被切换。另一种方法，也是Java采用的方法，就是提供一个特殊的锁定标志来处理数据。,对象的锁定标志,Java可以为每一个对象的实例配有一个标志，这个标志称做“锁定标志”。关键字synchronized提供了操作这个标志的方法。,程序 13-9,class stackint idx=0;char data=new char6;public void push(char c)synchronized(this)dataidx=c;idx+;.,程序13-10,public char pop()synchronized(this)idx-;return dataidx;,对象的锁定标志,下图是线程锁定标志使用示意图:,对象的锁定标志,当持有锁定标志的线程运行完synchronized()调用包含的程序块后，这个标志将会被自动返还。Java保证了该标志通常能够被正确地返还，即使被同步的程序块产生了一个异常，或者某个循环中断跳出了该程序块，这个标志也能被正确返还。,对象的锁定标志,如果一个线程两次调用了同一个对象，在退出最外层后这个标志也将被正确释放，而在退出内层时则不会执行释放。这些规则使得同步程序块的使用比其他系统中等同的操作，如信号灯的管理，要简单得多。,同步方法,synchronized()语句的标准写法为：public void push(char c)synchronized(this),同步方法,synchronized()语句的参数必须是this。Java语言允许使用下面这种简洁的写法：public synchronized void push(char c),同步方法,区别：如果把synchronized用做方法的修饰字，则整个方法都将称为同步块，这可能会使持有锁定标记的时间比实际需要的时间要长，从而降低效率。使用前一种方法来标记可以提醒用户同步在发生，这在避免死锁时非常重要。,死锁,在多线程竞争使用多资源的程序中，有可能出现死锁的情况。这种情况发生在一个线程等待另一个线程所持有的锁，而那个线程又在等待第一个线程持有的锁的时候。,死锁,每个线程都不能继续运行，除非另一线程运行完同步程序块。因为哪个线程都不能继续运行，所以哪个线程都无法运行完同步程序块。,死锁,程序13-11,class classA public classB b;synchronized void methoda()String name=Thread.currentThread().getName();System.out.println(name+“entered classA.methoda.);try Thread.sleep(1000);catch(InterruptedException e)System.out.println(name+trying to call classB.methodb();b.methodb();synchronized void methodb()System.out.println(inside classB.mothedb();,class classB public classA a;synchronized void methoda()String name=Thread.currentThread().getName();System.out.println(name+entered classB.methoda.);try Thread.sleep(1000);catch(InterruptedException e)System.out.println(name+trying to call classA.methodb();a.methodb();synchronized void methodb()System.out.println(inside classB.mothedb();,class DeadLock implements RunnableclassA a=new classA();classB b=new classB();DeadLock()Thread.currentThread().setName(MainThread);a.b=b;b.a=a;new Thread(this).start();a.methoda();System.out.println(back to main thread);,public void run()Thread.currentThread().setName(RacingThread);b.methoda();System.out.println(back to racing thread);public static void main(String args)new DeadLock();,程序 13-11,如果运行该程序就会发现在出现上述信息后发生死锁的情况。Java既不监测也不采取办法避免这种状态，因此保证死锁状态不会发生就成了程序员的职责。,死锁,一个避免死锁发生的办法是：如果有多个对象要被同步，对于获得这些锁的顺序作一个综合决定，并在整个程序中遵循这个顺序。,线程交互wait()和notify(),多个线程常常被创建用来完成不相关的任务，而线程之间有一些交互。,问题的提出,为什么两个线程可能需要交互呢？简单的例子：有两个人，一个在刷盘子，另一个在烘干。这两个人各自代表一个线程，他们之间有一个共享的对象碗橱。每个人都各司其职，显然，碗橱上有刷好的盘子时，烘干的人才能开始工作；而如果刷盘子的人刷得太快，刷好的盘子占满了碗橱时，他就不能再继续工作了，而要等到碗橱上有空位置才行。,解决方法,Java提供了一种建立在对象实例之上的交互方法。Java中的每个对象实例都有两个线程队列和它相连。第一个用来排列等待锁定标志的线程第二个则用来实现wait()和notify()的交互机制。,解决方法,类java.lang.Object中定义了三个方法:wait()，notify()，notifyAll()，,解决方法,wait()和notify()线程a代表刷盘子，线程b代表烘干，它们都有对对象drainingBoard的访问权。假设线程b烘干线程，想要进行烘干工作，而此时碗橱是空的，则应表示如下：if(drainingBoard.isEmpty()drainingBoard.wait();,解决方法,当线程b执行了wait()调用后，它不可再执行，并加入到对象drainingBorad的等待队列中。在有线程将它从这个队列中释放之前，它不能再次运行。,解决方法,烘干线程怎样才能重新运行呢？这应该由洗刷线程来通知它已经有工作可以做了，运行drainningBoard的notify()调用可以做到这一点：drainingBoard.addItem(plate);drainingBoard.notify();此时，drainingBoard的等待队列中第一个阻塞线程由队列中释放出来，并可重新参加运行的竞争。,解决方法,如果等待队列中没有阻塞线程时调用了方法notify()，则这个调用不做任何工作。notify()调用不会被保留到以后再发生效用。方法notify()最多只能释放等待队列中的第一个线程，如果有多个线程在等待，则其他的线程将继续留在队列中。方法notifyAll()能够在程序设计需要时释放所有等待线程。,解决方法,Java中的实现并不像这里所假设的这样简单。特别是，等待队列本身构成了一个特殊的数据结构，需要使用同步机制加以保护。在调用一个对象的wait()，notify()或notifyAll()时，必须首先持有该对象的锁定标志，因此这些方法必须在同步程序块中调用。,解决方法,将代码改变如下：synchronized(drainingBoard)if(drainingBoard.isEmpty()drainingBoard.wait();,解决方法,同样有：synchronized(drainingBoard)drainingBoard.addItem(plate);drainingBoard.notify();,解决方法,另外一个有趣的问题：就是线程执行被同步的语句时需要拥有对象的锁定标志，实际的实现过程中是不会出现这种情况的。Java将首先把锁定标志返回给对象，因此即使一个线程由于执行wait()调用而被阻塞，它也不会影响其他等待锁定标志的线程的运行。,解决方法,当一个线程被notify()后，它并不立即变为可执行状态，而仅仅是从等待队列中移入锁定标志队列中。这样，在重新获得锁定标志之前，它仍旧不能继续运行。另一方面，在实际实现中，方法wait()既可以被notify()终止，也可以通过调用线程的interrupt()方法来终止。后一种情况下，wait()会抛出一个InterruptedException异常，所以需要把它放在try/catch结构中。,解决方法,线程状态及状态转换示意图:,综合应用实例,现在来建立一个经典的生产者/消费者问题的实际例子。提供以下两个接口：public void push(char c);public char pop();,综合应用实例,首先来看生产者。生产者将随机产生20个大写字母并将它们推入栈中，每次推入动作之间有一个随机的延时，延时的范围为0100ms。每个推入的字母将在屏幕上显示。,生产者线程,public void run()char c;for(int i=0;i 20;i+)c=(char)(Math.random()*26+A);theStack.push(c);System.out.println(Produced:+c);tryThread.sleep(int)(Math.random()*100);catch(InterruptedException e),消费者线程,消费者从栈中取出20个字母，每次取出动作之间有延时，这里的延时为02s。这意味着栈的清空比填入要慢，因此栈能够很快被完全填满。,消费者线程,public void run()char c;for(int i=0;i 20;i+)c=theStack.pop();System.out.println(Consuned:+c);try Thread.sleep(int)(Math.random()*1000);catch(InterruptedException e),说明,栈需要一个索引值和一个缓冲区数组，因为本例是要演示缓冲区满时正确的操作和同步方法，所以缓冲区仅设为能容纳6个字母。一个新构造的SyncStack应该为空。,构造类,class SyncStackprivate int index=0;private char buffer=new char6;public synchronized char pop()public synchronized void push(char c),推入和弹出方法,public synchronized void push(char c)while(index=buffer.length)trythis.wait();catch(InterruptedException e)this.notify();buffer index=c;index+;,public synchronized char pop()while(index=0)trythis.wait();catch(InterruptedException e)this.notify();index-;return bufferindex;,程序13-17,/最终的程序代码:SyncTest.javapackage modl3;public class SyncTestpublic static void main(String args)SyncStack stack=new SyncStack();Runnable source=new Producer(stack);Runnable sink=new Consumer(stack);Thread t1=new Thread(source);Thread t2=new Thread(sink);t1.start();t2.start();,/Producer.javapackage modl3;public class Producer implements RunnableSyncStack theStack;public Producer(SyncStack s)theStack=s;public void run()char c;for(int i=0;i 20;i+)c=(char)(Math.random()*26+A);theStack.push(c);System.out.println(Produced:+c);tryThread.sleep(int)(Math.random()*100);catch(InterruptedException e),/Consumer.javapackage modl3;public class Consumer implements RunnableSyncStack theStack;public Consumer(SyncStack s)theStack=s;public void run()char c;for(int i=0;i 20;i+)c=theStack.pop();System.out.println(Consuned:+c);try Thread.sleep(int)(Math.random()*1000);catch(InterruptedException e),/SyncStack.javapackage modl3;public class SyncStackprivate int index=0;private char buffer=new char6;public synchronized void push(char c)while(index=buffer.length)trythis.wait();catch(InterruptedException e)this.notify();bufferindex=c;index+;,public synchronized char pop()while(index=0)trythis.wait();catch(InterruptedException e)this.notify();index-;return buffer index;,