本实例是一个简单的:单生者vs单消费者
1.生产者类:
package p_t_test;
/**
* wait/notify变形模式:生产者消费者模式实现进程间通信
*
* 生产者
* @author lxb
*
*/
public class P {
private String lock;
public P(String lock){
this.lock = lock;
}
public void setValue(){
try{
synchronized (lock) {
//如果不为空,生产者处于等待状态
if(!ValueObject.value.equals("")){
System.out.println("我是消费者,此时缓冲池中有数据,我正在等待这个池没有数据被消费者用,它用完之后,我就放新的数据 ");
lock.wait();
}
String value = System.currentTimeMillis() + "_"+System.nanoTime();
System.out.println("我放的 的值是:"+value);
lock.notify();
}
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
2.生产者线程:
package p_t_test;
/**
* 生产者线程
* @author lxb
*
*/
public class ThreadP extends Thread{
private P p;
public ThreadP(P p){
this.p = p;
}
public void run(){
//生产者不停的向缓冲池中存放数据
while(true){
p.setValue();
}
}
}
package p_t_test;
/**
* 消费者类
* @author lxb
*
*/
public class C {
private String lock;
public C(String lock){
this.lock = lock;
}
public void getValue(){
try{
synchronized (lock) {
//当没有值可供消费者使用时,使用消费者的线程处于等待状态
if(ValueObject.value.equals("")){
System.out.println("我是消费者,你妹生产者为毛还不放值 ,等了半天了,老子急用:");
lock.wait();
}
System.out.println("消费者获取到的值是:"+ValueObject.value);
ValueObject.value = ""; //消费者取完值之后,将当前值置空
lock.notify(); //唤醒生产者可以向缓冲池中存放数据了
}
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
package p_t_test;
/**
* 消费者线程
* @author lxb
*
*/
public class ThreadC extends Thread{
private C c;
public ThreadC(C c){
this.c = c;
}
public void run(){
/**
* 消费者不停的从缓冲池中取数据
*/
while(true){
c.getValue();
}
}
}
5.数据缓冲池:
package p_t_test;
public class ValueObject {
public static String value="";
}
6.测试类:
package p_t_test;
public class TestClient {
public static void main(String[] args) {
String lock = new String(""); // 创建对象锁
P p = new P(lock);
C r = new C(lock);
ThreadP pThread = new ThreadP(p);
ThreadC cThread = new ThreadC(r);
pThread.start();
cThread.start();
}
}