一个notify()的实例分析

在java多线程编程中，就要涉及到了对于资源的访问，当多个线程同时访问一个资源的时候就要涉及到一种访问策略。java提供了锁的机制，就是一个线程访问这个资源的时候可以先把这个资源锁住可以用synchronized(the object)来锁定the object，其他访问这个资源的线程就进入阻塞状态，直到当前的线程执行了这个对象的notify或者notifyall其他访问这个对象的阻塞状态的线程才有可能变成就绪状态。其中notify是唤醒一个线程，而notifyall是唤醒所有阻塞进程。

如下是一个这方面的实例

package concurrent;

import java.util.concurrent.TimeUnit;
/**
* Wait、Notify、NotifyAll的区别
* @author yydcj
* Email:yydcj@163.com
* 网址：<a>http://yydcj.iteye.com</a>
*/
public class WaitNotify {
private static int reduceThreadCount =0;
/**
* @param args
*/
public static void main(String[] args) {
WaitNotify notify = new WaitNotify();
Source source = notify.new Source("source");

for (int i = 0; i < 10; i++)
notify.new ReduceThread(source).start();
//		try {
//			TimeUnit.SECONDS.sleep(5);
//		} catch (InterruptedException e) {
//			e.printStackTrace();
//		}
notify.new AddThread(source).start();
}
class ReduceThread extends Thread{

private Source source;
public ReduceThread(Source source){
super("ReduceThread-" + reduceThreadCount++);
this.source = source;
}
public void run(){
for (int i = 0; i < 10; i++){
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
source.reduceCount();
}
}
}
class AddThread extends Thread{
private Source source;
public AddThread(Source source){
super("AddThread");
this.source = source;
}
public void run(){
for (int i = 0; i < 1; i++){
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
source.addCount();
}
}
}
class Source{
private int count = 0;
public Source(String name){
//			this.name = name;
}
public synchronized void addCount() {
System.out.println(Thread.currentThread().getName()+": count+1="+ ++count);
notify();
}
public synchronized void reduceCount() {
while (count <= 0) {
try {
System.out.println(Thread.currentThread().getName()+" wait()");
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+": count-1="+ --count);
}
}
}

//output：

ReduceThread-1 wait()

ReduceThread-5 wait()

ReduceThread-8 wait()

ReduceThread-6 wait()

ReduceThread-4 wait()

ReduceThread-2 wait()

ReduceThread-0 wait()

AddThread: count+1=1

ReduceThread-7: count-1=0

ReduceThread-9 wait()

ReduceThread-3 wait()

ReduceThread-1 wait()

ReduceThread-7 wait()

我这里是用notify()来唤醒其中一个ReduceThread线程的（此时notify的是ReduceThread-7），然后ReduceThread-7执行完消费任务后又进入了wait()、10个reduce线程虽然是顺序实例化的，但是他们并不是顺序拿到souce对象的。依次拿到souce对象的1586420 这7个线程，各个线程因为count 为0释放了这个对象给其他的线程。然后AddThread拿到了这个对象，将count变为1，notify了一个线程，这个线程就是1。虽然1被notify了，但是他并没有取得对象，对象被7获取了并将count设置为0，所以等于说1这个线程醒来之后发现count依然为0，所以又wait了一遍

一个线程被notify之后并不认为已经获取了对象，依然需要去和其他线程抢对象才能继续执行下去。