多线程编程：生产者消费者模式

亦凉 2022-09-28 05:53 183阅读 0赞

1.Runnable  wait notify实现

2.堵塞队列blockingQueue

3.lock

java.util.concurrent.locks.Lock

java.util.concurrent.locks.ReentrantLock

消费者

package com.well.test.runnable;
    
    /** * Created by mhc on 2017-03-09. */ public class Consumer implements Runnable{
    
        private int conNum;
    
        public int getConNum() {
            return conNum;
        }
    
        public void setConNum(int conNum) {
            this.conNum = conNum;
        }
    
        public Storage getTest() {
            return test;
        }
    
        public void setTest(Storage test) {
            this.test = test;
        }
    
        private Storage test;
    
        public Consumer(Storage test) {
            this.test = test;
        }
    
        @Override
        public void run() {
            try {
                int i = conNum;
                while (i > 0) {
                    test.consumeCar();
                    i--;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
        }
    }

生产者

package com.well.test.runnable;
    
    /** * Created by mhc on 2017-03-09. */ public class Producer implements Runnable {
    
        public int getProNum() {
            return proNum;
        }
    
        public Storage getTest() {
            return test;
        }
    
        public void setProNum(int proNum) {
            this.proNum = proNum;
        }
    
        public void setTest(Storage test) {
            this.test = test;
        }
    
        private int proNum;
        private Storage test;
    
        public Producer(Storage test) {
            this.test = test;
        }
    
        @Override
        public void run() {
            try {
                int i = proNum;
                while (i > 0) {
                    test.produceCar();
                    i--;
                }
    
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

缓冲区

package com.well.test.runnable;
    
    /** * Created by mhc on 2017-03-09. */ public class Storage {
    
        public int num = 0;
    
        public synchronized void produceCar() throws InterruptedException {
    
            if (num >= 10) {
                this.wait();
            }
            Thread.sleep(50);
            num++;
            System.out.println(Thread.currentThread().getName() + "生产了一辆小车,当前" + num);
            this.notify();
        }
    
        public synchronized void consumeCar() throws InterruptedException {
    
            if (num <= 0) {
                this.wait();
            }
            Thread.sleep(30);
            num--;
            System.out.println(Thread.currentThread().getName() + "消费了一辆小车,当前" + num);
            this.notify();
        }
    
    }

package com.well.test.queue;
    
    import java.util.Random;
    import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.LinkedBlockingDeque;
    
    /** * Created by mhc on 2017-03-09. */ public class Storage {
    
        public BlockingQueue blockingQueue = new LinkedBlockingDeque();
    
        public  void produceCar() throws InterruptedException {
    
            Thread.sleep(50);
    
            Random random = new Random();
            int num = random.nextInt(10000);
    
            blockingQueue.put(num);
    
            System.out.println(Thread.currentThread().getName() + "生产了一辆小车,当前" + num);
        }
    
        public  void consumeCar() throws InterruptedException {
    
    
            Thread.sleep(30);
    
            int num = (int) blockingQueue.take();
    
            System.out.println(Thread.currentThread().getName() + "消费了一辆小车,当前" + num);
    
        }
    
    }

package com.well.test.lock;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    /** * Created by mhc on 2017-03-09. */ public class Storage {
    
        public int num = 0;
    
        final Lock lock = new ReentrantLock();
    
        public void produceCar() throws InterruptedException {
    
            lock.lock();
            try {
                Thread.sleep(50);
                num++;
                System.out.println(Thread.currentThread().getName() + "生产了一辆小车,当前" + num);
            } finally {
                lock.unlock();
            }
        }
    
        public void consumeCar() throws InterruptedException {
    
            lock.lock();
            try {
                while (num <= 0){
                    Thread.sleep(100);
                }
                Thread.sleep(30);
                System.out.println(Thread.currentThread().getName() + "消费了一辆小车,当前" + num);
                num--;
            } finally {
                lock.unlock();
            }
    
        }
    
    }

package com.well.test.runnable;
    
    /** * Created by mhc on 2017-03-09. */ public class Test {
    
        public static void main(String args[]) {
    
            Storage storage = new Storage();
            Producer productor1 = new Producer(storage);
            productor1.setProNum(16);
            Producer productor2 = new Producer(storage);
            productor2.setProNum(14);
    
            Consumer consumer1 = new Consumer(storage);
            consumer1.setConNum(9);
            Consumer consumer2 = new Consumer(storage);
            consumer2.setConNum(6);
    
            Thread thread_pro1 = new Thread(productor1);
            Thread thread_pro2 = new Thread(productor2);
    
            Thread thread_con1 = new Thread(consumer1);
            Thread thread_con2 = new Thread(consumer2);
    
            thread_pro1.start();
            thread_pro2.start();
    
            thread_con1.start();
            thread_con2.start();
        }
    }