java的wait和notify实例

本例子实现了两个线程，每个线程输出1到100的数字。
第一个线程输出1-10，停止，通知第二个线程 输出1-10 第二个线程停止 通知第一个线程 输出11-20 ...实现的要点是在Java中，每个对象都有个对象锁标志(Object lock flag)与之想关联，当一个线程A调用对象的一段synchronized代码时，它首先要获取与这个对象关联的对象锁标志，然后执行相应的代码，执行结束后，把这个对象锁标志返回给对象；因此，在线程A执synchronized代码期间，如果另一个线程B也要执行同一对象的一段synchronized代码时（不一定与线程A执行的相同），它将要等到线程A执行完后，才能继续....

如何利用wait() notify() notifyAll()?

在synchronized代码被执行期间，线程可以调用对象的wait()方法，释放对象锁标志，进入等待状态，并且可以调用notify()或者
notifyAll()方法通知正在等待的其他线程。notify()通知等待队列中的第一个线程，notifyAll()通知的是等待队列中的所有线程。

package jdeveloper.study;


import java.lang.Runnable;
import java.lang.Thread;

public class DemoThread implements Runnable{


public DemoThread() {
      TestThread testthread1 = new TestThread(this,"1");
      TestThread testthread2 = new TestThread(this,"2");


      testthread2.start();
      testthread1.start();

}


public static void main(String[] args) {
  DemoThread demoThread1 = new DemoThread();
}


public void run(){

    TestThread t = (TestThread) Thread.currentThread();
    try{
      if (!t.getName().equalsIgnoreCase("1")) {
        synchronized(this) {
            wait();
        }
      }
      while(true){

        System.out.println("@time in thread"+ t.getName()+ "="+ t.increaseTime());

        if(t.getTime()%10 == 0) {
        synchronized(this) {
          System.out.println("****************************************");
          notify();
          if ( t.getTime()==100 ) break;
          wait();
        }
      }
    }
    }catch(Exception e){e.printStackTrace();}
  }


}


class TestThread extends Thread{
  private int time = 0 ;
  public TestThread(Runnable r,String name){
    super(r,name);
  }
  public int getTime(){
    return time;
  }
  public int increaseTime (){
    return ++time;
  }

}





Java的线路同步示例（synchronized、wait和notify）
从网上找到的代码（随便改的）。比较清晰地展示了wait和notify的运行机制。


package com.wubuku.mytest;


public class ThreadingExample {


    public static void main(String args[]) {
        Thread[] threads = new Thread[2];
        for (int count = 0; count < threads.length; count++) {
            threads[count] = new ThreadCounter(count);
            threads[count].start();
        }
    }


    private static class ThreadCounter extends Thread {
        /**
         * 在没有同步的情况下，这个方法会打印出不定顺序的数字
         */
        public static void count() {
            for (int count = 1; count <= 5; count++)
                System.out.print(count + " ");
        }


        public static Object synchronizeVariable = "locking variable";


        private int threadNo;


        public ThreadCounter(int threadNo) {
            this.threadNo = threadNo;
        }


        public void run() {
            countWithSync();
        }


        /**
         * 在有同步的情况下，能打印出这样顺序的数字： 1 1 2 2 3 3 4 4 5 5
         */
        private void countWithSync() {
            synchronized (synchronizeVariable) {
                for (int count = 1; count <= 5; count++) {
                    System.out.println("[thread_" + threadNo + " print:]"
                            + count + " ");
                    synchronizeVariable.notifyAll();


                    if (count < 5) {
                        System.out.println("[thread_" + threadNo
                                + " sleep zzz...] ");

                        try {
                            synchronizeVariable.wait();
                        } catch (InterruptedException error) {
                        }

                        System.out.println("[thread_" + threadNo + " wakup!] ");
                    }
                }
            }

        }
    }
}






一个理解wait()与notify()的例子


　　下面是我原来在CSDN论坛上看到的一个贴子，涉及到同步,wait(),notify()等概念的理解，我试着根据原来的一些回复和Think in Java上的相关概念将wait()和notify()这两个方法剖析了一下，欢迎指教.


　　问题如下：


