java多线程编程总结-.pdf

《java多线程编程总结-.pdf》由会员分享，可在线阅读，更多相关《java多线程编程总结-.pdf（50页珍藏版）》请在taowenge.com淘文阁网|工程机械CAD图纸|机械工程制图|CAD装配图下载|SolidWorks_CaTia_CAD_UG_PROE_设计图分享下载上搜索。

1、Java多线程编程线程：大总结Java 线程是 Java 语言中一个非常重要的部分，Java5 之前，多线程的语言支持还是比较弱的，内容也较少，写一个复杂的多线程程序是相当有挑战性的。在 Java5 以后，Java 对多线程做了很多扩展，扩展部分称之为并发包。这部分内容大大增强了 Java 多线程编程的能力，通过使用Java5 线程新特征的 API，可以很容易的做出复杂的多线程程序。与其他语言相比，已经是相当强悍了。通过十多篇博文，将Java 多线程的方方面面过了一遍，对我来说是一个学习和提高的过程，也为 Java 线程系列博文能给后来的学习者带来便利。知识点都过了一遍，要总结起来感觉很困难，

2、毕竟Java 线程是一个庞大的话题，不知道从何说起，如果泛泛而谈，那总结还有什么意义呢，再次，将前面的博文串联起来，按照先后顺序加上链接，以方便浏览也最好的首尾。下面是 Java 线程系列博文的一个编目：Java 线程：概念与原理Java 线程：创建与启动Java 线程：线程栈模型与线程的变量Java 线程：线程状态的转换Java 线程：线程的同步与锁Java 线程：线程的交互Java 线程：线程的调度-休眠Java 线程：线程的调度-优先级Java线程：线程的调度-让步Java 线程：线程的调度-合并Java 线程：线程的调度-守护线程Java线程：线程的同步-同步方法Java线程：线程的同

3、步-同步块Java线程：并发协作-生产者消费者模型Java 线程：并发协作-死锁Java 线程：volatile关键字Java 线程：新特征-线程池Java 线程：新特征-有返回值的线程Java线程：新特征-锁（上）Java 线程：新特征-锁（下）Java 线程：新特征-信号量Java 线程：新特征-阻塞队列Java 线程：新特征-阻塞栈Java 线程：新特征-条件变量Java 线程：新特征-原子量Java 线程：新特征-障碍器Java 线程：大总结Java线程：概念与原理一、操作系统中线程和进程的概念现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。进程是指一个内存中运行的应用程

4、序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe 就是一个进程。线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如 java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程共享进程的内存。“同时”执行是人的感觉，在线程之间实际上轮换执行。二、Java 中的线程在 Java 中，“线程”指两件不同的事情：1、java.lang.Thread类的一个实例；2、线程的执行。使用 java.lang.Thread类或者 java.lang.Runnable接口编写代码来定义、实例化和启动新线程。一个 Th

5、read类实例只是一个对象，像Java 中的任何其他对象一样，具有变量和方法，生死于堆上。Java 中，每个线程都有一个调用栈，即使不在程序中创建任何新的线程，线程也在后台运行着。一个 Java 应用总是从 main()方法开始运行，mian()方法运行在一个线程内，它被称为主线程。一旦创建一个新的线程，就产生一个新的调用栈。线程总体分两类：用户线程和守候线程。当所有用户线程执行完毕的时候，JVM 自动关闭。但是守候线程却不独立于JVM，守候线程一般是由操作系统或者用户自己创建的。Java线程：创建与启动一、定义线程1、扩展 java.lang.Thread类。此类中有个 run()方法，应该

6、注意其用法：public void run()如果该线程是使用独立的Runnable运行对象构造的，则调用该Runnable对象的run方法；否则，该方法不执行任何操作并返回。Thread的子类应该重写该方法。2、实现 java.lang.Runnable接口。void run()使用实现接口Runnable的对象创建一个线程时，启动该线程将导致在独立执行的线程中调用对象的run方法。方法run的常规协定是，它可能执行任何所需的操作。二、实例化线程1、如果是扩展 java.lang.Thread类的线程，则直接new 即可。2、如果是实现了java.lang.Runnable接口的类，则用Th

