生产者、消费者阻塞队列-传统版

生产者、消费者模型

生产者负责生产数据，消费者负责消费数据，中间件MQ就是这种模型设计。下面简单实现一个生产者和消费者的模型，实现生产一个数据，消费一个数据。

代码

/**
 *
 * 生产者 消费者阻塞队列 传统版
 *
 * 一个线程对变量+1，一个线程对变量-1
 *
 */
public class PC<T> {

    private volatile int i = 0;

    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();


   /**
     * 生产者，每次生产一个数据，然后等待消费者消费数据
     */
    public void produce() {
        lock.lock();

        try {
            // 防止线程一直再生成，消费者没有消费
            while (i != 0) {
                condition.await();
            }
            i++;
            System.out.println(Thread.currentThread().getName() + "\t" + i);
            condition.signalAll();
        } catch (InterruptedException e) {
        } finally {
            lock.unlock();
        }

    }

    /**
     * 消费者，每次消费一个数据，然后等待生产者生产数据
     */
    public void consume() {
        lock.lock();

        try {
            // 防止线程一直再消费，生产者没有生产消息
            while (i == 0) {
                condition.await();
            }
            i--;
            System.out.println(Thread.currentThread().getName() + "\t" + i);

            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

           

测试

public static void main(String[] args) {
        PC<Integer> pc = new PC<>();
		
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
            	// 生产
                pc.produce();
            }
        }, "AA").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
            	// 消费
                pc.consume();
            }
        }, "BB").start();
    }
           

通过测试，可以看到

AA

线程生产一个数据（将i增加到1），然后

BB

线程消费一个数据（将i减去1），这样就是一个通过锁实现的生产者消费者模型（传统版），在高并发的环境下性能不太高