java生产者消费模式

在这里我就不过多的对生产者和消费者模式详细描述，网上一大把，我这里主要有两种实现方式，一种是使用synchronized关键字，还有一种是使用juc里面的api，直接上代码吧

synchronized：

public class ProducerAndConsumer {
    static final Object lock = new Object();
    public static void main(String[] args) {
        ThreadFactory threadFactory = Executors.defaultThreadFactory();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 10, 10, TimeUnit.DAYS,
                new ArrayBlockingQueue<Runnable>(10),threadFactory);
        threadPoolExecutor.execute(new Producer());
        threadPoolExecutor.execute(new Consumer());
    }
}
class Producer implements Runnable{
    @Override
    public void run() {
        synchronized (ProducerAndConsumer.lock){
            while (true){
                try {
                    System.out.println("i am producer");
                    ProducerAndConsumer.lock.notify();
                    ProducerAndConsumer.lock.wait();
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
class Consumer implements Runnable{
    @Override
    public void run() {
        synchronized (ProducerAndConsumer.lock){
            while (true){
                try {
                    System.out.println("i am consumer");
                    ProducerAndConsumer.lock.notify();
                    ProducerAndConsumer.lock.wait();
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

juc：

public class LockSupportTest {
    static int count = 1;
    static ReentrantLock lock = new ReentrantLock();
    static Condition condition = lock.newCondition();
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        executorService.execute(new Producer());
        executorService.execute(new Consumer());
    }
    static class Producer extends Thread{
        @Override
        public void run() {
            while (true) {
                try {
                    lock.lock();
                    System.out.println("我是生产者：" + ++count);
                    Thread.sleep(1000);
                    condition.signal();//唤醒一个线程
                    condition.await();//当前线程堵塞
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
    }
    static class Consumer extends Thread{
        @Override
        public void run() {
            while (true) {
                try {
                    lock.lock();
                    System.out.println("我是消费者：" + --count);
                    Thread.sleep(1000);
                    condition.signal();
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
    }
}