java jdk5.0生产者消费者升级版

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test_Producer_Consumer {

public static void main(String[] args) {
Resource res = new Resource();
Producer pro = new Producer(res);
Consumer con = new Consumer(res);
Thread t1 = new Thread(pro);
Thread t2 = new Thread(pro);
Thread t3 = new Thread(con);
Thread t4 = new Thread(con);
t1.start();
t2.start();
t3.start();
t4.start();
}

}

/*
* class Resource { private String name; private int count = 1; private boolean
* flag = false;
*
* public synchronized void set(String name) { while(flag) { try { this.wait();
* } catch (InterruptedException e) { e.printStackTrace(); } } this.name = name
* + "..." + count++; System.out.println(Thread.currentThread().getName() +
* "...生产了..." + name); flag = true; this.notifyAll(); }
*
* public synchronized void out() { while(!flag) { try { this.wait(); } catch
* (InterruptedException e) { e.printStackTrace(); } }
* System.out.println(Thread.currentThread().getName() + "...消费了.............."
* + name); flag = false; this.notifyAll(); } }
*/

class Resource {
private String name;
private int count = 1;
private boolean flag = false;

/*
* JDK5.0对线程同步问题进行了升级
*/
private Lock lock = new ReentrantLock();
private Condition condition_pro = lock.newCondition();
private Condition condition_con = lock.newCondition();

public void set(String name) {
lock.lock();
try {
while (flag) {
condition_pro.await();
}
this.name = name + "..." + count++;
System.out.println(Thread.currentThread().getName() + "...生产了..."
+ name);
flag = true;
condition_con.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
} finally { // 不管你await有没有出错，你的锁一定会要释放
lock.unlock();
}
}

public void out() {
lock.lock();
try {
while (!flag) {
condition_con.await();
}
System.out.println(Thread.currentThread().getName()
+ "...消费了.............." + name);
flag = false;
condition_pro.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
} finally { // 不管你await有没有出错，你的锁一定会要释放
lock.unlock();
}

}
}

class Producer implements Runnable {

private Resource res;

Producer(Resource res) {
this.res = res;
}

@Override
public void run() {
while (true) {
res.set("商品");
}
}

}

class Consumer implements Runnable {

private Resource res;

Consumer(Resource res) {
this.res = res;
}

@Override
public void run() {
while (true) {
res.out();
}
}

}

JDK5.0对多线程同步进行了升级

将隐式的synchronized替换成了显式的Lock对象

将Object对象中的wait、notify、notifyAll，替换成了Condition对象

因为等待和唤醒是针对锁对象的，所以Condition对象的实例可以通过Lock对象的newCondition()方法拿到

并且升级之后最大的好处是一个锁对象可以对应多个Condition对象，这样在生产者消费者的例子中就可以解决

唤醒的时候把本方唤醒的问题，通过不同的Condition对象，可以选择让哪些Condition对象等待，哪些Condition对象唤醒