7、read的构造方法：Thread(Runnable target)Thread(Runnable target,String name)Thread(ThreadGroup group,Runnable target)Thread(ThreadGroup group,Runnable target,String name)Thread(ThreadGroup group,Runnable target,String name,long stackSize)三、启动线程在线程的 Thread对象上调用 start()方法，而不是 run()或者别的方法。在调用 start()方法之前：线程处于新

8、状态中，新状态指有一个Thread对象，但还没有一个真正的线程。在调用 start()方法之后：发生了一系列复杂的事情：启动新的执行线程（具有新的调用栈）；该线程从新状态转移到可运行状态；当该线程获得机会执行时，其目标run()方法将运行。注意：对 Java 来说，run()方法没有任何特别之处。像 main()方法一样，它只是新线程知道调用的方法名称(和签名)。因此，在 Runnable上或者 Thread上调用 run 方法是合法的。但并不启动新的线程。四、例子1、实现 Runnable接口的多线程例子/*实现 Runnable接口的类*author leizhimin 2008-9-13

9、 18:12:10*/publicclass DoSomething implements Runnable private String name;publicDoSomething(String name)this.name=name;publicvoid run()for (int i=0;i 5;i+)for (long k=0;k 100000000;k+);System.out.println(name+:+i);/*测试 Runnable类实现的多线程程序*author leizhimin 2008-9-13 18:15:02*/publicclass TestRunnable

10、publicstaticvoid main(String args)DoSomething ds1=new DoSomething(阿三);DoSomething ds2=new DoSomething(李四);Thread t1=new Thread(ds1);Thread t2=new Thread(ds2);t1.start();t2.start();执行结果：李四:0 阿三:0 李四:1 阿三:1 李四:2 李四:3 阿三:2 李四:4 阿三:3 阿三:4 Process finished with exit code 0 2、扩展 Thread类实现的多线程例子/*测试扩展 Thre

11、ad类实现的多线程程序*author leizhimin 2008-9-13 18:22:13*/publicclass TestThread extends Thread publicTestThread(String name)super(name);publicvoid run()for(int i=0;i5;i+)for(longk=0;k 100000000;k+);System.out.println(this.getName()+:+i);publicstaticvoid main(String args)Thread t1=new TestThread(阿三);Thread t

12、2=new TestThread(李四);t1.start();t2.start();执行结果：阿三 :0 李四 :0 阿三 :1 李四 :1 阿三 :2 李四 :2 阿三 :3 阿三 :4 李四 :3 李四 :4 Process finished with exit code 0 对于上面的多线程程序代码来说，输出的结果是不确定的。其中的一条语句for(long k=0;k 100000000;k+);是用来模拟一个非常耗时的操作的。五、一些常见问题1、线程的名字，一个运行中的线程总是有名字的，名字有两个来源，一个是虚拟机自己给的名字，一个是你自己的定的名字。在没有指定线程名字的情况下，虚拟

13、机总会为线程指定名字，并且主线程的名字总是mian，非主线程的名字不确定。2、线程都可以设置名字，也可以获取线程的名字，连主线程也不例外。3、获取当前线程的对象的方法是：Thread.currentThread()；4、在上面的代码中，只能保证：每个线程都将启动，每个线程都将运行直到完成。一系列线程以某种顺序启动并不意味着将按该顺序执行。对于任何一组启动的线程来说，调度程序不能保证其执行次序，持续时间也无法保证。5、当线程目标 run()方法结束时该线程完成。6、一旦线程启动，它就永远不能再重新启动。只有一个新的线程可以被启动，并且只能一次。一个可运行的线程或死线程可以被重新启动。7、线程的调

14、度是 JVM 的一部分，在一个CPU 的机器上上，实际上一次只能运行一个线程。一次只有一个线程栈执行。JVM 线程调度程序决定实际运行哪个处于可运行状态的线程。众多可运行线程中的某一个会被选中做为当前线程。可运行线程被选择运行的顺序是没有保障的。8、尽管通常采用队列形式，但这是没有保障的。队列形式是指当一个线程完成“一轮”时，它移到可运行队列的尾部等待，直到它最终排队到该队列的前端为止，它才能被再次选中。事实上，我们把它称为可运行池而不是一个可运行队列，目的是帮助认识线程并不都是以某种有保障的顺序排列唱呢个一个队列的事实。9、尽管我们没有无法控制线程调度程序，但可以通过别的方式来影响线程调度的

