Java基于Lock锁来实现生产者消费者

自己基于网上内容改编了一个，防止以后面试找不到上传一份。里面主要由生产者先进行生产10个物品之后，消费者开始消费。消费者消费一次用2秒，生产者生产一份需要1秒。

生产者代码

package com.macro.mall.demo.test.thread.productconsumer.lock;

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

/**
 * @author zxw
 * @version 1.0
 * @description 生产者
 * @data: 2020/2/12 17:37
 */
public class Producer implements Runnable {

    private int maxNum = 10;
    private int currentNum = 0;
    private LinkedList<String> list;
    private Lock lock;
    private Condition condition;

    public Producer(LinkedList<String> list, Lock lock, Condition condition) {
        this.list = list;
        this.lock = lock;
        this.condition = condition;
    }

    private void start(LinkedList<String> list, Lock lock, Condition condition) {
        while (true) {
            //生产者开始生产
            try {
                Thread.sleep(1000);
                lock.lock();
                if (list.size() >= maxNum) {
                    //如果到达最大数则等待
                    condition.await();
                }
                list.push("物品" + currentNum++);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("第" + currentNum + "增加物品，" + "==当前剩余物品：" + list.size());
            condition.signal();
            lock.unlock();
        }
    }

    @Override
    public void run() {
        start(list, lock, condition);
    }
}

消费者代码

package com.macro.mall.demo.test.thread.productconsumer.lock;

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

/**
 * @author zxw
 * @version 1.0
 * @description 消费者
 * @data: 2020/2/12 17:45
 */
public class Consumer implements Runnable {

    private LinkedList<String> list;
    private Lock lock;
    private Condition condition;

    public Consumer(LinkedList<String> list, Lock lock, Condition condition) {
        this.list = list;
        this.lock = lock;
        this.condition = condition;
    }

    private void start(LinkedList<String> list, Lock lock, Condition condition) {
        while (true) {
            try {
                Thread.sleep(2000);
                lock.lock();
                if (list.size() <= 0) {
                    condition.await();
                }
                System.out.println("消费物品：" + list.pop() + "==剩余物品：" + list.size());
                condition.signal();
                lock.unlock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

    @Override
    public void run() {
        start(list, lock, condition);
    }
}

测试类

package com.macro.mall.demo.test.thread.productconsumer.lock;

import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author zxw
 * @version 1.0
 * @description 测试
 * @data: 2020/2/12 17:50
 */
public class LockTest {
    private static LinkedList<String> list = new LinkedList<String>();
    private static ReentrantLock reentrantLock = new ReentrantLock();
    private static Condition condition = reentrantLock.newCondition();

    public static void main(String[] args) {
        Producer producer = new Producer(list, reentrantLock, condition);
        Consumer consumer = new Consumer(list, reentrantLock, condition);

        ExecutorService executorService = Executors.newFixedThreadPool(2);
        executorService.submit(producer);
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executorService.submit(consumer);
        executorService.shutdown();
    }
}