生产者与消费者1：1基于字符串

一个生产者/一个消费者：

 1 /**
 2  *    生产者
 3  */
 4 public class P {
 5     private String lock;//锁
 6     
 7     public P(String lock) {
 8         this.lock = lock;
 9     }
10     
11     public void setValue() {
12         try {
13             synchronized (lock) {
14                 //判断如果值不为""  则表示没有被消费,那么就等待被消费
15                 if(!ValueObject.value.equals("")) {
16                         lock.wait();
17                 }
18                 //如果已经被消费则获取当前时间,将值改成当前时间,模拟生产了
19                 String value = System.currentTimeMillis()+ "---" + System.nanoTime();
20                 System.out.println("set的值为：" + value);
21                 ValueObject.value = value;
22                 //生产完  唤醒某个线程
23                 lock.notify();
24             }
25         } catch (InterruptedException e) {
26             e.printStackTrace();
27         }
28     }
29 }

/**
 *    消费者
 */
public class C {
    private String lock;//锁
    
    public C(String lock) {
        this.lock = lock;
    }
    
    public void getValue() {
        synchronized (lock) {
            try {
                if(ValueObject.value.equals("")) { //如果当前还未生产 则等待
                    lock.wait();
                }
                //如果已经生产了   则打印出生产的值   通过将值赋值为 "" 来实现消费
                System.out.println("get的值是：" + ValueObject.value);
                ValueObject.value = "";
                //消费之后  唤醒等待的某一个线程，当前只要一个消费者和一个生产者，所有唤醒的是生产者
                lock.notify();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

1 /**
2  *    模拟生产和消费的物件,当值为"" 表示为生产或者已消费    反之则表示未生产或者未消费
3  */
4 public class ValueObject {
5     
6     public static String value = "";
7 
8 }

 1 /**
 2  *    生产者线程
 3  */
 4 public class ThreadP extends Thread {
 5     
 6     private P p;
 7     
 8     public ThreadP(P p) {
 9         this.p = p;
10     }
11     
12     @Override
13     public void run() {
14         while (true) {
15             p.setValue();
16         }
17     }
18 }

 1 /**
 2  *    消费者线程
 3  */
 4 public class ThreadC extends Thread {
 5     
 6     private C c;
 7     
 8     public ThreadC(C c) {
 9         this.c = c;
10     }
11     
12     @Override
13     public void run() {
14         while (true) {
15             c.getValue();
16         }
17     }
18 }

 1 /**
 2  *    测试类
 3  */
 4 public class Run {
 5 
 6     public static void main(String[] args) {
 7         String lock = new String("");
 8         
 9         P p = new P(lock);
10         C c = new C(lock);
11         
12         ThreadP threadP = new ThreadP(p);
13         ThreadC threadC = new ThreadC(c);
14         
15         threadP.start();
16         threadC.start();
17         
18     }
19 }

运行结果如下：