15、方式。Java线程：线程栈模型与线程的变量要理解线程调度的原理，以及线程执行过程，必须理解线程栈模型。线程栈是指某时刻时内存中线程调度的栈信息，当前调用的方法总是位于栈顶。线程栈的内容是随着程序的运行动态变化的，因此研究线程栈必须选择一个运行的时刻（实际上指代码运行到什么地方)。下面通过一个示例性的代码说明线程（调用）栈的变化过程。这幅图描述在代码执行到两个不同时刻1、2 时候，虚拟机线程调用栈示意图。当程序执行到 t.start();时候，程序多出一个分支（增加了一个调用栈B），这样，栈 A、栈 B并行执行。从这里就可以看出方法调用和线程启动的区别了。Java线程：线程状态的转换一、线程状态

16、线程的状态转换是线程控制的基础。线程状态总的可分为五大状态：分别是生、死、可运行、运行、等待/阻塞。用一个图来描述如下：1、新状态：线程对象已经创建，还没有在其上调用start()方法。2、可运行状态：当线程有资格运行，但调度程序还没有把它选定为运行线程时线程所处的状态。当 start()方法调用时，线程首先进入可运行状态。在线程运行之后或者从阻塞、等待或睡眠状态回来后，也返回到可运行状态。3、运行状态：线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。4、等待/阻塞/睡眠状态：这是线程有资格运行时它所处的状态。实际上这个三状态组合为一种，

17、其共同点是：线程仍旧是活的，但是当前没有条件运行。换句话说，它是可运行的，但是如果某件事件出现，他可能返回到可运行状态。5、死亡态：当线程的run()方法完成时就认为它死去。这个线程对象也许是活的，但是，它已经不是一个单独执行的线程。线程一旦死亡，就不能复生。如果在一个死去的线程上调用start()方法，会抛出 java.lang.IllegalThreadStateException异常。有关详细状态转换图可以参看下图。二、阻止线程执行对于线程的阻止，考虑一下三个方面，不考虑IO 阻塞的情况：睡眠；等待；因为需要一个对象的锁定而被阻塞。1、睡眠Thread.sleep(long millis

18、)和 Thread.sleep(long millis,int nanos)静态方法强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。当线程睡眠时，它入睡在某个地方，在苏醒之前不会返回到可运行状态。当睡眠时间到期，则返回到可运行状态。线程睡眠的原因：线程执行太快，或者需要强制进入下一轮，因为 Java 规范不保证合理的轮换。睡眠的实现：调用静态方法。try Thread.sleep(123);catch(InterruptedException e)e.printStackTrace();睡眠的位置：为了让其他线程有机会执行，可以将Thread.sleep()的调用放线程 run()之内

19、。这样才能保证该线程执行过程中会睡眠。例如，在前面的例子中，将一个耗时的操作改为睡眠，以减慢线程的执行。可以这么写：public void run()for(int i=0;i5;i+)/很耗时的操作，用来减慢线程的执行/for(long k=0;k 100000000;k+);try Thread.sleep(3);catch(InterruptedException e)e.printStackTrace();.System.out.println(this.getName()+:+i);运行结果：阿三 :0 李四 :0 阿三 :1 阿三 :2 阿三 :3 李四 :1 李四 :2 阿三 :

20、4 李四 :3 李四 :4 Process finished with exit code 0 这样，线程在每次执行过程中，总会睡眠3 毫秒，睡眠了，其他的线程就有机会执行了。注意：1、线程睡眠是帮助所有线程获得运行机会的最好方法。2、线程睡眠到期自动苏醒，并返回到可运行状态，不是运行状态。sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始执行。3、sleep()是静态方法，只能控制当前正在运行的线程。下面给个例子：/*一个计数器，计数到100，在每个数字之间暂停1 秒，每隔 10 个数字输出一个字符串*author leizhimin

21、2008-9-14 9:53:49*/publicclass MyThread extends Thread publicvoid run()for (int i=0;i 100;i+)if(i)%10=0)System.out.println(-+i);System.out.print(i);try Thread.sleep(1);System.out.print(线程睡眠 1 毫秒！n);catch (InterruptedException e)e.printStackTrace();publicstaticvoid main(String args)new MyThread().sta

