三种解决消费者生产者问题的方案

古城微笑少年丶 2023-06-23 08:54 43阅读 0赞

提供三种方法来解决消费者生产者问题

第一种：利用synchronized与wait、notify

public class ProConWN {
        public static void main(String[] args) {
            LinkedList linkedList = new LinkedList();
            ExecutorService service = Executors.newFixedThreadPool(15);
            for (int i = 0; i < 5; i++) {
                service.submit(new Productor(linkedList, 8));
            }
            for (int i = 0; i < 10; i++) {
                service.submit(new Consumer(linkedList));
            }
        }
    
    
        static class Productor implements Runnable {
            private List<Integer> list;
    
            private int maxLength;
    
            public Productor(List<Integer> list, int maxLength) {
                this.list = list;
                this.maxLength = maxLength;
            }
    
            @Override
            public void run() {
                while (true) {
                    synchronized (list) {
                        try {
                            while (list.size() == maxLength) {
                                System.out.println("生产者" + Thread.currentThread().getName() + "list已达到最大容量，进行wait等待");
                                list.wait();
                                System.out.println("生产者" + Thread.currentThread().getName() + "退出wait");
                            }
                            Random random = new Random();
                            int i = random.nextInt();
                            System.out.println("生产者" + Thread.currentThread().getName() + "生产数据" + i);
                            list.add(i);
                            list.notifyAll();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
    
                    }
                }
            }
        }
    
        static class Consumer implements Runnable {
    
            private List<Integer> list = null;
    
            public Consumer(List list) {
                this.list = list;
    
            }
    
            @Override
            public void run() {
                while (true) {
                    synchronized (list) {
                        try {
                            while (list.isEmpty()) {
                                System.out.println("消费者" + Thread.currentThread().getName() + "list为空，进行wait等候");
                                list.wait();
                                System.out.println("消费者" + Thread.currentThread().getName() + "退出wait");
    
                            }
                            Integer element = list.remove(0);
                            System.out.println("消费者" + Thread.currentThread().getName() + "消费数据" + element);
                            list.notifyAll();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    
    
    }

第二种：利用lock锁

public class ProConLock {
        private static ReentrantLock lock = new ReentrantLock();
        private static Condition full = lock.newCondition();
        private static Condition empty = lock.newCondition();
    
        public static void main(String[] args) {
            LinkedList linkedList = new LinkedList();
            ExecutorService service = Executors.newFixedThreadPool(15);
    
            for (int i = 0; i < 5; i++) {
                service.submit(new Productor(linkedList, 8, lock));
    
            }
            for (int i = 0; i < 10; i++) {
                service.submit(new Consumer(linkedList, lock));
            }
        }
    
        static class Productor implements Runnable {
    
            private List<Integer> list;
            private int maxLength;
            private Lock lock;
    
            public Productor(List<Integer> list, int maxLength, Lock lock) {
                this.list = list;
                this.maxLength = maxLength;
                this.lock = lock;
            }
    
            @Override
            public void run() {
    
                while (true) {
                    lock.lock();
                    try {
                        while (list.size() == maxLength) {
                            System.out.println("生产者" + Thread.currentThread().getName() + "list达到最大容量，进行wait");
                            full.await();
                            System.out.println("生产者" + Thread.currentThread().getName() + "退出wait");
                        }
                        Random random = new Random();
                        int i = random.nextInt();
                        System.out.println("生产者" + Thread.currentThread().getName() + "生产数据" + i);
                        list.add(i);
                        empty.signalAll();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }
                }
            }
        }
    
        static class Consumer implements Runnable {
            private List<Integer> list;
            private Lock lock;
    
            public Consumer(List<Integer> list, Lock lock) {
                this.list = list;
                this.lock = lock;
            }
    
    
            @Override
            public void run() {
                while (true) {
                    lock.lock();
                    try {
                        while (list.isEmpty()) {
                            System.out.println("消费者" + Thread.currentThread().getName() + "list为空，进行wait");
                            empty.await();
                            System.out.println("消费者" + Thread.currentThread().getName() + "退出wait");
    
                        }
                        Integer element = list.remove(0);
                        System.out.println("消费者" + Thread.currentThread().getName() + "消费数据" + element);
                        full.signalAll();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }
                }
    
            }
        }

第三种：利用阻塞队LinkedBlockingQueue

public class ProConBlocking {
        private static LinkedBlockingQueue<Math> queue = new LinkedBlockingQueue<Math>();
    
        public static void main(String[] args) {
            ExecutorService service = Executors.newFixedThreadPool(15);
            for (int i = 0; i < 5; i++) {
    
    
                service.submit(new Productor(queue));
    
    
            }
            for (int i = 0; i < 10; i++) {
                service.submit(new Consumer(queue));
            }
        }
    
        static class Productor implements Runnable {
            private BlockingQueue<Integer> queue;
    
    
            public Productor(BlockingQueue queue) {
                this.queue = queue;
    
    
            }
    
            @Override
            public void run() {
                try {
                    while (true) {
                        Random random = new Random();
                        int i = random.nextInt();
                        System.out.println("生产者" + Thread.currentThread().getName() + "生产数据" + i);
                        queue.put(i);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        static class Consumer implements Runnable {
            private BlockingQueue<Integer> queue;
    
            public Consumer(BlockingQueue queue) {
                this.queue = queue;
    
            }
    
            @Override
            public void run() {
                try {
                    while (true) {
                        Integer element = queue.take();
                        System.out.println("消费者" + Thread.currentThread().getName() + "正在消费数据" + element);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }