多线程编程 -wait(),notify()/notityAll()方法 .

wait(),notify()/notityAll()方法]关于这两个方法,有很多的内容需要说明.在下面的说明中可能会有很多地方不能一下子明白,但在看完本节后,即使不能完全明白,你也一定要回过头来记住下面的两句话

:[wait(),notify()/notityAll()方法是普通对象的方法(Object超类中实现),而不是线程对象的方法][wait(),notify()/notityAll()方法只能在同步方法中调用][线程的互斥控制]

多个线程同时操作某一对象时,一个线程对该对象的操作可能会改变其状态,而该状态会影响另一线程对该对象的真正结果.象这种控制某一时刻只能有一个线程执行某个执行单元的机制就叫互斥控制或共享互斥(mutualexclusion).在JAVA中,用synchornized关键字来实现互斥控制(暂时这样认为,JDK1.5已经发展了新的机制)[synchornized关键字]把一个单元声明为synchornized,就可以让在同一时间只有一个线程操作该方法.有人说synchornized就是一把锁,事实上它确实存在锁,但是是谁的锁,锁谁,这是一个非常复杂的问题.每个对象只有一把监视锁(monitorlock),一次只能被一个线程获取.当一个线程获取了这一个锁后,其它线程就只能等待这个线程释放锁才能再获取

.那么synchornized关键字到底锁什么?得到了谁的锁?对于同步块,synchornized获取的是参数中的对象锁:
synchornized(obj){}
线程执行到这里时,首先要获取obj这个实例的锁,如果没有获取到线程只能等待.如果多个线程执行到这里,只能有一个线程获取obj的锁,然后执行{}中的语句,所以,obj对象的作用范围不同,控制程序不同.假如:

public void test(){
Object o = new Object(); synchornized(obj){ }这段程序控制不了任何,多个线程之间执行到Object o= newObject();时会各自产生一个对象然后获取这个对象有监视锁,各自皆大欢喜地执行.而如果是类的属性:
class Test{
Object o =new Object();
public voidtest(){synchornized(o){ }}

所有执行到Test实例的synchornized(o)的线程,只有一个线程可以获取到监视锁.有时我们会这样:

public void test(){synchornized(this){}
}

那么所有执行Test实例的线程只能有一个线程执行.而synchornized(o)和synchornized(this)的范围是不同的,因为执行到Test实例的synchornized(o)的线程等待时,其它线程可以执行Test实例的synchornized(o1)部分,但多个线程同时只有一个可以执行Test实例的synchornized(this).]而对于
synchornized(Test.class){}

这样的同步块而言,所有调用Test多个实例的线程赐教只能有一个线程可以执行.

[synchornized方法]

如果一个方法声明为synchornized的,则等同于把在为个方法上调用synchornized(this).如果一个静态方法被声明为synchornized,则等同于把在为个方法上调用synchornized(类.class).现在进入wait方法和notify/notifyAll方法.这两个(或叫三个)方法都是Object对象的方法,而不是线程对象的方法.如同锁一样,它们是在线程中调用某一对象上执行的.
class Test{
publicsynchornized void test(){
//获取条件,int x 要求大于100; if(x< 100)
wait();}

这里为了说明方法没有加在try{}catch(){}中,如果没有明确在哪个对象上调用wait()方法,则为this.wait();假如:Testt = newTest();现在有两个线程都执行到t.test();方法.其中线程A获取了t的对象锁,进入test()方法内.这时x小于100,所以线程A进入等待.当一个线程调用了wait方法后,这个线程就进入了这个对象的休息室(waitset),这是一个虚拟的对象,但JVM中一定存在这样的一个数据结构用来记录当前对象中有哪些程线程在等待.当一个线程进入等待时,它就会释放锁,让其它线程来获取这个锁.所以线程B有机会获得了线程A释放的锁,进入test()方法,如果这时x还是小于100,线程B也进入了t的休息室.这两个线程只能等待其它线程调用notity[All]来唤醒.但是如果调用的是有参数的wait(time)方法,则线程A,B都会在休息室中等待这个时间后自动唤醒.

[为什么真正的应用都是用while(条件)而不用if(条件)]

在实际的编程中我们看到大量的例子都是用?　　while(x < 100)　　wait();go();而不是用if,为什么呢?在多个线程同时执行时,if(x<100)是不安全的.因为如果线程A和线程B都在t的休息室中等待,这时另一个线程使x==100了,并调用notifyAll方法,线程A继续执行下面的go().而它执行完成后,x有可能又小于100,比如下面的程序中调用了--x,这时切换到线程B,线程B没有继续判断,直接执行go();就产生一个错误的条件,只有while才能保证线程B又继续检查一次。[notify/notifyAll方法]这两个方法都是把某个对象上休息区内的线程唤醒,notify只能唤醒一个,但究竟是哪一个不能确定,而notifyAll则唤醒这个对象上的休息室中所有的线程.一般有为了安全性,我们在绝对多数时候应该使用notifiAll(),除非你明确知道只唤醒其中的一个线程.那么是否是只要调用一个对象的wait()方法,当前线程就进入了这个对象的休息室呢?事实中,要调用一个对象的wait()方法,只有当前线程获取了这个对象的锁,换句话说一定要在这个对象的同步方法或以这个对象为参数的同步块中.
class MyThread extends Thread{
Test t = newTest();
public voidrun(){
t.test();
System.out.println("Thread say:Hello,World!"); } public classTest { int x =0;
public void test(){
if(x==0)
try{
wait();
}catch(Exception e){} publicstatic void main(String[] args) throws Exception{
newMyThread().start();}
这个线程就不会进入t的wait方法而直接打印出Threadsay:Hello,World!.而如果改成:

public class Test {
int x = 0;
public synchornized void test(){
if(x==0)
try{
wait();
}catch(Exception e){}public static void main(String[] args) throws Exception{
new MyThread().start();}

我们就可以看到线程一直等待,注意这个线程进入等待后没有其它线程唤醒,除非强行退出JVM环境,否则它一直等待.所以请记住:[线程要想调用一个对象的wait()方法就要先获得该对象的监视锁,而一旦调用wait()后又立即释放该锁]

线程的状态：

1.new： 线程对象已经诞生，但尚未启动，所以无法执行

2.  runnable  : 系统又能了分配cup时间给线程，线程可能在执行，也可能不处于执行态

3.dead：

4.blocked .

线程变为blocked的五种可能：

  1. 通过sleep（millisecends）让线程进入休眠态，指定时间内线程不能执行。

  2.通过suspend（）暂停线程，除非收到resume（），否则线程不能进入可执行状态。

 3. 通过wait（）暂停线程，只有notify（）或者notifyAll（）才可以使线程进入可执行态。

4。线程在等待IO动作完成。

5.线程在等待同一个对象的对象锁。

注意： wait ()，notify(), sleep(),notify(),suspend(),resume()只有在synchronize（）的函数或者通过大括号｛｝包围的同步快里面才会起作用，

  其中wait ()，notify() 在non-synchronized的情况下编译没错，但执行是会抛出illegalMoitorstateExecption, 其他几个可以执行但是不会起到作用。