22、rt();-0 0 线程睡眠 1 毫秒！1 线程睡眠 1 毫秒！2 线程睡眠 1 毫秒！3 线程睡眠 1 毫秒！4 线程睡眠 1 毫秒！5 线程睡眠 1 毫秒！6 线程睡眠 1 毫秒！7 线程睡眠 1 毫秒！8 线程睡眠 1 毫秒！9 线程睡眠 1 毫秒！-10 10 线程睡眠 1 毫秒！11 线程睡眠 1 毫秒！12 线程睡眠 1 毫秒！13 线程睡眠 1 毫秒！14 线程睡眠 1 毫秒！15 线程睡眠 1 毫秒！16 线程睡眠 1 毫秒！17 线程睡眠 1 毫秒！18 线程睡眠 1 毫秒！19 线程睡眠 1 毫秒！.2、线程的优先级和线程让步yield()线程的让步是通过Thread.yi

23、eld()来实现的。yield()方法的作用是：暂停当前正在执行的线程对象，并执行其他线程。要理解 yield()，必须了解线程的优先级的概念。线程总是存在优先级，优先级范围在 110之间。JVM 线程调度程序是基于优先级的抢先调度机制。在大多数情况下，当前运行的线程优先级将大于或等于线程池中任何线程的优先级。但这仅仅是大多数情况。注意：当设计多线程应用程序的时候，一定不要依赖于线程的优先级。因为线程调度优先级操作是没有保障的，只能把线程优先级作用作为一种提高程序效率的方法，但是要保证程序不依赖这种操作。当线程池中线程都具有相同的优先级，调度程序的JVM 实现自由选择它喜欢的线程。这时候调度程

24、序的操作有两种可能：一是选择一个线程运行，直到它阻塞或者运行完成为止。二是时间分片，为池内的每个线程提供均等的运行机会。设置线程的优先级：线程默认的优先级是创建它的执行线程的优先级。可以通过setPriority(int newPriority)更改线程的优先级。例如：Thread t=new MyThread();t.setPriority(8);t.start();线程优先级为 110之间的正整数，JVM 从不会改变一个线程的优先级。然而，110之间的值是没有保证的。一些JVM 可能不能识别 10 个不同的值，而将这些优先级进行每两个或多个合并，变成少于10 个的优先级，则两个或多个优先级

25、的线程可能被映射为一个优先级。线程默认优先级是5，Thread类中有三个常量，定义线程优先级范围：static int MAX_PRIORITY 线程可以具有的最高优先级。static int MIN_PRIORITY 线程可以具有的最低优先级。static int NORM_PRIORITY 分配给线程的默认优先级。3、Thread.yield()方法Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的

26、轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。结论：yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。4、join()方法Thread的非静态方法 join()让一个线程 B“加入”到另外一个线程 A 的尾部。在 A 执行完毕之前，B 不能工作。例如：Thread t=new MyThread();t.start();t.join();另外，join()方法还有带超时限制的重载版本。例如 t.join(5000);则让线程等待 5000 毫秒，如果超过

27、这个时间，则停止等待，变为可运行状态。线程的加入 join()对线程栈导致的结果是线程栈发生了变化，当然这些变化都是瞬时的。下面给示意图：小结到目前为止，介绍了线程离开运行状态的3 种方法：1、调用 Thread.sleep()：使当前线程睡眠至少多少毫秒（尽管它可能在指定的时间之前被中断）。2、调用 Thread.yield()：不能保障太多事情，尽管通常它会让当前运行线程回到可运行性状态，使得有相同优先级的线程有机会执行。3、调用 join()方法：保证当前线程停止执行，直到该线程所加入的线程完成为止。然而，如果它加入的线程没有存活，则当前线程不需要停止。除了以上三种方式外，还有下面几种特

