java多线程初探（零）生产者消费者模式-线程通信

测试类

package gcc.twoThreadTransData.producerAndConsumer;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 多个线程之间通信
 * 消费者生产者模式
 * 多个生产者和消费者
 * 流程：
 * 多个线程（生产者，消费者）公用一把锁
 * 本例设置了两个生产者线程和两个消费者线程
 * 启动线程，run方法内循环调用生产和消费方法
 * 无数据，生产，notifyAll唤醒所有wait等待（不管是消费者的还是生产者的）
 * 有数据，不生产，wait等待
 * 有数据，消费，数据置空，notifyAll唤醒所有wait等待
 * 无数据，不消费，wait等待
 */
public class TestPCModel {

    protected static Logger logger = LoggerFactory.getLogger(TestPCModel.class);

    public static void main(String[] args) throws InterruptedException {
        String lock =  new String("");
        Producer p = new Producer(lock);
        Consumer c = new Consumer(lock);
        ThreadP[] pThread = new ThreadP[2];
        ThreadC[] cThread = new ThreadC[2];
        for (int i = 0; i <2 ; i++) {
            pThread[i]=new ThreadP(p);
            pThread[i].setName("生产者-"+i);
            cThread[i]=new ThreadC(c);
            cThread[i].setName("消费者-"+i);
            pThread[i].start();
            cThread[i].start();
        }
        /*Thread.sleep(2000);
        Thread[] threadArray = new Thread[Thread.currentThread().getThreadGroup().activeCount()];
        Thread.currentThread().getThreadGroup().enumerate(threadArray);
        for (int i = 0; i <threadArray.length ; i++) {
            logger.info(threadArray[i].getName()+"---"+threadArray[i].getState());
        }*/

    }

}

生产者类

package gcc.twoThreadTransData.producerAndConsumer;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Producer {

    protected static Logger logger = LoggerFactory.getLogger(Producer.class);

    private String lock;
    public Producer(String lock){
        this.lock=lock;
    }

    public void setValue(){
        try {
            synchronized (lock) {
                while (!"".equals(ValueObject.value)){
                    logger.info("已生产，等待消费："+Thread.currentThread().getName());
                    lock.wait();
                }
                logger.info("开始生产："+Thread.currentThread().getName());
                String value=System.currentTimeMillis()+"--"+System.nanoTime();
                ValueObject.value=value;
                lock.notifyAll();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

消费者类

package gcc.twoThreadTransData.producerAndConsumer;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Consumer {

    protected static Logger logger = LoggerFactory.getLogger(Consumer.class);

    private String lock;
    public Consumer(String lock){
        this.lock=lock;
    }

    public void getValue(){
        try {
            synchronized (lock) {
                while (ValueObject.value.equals("")){
                    logger.info("已消费完："+Thread.currentThread().getName());
                    lock.wait();
                }
                logger.info("开始消费："+Thread.currentThread().getName());
                ValueObject.value="";
                lock.notifyAll();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

生产者线程

package gcc.twoThreadTransData.producerAndConsumer;

public class ThreadP extends Thread{

    private Producer producer;
    public ThreadP(Producer producer){
        this.producer=producer;
    }

    public void run(){
        while (true){
            producer.setValue();
        }
    }

}

消费者线程

package gcc.twoThreadTransData.producerAndConsumer;

public class ThreadC extends Thread{

    private Consumer consumer;
    public ThreadC(Consumer consumer){
        this.consumer=consumer;
    }

    public void run(){
        while (true){
            consumer.getValue();
        }
    }

}

辅助类

package gcc.twoThreadTransData.producerAndConsumer;

public class ValueObject {

    public static String value="";

}