//分析这段程序，并解释一下，着重讲讲synchronized、wait(),notify 谢谢！
class ThreadA
{
  public static void main(String[] args)
  {
    ThreadB b=new ThreadB();
    b.start();
    System.out.println("b is start....");
    synchronized(b)//括号里的b是什么意思,起什么作用?
    {
      try
      {
 System.out.println("Waiting for b to complete...");
 b.wait();//这一句是什么意思，究竟让谁wait?
        System.out.println("Completed.Now back to main thread");
      }catch (InterruptedException e){}
    }
    System.out.println("Total is :"+b.total);
   }
}

class ThreadB extends Thread
{
  int total;
  public void run()
  {
    synchronized(this)
    {
      System.out.println("ThreadB is running..");
      for (int i=0;i<100;i++ )
      {
        total +=i;
        System.out.println("total is "+total);
      }
      notify();
    }
  }
}


　　要分析这个程序,首先要理解notify()和wait(),为什么在前几天纪录线程的时候没有纪录这两个方法呢,因为这两个方法本来就不属于 Thread类,而是属于最底层的object基础类的,也就是说不光是Thread，每个对象都有notify和wait的功能，为什么？因为他们是用来操纵锁的,而每个对象都有锁,锁是每个对象的基础,既然锁是基础的,那么操纵锁的方法当然也是最基础了.


　　再往下看之前呢,首先最好复习一下Think in Java的14.3.1中第3部分内容：等待和通知,也就是wait()和notify了.


　　按照Think in Java中的解释:"wait()允许我们将线程置入“睡眠”状态，同时又“积极”地等待条件发生改变.而且只有在一个notify()或notifyAll()发生变化的时候，线程才会被唤醒，并检查条件是否有变."


　　我们来解释一下这句话.
　　"wait()允许我们将线程置入“睡眠”状态",也就是说,wait也是让当前线程阻塞的,这一点和sleep或者suspend是相同的.那和sleep,suspend有什么区别呢?


　　区别在于"(wait)同时又“积极”地等待条件发生改变",这一点很关键,sleep和suspend无法做到.因为我们有时候需要通过同步（synchronized）的帮助来防止线程之间的冲突，而一旦使用同步,就要锁定对象，也就是获取对象锁,其它要使用该对象锁的线程都只能排队等着, 等到同步方法或者同步块里的程序全部运行完才有机会.在同步方法和同步块中,无论sleep()还是suspend()都不可能自己被调用的时候解除锁定,他们都霸占着正在使用的对象锁不放.
　　而wait却可以,它可以让同步方法或者同步块暂时放弃对象锁,而将它暂时让给其它需要对象锁的人(这里应该是程序块,或线程)用,这意味着可在执行wait()期间调用线程对象中的其他同步方法!在其它情况下(sleep啊,suspend啊),这是不可能的.
　　但是注意我前面说的,只是暂时放弃对象锁,暂时给其它线程使用,我wait所在的线程还是要把这个对象锁收回来的呀.wait什么?就是wait别人用完了还给我啊！
　　好,那怎么把对象锁收回来呢?
　　第一种方法,限定借出去的时间.在wait()中设置参数,比如wait(1000),以毫秒为单位,就表明我只借出去1秒中,一秒钟之后,我自动收回.
　　第二种方法,让借出去的人通知我,他用完了,要还给我了.这时,我马上就收回来.哎,假如我设了1小时之后收回,别人只用了半小时就完了,那怎么办呢?靠!当然用完了就收回了,还管我设的是多长时间啊.


　　那么别人怎么通知我呢?相信大家都可以想到了,notify(),这就是最后一句话"而且只有在一个notify()或notifyAll()发生变化的时候，线程才会被唤醒"的意思了.
　　因此,我们可将一个wait()和notify()置入任何同步方法或同步块内部，无论在那个类里是否准备进行涉及线程的处理。而且实际上,我们也只能在同步方法或者同步块里面调用wait()和notify().


　　这个时候我们来解释上面的程序,简直是易如反掌了.


　　synchronized(b){...}；的意思是定义一个同步块,使用b作为资源锁。b.wait();的意思是临时释放锁，并阻塞当前线程,好让其他使用同一把锁的线程有机会执行,在这里要用同一把锁的就是b线程本身.这个线程在执行到一定地方后用notify()通知wait的线程,锁已经用完,待notify()所在的同步块运行完之后,wait所在的线程就可以继续执行.