28、殊情况可能使线程离开运行状态：1、线程的 run()方法完成。2、在对象上调用wait()方法（不是在线程上调用）。3、线程不能在对象上获得锁定，它正试图运行该对象的方法代码。4、线程调度程序可以决定将当前运行状态移动到可运行状态，以便让另一个线程获得运行机会，而不需要任何理由。Java线程：线程的同步与锁一、同步问题提出线程的同步是为了防止多个线程访问一个数据对象时，对数据造成的破坏。例如：两个线程 ThreadA、ThreadB都操作同一个对象Foo 对象，并修改 Foo 对象上的数据。publicclass Foo privateint x=100;publicint getX()ret

29、urn x;publicint fix(int y)x=x-y;return x;publicclass MyRunnable implements Runnable private Foo foo=new Foo();publicstaticvoid main(String args)MyRunnable r=new MyRunnable();Thread ta=new Thread(r,Thread-A);Thread tb=new Thread(r,Thread-B);ta.start();tb.start();publicvoid run()for (int i=0;i 0)retur

30、n (String)nameList.remove(0);else returnnull;publicclass Test publicstaticvoid main(String args)final NameList nl=new NameList();nl.add(aaa);class NameDropper extends Thread publicvoid run()String name=nl.removeFirst();System.out.println(name);Thread t1=new NameDropper();Thread t2=new NameDropper();

