Java 生产者和消费者面试题

冷不防 2021-07-24 11:05 399阅读 0赞

# 一 面试题 #

写一个固定容量同步容器，拥有 put 和 get 方法。

能够支持 2 个生产者线程以及 10 个消费者线程的阻塞调用。

# 二 使用 synchronized 同步机制解决 #

## 1 代码 ##

/**
    * 使用wait和notify/notifyAll来实现
    */
    import java.util.LinkedList;
    import java.util.concurrent.TimeUnit;
    
    public class MyContainer1<T> {
        // 记下的是生产者线程和它生产的产品
        final private LinkedList<T> lists = new LinkedList<>();
        final private int MAX = 10; // 最多10个元素
        private int count = 0;
    
        public synchronized void put(T t) {
            while (lists.size() == MAX) { // 想想为什么用 while 而不是用 if？
                try {
                    this.wait(); //effective java
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    
            lists.add(t);
            ++count;
            this.notifyAll(); // 通知消费者线程进行消费
        }
    
        public synchronized T get() {
            T t = null;
            while (lists.size() == 0) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            t = lists.removeFirst();
            count--;
            this.notifyAll(); //通知生产者进行生产
            return t;
        }
    
        public static void main(String[] args) {
            MyContainer1<String> c = new MyContainer1<>();
            // 启动消费者线程
            for (int i = 0; i < 10; i++) {
                new Thread(() -> {
                    for (int j = 0; j < 5; j++) System.out.println(c.get());
                }, "c" + i).start();
            }
    
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
    
            // 启动生产者线程
            for (int i = 0; i < 2; i++) {
                new Thread(() -> {
                    for (int j = 0; j < 25; j++) c.put(Thread.currentThread().getName() + " " + j);
                }, "p" + i).start();
            }
        }
    }

# 2 测试 #

> p1 0
> 
> p0 8
> 
> p0 7
> 
> p0 1
> 
> p0 11
> 
> p0 12
> 
> p0 4
> 
> p0 6
> 
> p0 15
> 
> p1 2
> 
> p0 0
> 
> p0 5
> 
> p1 1
> 
> p0 3
> 
> p1 6
> 
> p1 7
> 
> p0 2
> 
> p1 8
> 
> p1 10
> 
> p1 5
> 
> p1 4
> 
> p1 3
> 
> p0 16
> 
> p0 14
> 
> p0 13
> 
> p0 10
> 
> p1 16
> 
> p0 9
> 
> p0 18
> 
> p1 17
> 
> p1 18
> 
> p1 15
> 
> p1 14
> 
> p1 19
> 
> p1 20
> 
> p1 13
> 
> p1 12
> 
> p0 17
> 
> p1 22
> 
> p0 20
> 
> p1 11
> 
> p1 9
> 
> p1 23
> 
> p0 22
> 
> p0 23
> 
> p0 21
> 
> p1 24
> 
> p1 21
> 
> p0 24
> 
> p0 19

## 3 说明 ##

使用 wait 和 notify/notifyAll 来实现。

该实现存在一个问题：生产者把所有生产者和消费者一起都叫醒。消费者把所有生产者和消费者一起都叫醒

# 三 使用 Condition 精确叫醒特定线程组 #

## 1 代码 ##

/**
    * 使用Lock和Condition来实现
    * 对比两种方式，Condition的方式可以更加精确的指定哪些线程被唤醒
    */
    
    import java.util.LinkedList;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    
    public class MyContainer2<T> {
        // 记下的是生产者线程和它生产的产品
        final private LinkedList<T> lists = new LinkedList<>();
        final private int MAX = 10; // 最多10个元素
        private int count = 0;
    
    
        private Lock lock = new ReentrantLock();
        // 能精确叫醒一组线程，newCondition 会产生一个等待队列，队列中是生产者
        private Condition producer = lock.newCondition();
        // newCondition 会产生一个等待队列，队列中是消费
        private Condition consumer = lock.newCondition();
    
    
        // 生产
        public void put(T t) {
            try {
                lock.lock();
                while (lists.size() == MAX) { // 想想为什么用while而不是用if？
                    producer.await();
                }
                lists.add(t);
                ++count;
                consumer.signalAll(); // 通知消费者线程进行消费，不叫醒生产者
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    
    
        // 消费
        public T get() {
            T t = null;
            try {
                lock.lock();
                while (lists.size() == 0) {
                    consumer.await();
                }
                t = lists.removeFirst();
                count--;
                producer.signalAll(); // 通知生产者进行生产，不叫醒消费者
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
            return t;
        }
    
    
        public static void main(String[] args) {
            MyContainer2<String> c = new MyContainer2<>();
            //启动消费者线程
            for (int i = 0; i < 10; i++) {
                new Thread(() -> {
                    for (int j = 0; j < 5; j++) System.out.println(c.get());
                }, "c" + i).start();
            }
    
    
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
    
            //启动生产者线程
            for (int i = 0; i < 2; i++) {
                new Thread(() -> {
                    for (int j = 0; j < 25; j++) c.put(Thread.currentThread().getName() + " " + j);
                }, "p" + i).start();
            }
        }
    }

## 2 测试 ##

> p0 0
> 
> p0 9
> 
> p0 8
> 
> p0 1
> 
> p0 6
> 
> p0 4
> 
> p0 7
> 
> p0 5
> 
> p0 3
> 
> p0 2
> 
> p0 13
> 
> p1 4
> 
> p0 12
> 
> p1 3
> 
> p0 11
> 
> p0 17
> 
> p1 2
> 
> p0 10
> 
> p1 1
> 
> p1 0
> 
> p1 8
> 
> p1 7
> 
> p1 6
> 
> p0 19
> 
> p0 18
> 
> p0 16
> 
> p0 15
> 
> p0 14
> 
> p1 5
> 
> p1 13
> 
> p0 23
> 
> p0 24
> 
> p1 12
> 
> p0 22
> 
> p0 21
> 
> p0 20
> 
> p1 11
> 
> p1 10
> 
> p1 9
> 
> p1 20
> 
> p1 19
> 
> p1 18
> 
> p1 17
> 
> p1 16
> 
> p1 15
> 
> p1 14
> 
> p1 21
> 
> p1 22
> 
> p1 23
> 
> p1 24