31、t1.start();t2.start();虽然集合对象private List nameList=Collections.synchronizedList(new LinkedList();是同步的，但是程序还不是线程安全的。出现这种事件的原因是，上例中一个线程操作列表过程中无法阻止另外一个线程对列表的其他操作。解决上面问题的办法是，在操作集合对象的NameList上面做一个同步。改写后的代码如下：publicclass NameList privateList nameList=Collections.synchronizedList(new LinkedList();publicsync

32、hronizedvoidadd(String name)nameList.add(name);publicsynchronizedString removeFirst()if(nameList.size()0)return (String)nameList.remove(0);else returnnull;这样，当一个线程访问其中一个同步方法时，其他线程只有等待。七、线程死锁死锁对 Java 程序来说，是很复杂的，也很难发现问题。当两个线程被阻塞，每个线程在等待另一个线程时就发生死锁。还是看一个比较直观的死锁例子：publicclass DeadlockRisk privatestaticc

33、lass Resource publicint value;private Resource resourceA=new Resource();privateResource resourceB=new Resource();publicint read()synchronized(resourceA)synchronized(resourceB)returnresourceB.value+resourceA.value;publicvoid write(int a,int b)synchronized(resourceB)synchronized(resourceA)resourceA.va

34、lue=a;resourceB.value=b;假设 read()方法由一个线程启动，write()方法由另外一个线程启动。读线程将拥有 resourceA锁，写线程将拥有resourceB锁，两者都坚持等待的话就出现死锁。实际上，上面这个例子发生死锁的概率很小。因为在代码内的某个点，CPU 必须从读线程切换到写线程，所以，死锁基本上不能发生。但是，无论代码中发生死锁的概率有多小，一旦发生死锁，程序就死掉。有一些设计方法能帮助避免死锁，包括始终按照预定义的顺序获取锁这一策略。已经超出SCJP 的考试范围。八、线程同步小结1、线程同步的目的是为了保护多个线程反问一个资源时对资源的破坏。2、线程同

35、步方法是通过锁来实现，每个对象都有切仅有一个锁，这个锁与一个特定的对象关联，线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该对象的其他同步方法。3、对于静态同步方法，锁是针对这个类的，锁对象是该类的Class 对象。静态和非静态方法的锁互不干预。一个线程获得锁，当在一个同步方法中访问另外对象上的同步方法时，会获取这两个对象锁。4、对于同步，要时刻清醒在哪个对象上同步，这是关键。5、编写线程安全的类，需要时刻注意对多个线程竞争访问资源的逻辑和安全做出正确的判断，对“原子”操作做出分析，并保证原子操作期间别的线程无法访问竞争资源。6、当多个线程等待一个对象锁时，没有获取到锁的线程将发生阻塞

36、。7、死锁是线程间相互等待锁锁造成的，在实际中发生的概率非常的小。真让你写个死锁程序，不一定好使，呵呵。但是，一旦程序发生死锁，程序将死掉。Java线程：线程的交互线程交互是比较复杂的问题，SCJP 要求不很基础：给定一个场景，编写代码来恰当使用等待、通知和通知所有线程。一、线程交互的基础知识SCJP 所要求的线程交互知识点需要从java.lang.Object的类的三个方法来学习：void notify()唤醒在此对象监视器上等待的单个线程。void notifyAll()唤醒在此对象监视器上等待的所有线程。void wait()导致当前的线程等待，直到其他线程调用此对象的 notify()

37、方法或 notifyAll()方法。当然，wait()还有另外两个重载方法：void wait(long timeout)导致当前的线程等待，直到其他线程调用此对象的 notify()方法或 notifyAll()方法，或者超过指定的时间量。void wait(long timeout,int nanos)导致当前的线程等待，直到其他线程调用此对象的 notify()方法或 notifyAll()方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量。以上这些方法是帮助线程传递线程关心的时间状态。关于等待/通知，要记住的关键点是：必须从同步环境内调用wait()、notify()、not

38、ifyAll()方法。线程不能调用对象上等待或通知的方法，除非它拥有那个对象的锁。wait()、notify()、notifyAll()都是 Object的实例方法。与每个对象具有锁一样，每个对象可以有一个线程列表，他们等待来自该信号（通知）。线程通过执行对象上的wait()方法获得这个等待列表。从那时候起，它不再执行任何其他指令，直到调用对象的notify()方法为止。如果多个线程在同一个对象上等待，则将只选择一个线程（不保证以何种顺序）继续执行。如果没有线程等待，则不采取任何特殊操作。下面看个例子就明白了：/*计算输出其他线程锁计算的数据*author leizhimin 2008-9-1

39、5 13:20:38*/publicclass ThreadA publicstaticvoid main(String args)ThreadB b=new ThreadB();/启动计算线程 b.start();/线程 A 拥有 b 对象上的锁。线程为了调用wait()或 notify()方法，该线程必须是那个对象锁的拥有者synchronized(b)try System.out.println(等待对象 b 完成计算。);/当前线程 A 等待 b.wait();catch (InterruptedException e)e.printStackTrace();System.out.pr

40、intln(b 对象计算的总和是：+b.total);/*计算 1+2+3.+100的和*author leizhimin 2008-9-15 13:20:49*/publicclass ThreadB extends Thread int total;publicvoid run()synchronized(this)for (int i=0;i 101;i+)total+=i;/（完成计算了）唤醒在此对象监视器上等待的单个线程，在本例中线程A 被唤醒 notify();等待对象 b 完成计算。b 对象计算的总和是：5050 Process finished with exit code 0

41、 千万注意：当在对象上调用 wait()方法时，执行该代码的线程立即放弃它在对象上的锁。然而调用 notify()时，并不意味着这时线程会放弃其锁。如果线程荣然在完成同步代码，则线程在移出之前不会放弃锁。因此，只要调用notify()并不意味着这时该锁变得可用。二、多个线程在等待一个对象锁时候使用notifyAll()在多数情况下，最好通知等待某个对象的所有线程。如果这样做，可以在对象上使用notifyAll()让所有在此对象上等待的线程冲出等待区，返回到可运行状态。下面给个例子：/*计算线程*author leizhimin 2008-9-20 11:15:46*/publicclass C

42、alculator extends Thread int total;publicvoid run()synchronized(this)for (int i=0;i 101;i+)total+=i;/通知所有在此对象上等待的线程 notifyAll();/*获取计算结果并输出*author leizhimin 2008-9-20 11:15:22*/publicclass ReaderResult extends Thread Calculator c;publicReaderResult(Calculator c)this.c=c;publicvoid run()synchronized(

43、c)try System.out.println(Thread.currentThread()+等待计算结果。);c.wait();catch (InterruptedException e)e.printStackTrace();System.out.println(Thread.currentThread()+计算结果为：+c.total);publicstaticvoid main(String args)Calculator calculator=new Calculator();/启动三个线程，分别获取计算结果new ReaderResult(calculator).start();

44、new ReaderResult(calculator).start();new ReaderResult(calculator).start();/启动计算线程 calculator.start();运行结果：ThreadThread-1,5,main等待计算结果。ThreadThread-2,5,main等待计算结果。ThreadThread-3,5,main等待计算结果。Exception in thread Thread-0 java.lang.IllegalMonitorStateException:current thread not owner at java.lang.Obje

45、ct.notifyAll(Native Method)at threadtest.Calculator.run(Calculator.java:18)ThreadThread-1,5,main计算结果为：5050 ThreadThread-2,5,main计算结果为：5050 ThreadThread-3,5,main计算结果为：5050 Process finished with exit code 0 运行结果表明，程序中有异常，并且多次运行结果可能有多种输出结果。这就是说明，这个多线程的交互程序还存在问题。究竟是出了什么问题，需要深入的分析和思考，下面将做具体分析。实际上，上面这个代码中

46、，我们期望的是读取结果的线程在计算线程调用notifyAll()之前等待即可。但是，如果计算线程先执行，并在读取结果线程等待之前调用了notify()方法，那么又会发生什么呢？这种情况是可能发生的。因为无法保证线程的不同部分将按照什么顺序来执行。幸运的是当读取线程运行时，它只能马上进入等待状态-它没有做任何事情来检查等待的事件是否已经发生。-因此，如果计算线程已经调用了notifyAll()方法，那么它就不会再次调用notifyAll()，-并且等待的读取线程将永远保持等待。这当然是开发者所不愿意看到的问题。因此，当等待的事件发生时，需要能够检查notifyAll()通知事件是否已经发生。通常

47、，解决上面问题的最佳方式是将（博主到这句话就太监了，先留着，以后补上）Java线程：线程的调度-休眠Java 线程调度是 Java 多线程的核心，只有良好的调度，才能充分发挥系统的性能，提高程序的执行效率。这里要明确的一点，不管程序员怎么编写调度，只能最大限度的影响线程执行的次序，而不能做到精准控制。线程休眠的目的是使线程让出CPU 的最简单的做法之一，线程休眠时候，会将CPU 资源交给其他线程，以便能轮换执行，当休眠一定时间后，线程会苏醒，进入准备状态等待执行。线程休眠的方法是Thread.sleep(long millis)和 Thread.sleep(long millis,int na

48、nos)，均为静态方法，那调用 sleep 休眠的哪个线程呢？简单说，哪个线程调用 sleep，就休眠哪个线程。/*Java线程：线程的调度-休眠*author leizhimin 2009-11-4 9:02:40*/publicclass Test publicstaticvoid main(String args)Thread t1=new MyThread1();Thread t2=new Thread(new MyRunnable();t1.start();t2.start();class MyThread1 extends Thread publicvoid run()for (i

49、nt i=0;i 3;i+)System.out.println(线程 1 第+i+次执行！);try Thread.sleep(50);catch (InterruptedException e)e.printStackTrace();class MyRunnable implements Runnable publicvoid run()for (int i=0;i 3;i+)System.out.println(线程 2 第+i+次执行！);try Thread.sleep(50);catch (InterruptedException e)e.printStackTrace();线程

50、2 第 0 次执行！线程 1 第 0 次执行！线程 1 第 1 次执行！线程 2 第 1 次执行！线程 1 第 2 次执行！线程 2 第 2 次执行！Process finished with exit code 0 从上面的结果输出可以看出，无法精准保证线程执行次序。Java线程：线程的调度-优先级与线程休眠类似，线程的优先级仍然无法保障线程的执行次序。只不过，优先级高的线程获取CPU 资源的概率较大，优先级低的并非没机会执行。线程的优先级用1-10 之间的整数表示，数值越大优先级越高，默认的优先级为5。在一个线程中开启另外一个新线程，则新开线程称为该线程的子线程，子线程初始优先级与父线程相