Java多线程-生产者消费者几种实现方式

最新推荐文章于 2024-06-06 11:20:48 发布

寒江蓑笠

最新推荐文章于 2024-06-06 11:20:48 发布

阅读量1.8k

点赞数

分类专栏： Java Android开发文章标签： java 多线程

本文链接：https://blog.csdn.net/heqiangflytosky/article/details/51568397

版权

Android开发同时被 2 个专栏收录

91 篇文章 2 订阅

订阅专栏

Java

12 篇文章 0 订阅

订阅专栏

http://blog.csdn.net/monkey_d_meng/article/details/6251879

wait()/notify()方法

http://blog.csdn.net/ghsau/article/details/7433673

    public void doWork(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                Storage storage = new Storage();

                Producer p1 = new Producer(storage);
                p1.setNum(10);
                p1.setName("p1");

                Producer p2 = new Producer(storage);
                p2.setNum(10);
                p2.setName("p2");

                Consumer c1 = new Consumer(storage);
                c1.setNum(15);
                c1.setName("c1");

                Consumer c2 = new Consumer(storage);
                c2.setNum(15);
                c2.setName("c2");

                Consumer c3 = new Consumer(storage);
                c3.setNum(15);
                c3.setName("c3");

                Producer p3 = new Producer(storage);
                p3.setNum(10);
                p3.setName("p3");

                Producer p4 = new Producer(storage);
                p4.setNum(10);
                p4.setName("p4");

                Producer p5 = new Producer(storage);
                p5.setNum(10);
                p5.setName("p5");

                p1.start();
                p2.start();
                c1.start();
                c2.start();
                c3.start();
                p3.start();
                p4.start();
                p5.start();

            }
        }).start();
    }

    public static class Storage{
        private static int MAX = 100;
        private ArrayList<Object> mObjectArrayList = new ArrayList<>(100);
        public void produce(int num){
            Log.e("Test",Thread.currentThread().getName()+", produce num = "+num);
            synchronized (mObjectArrayList){
                Log.e("Test",Thread.currentThread().getName()+", enter produce");
                while (mObjectArrayList.size()+num > MAX){
                    Log.e("Test",Thread.currentThread().getName()+", 需要生产 "+num+" 个， 目前有" +mObjectArrayList.size()+"个");
                    try {
                        mObjectArrayList.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                for(int i=1;i<=num;i++){
                    mObjectArrayList.add(new Object());
                }
                mObjectArrayList.notifyAll();
                Log.e("Test",Thread.currentThread().getName()+", 生产 "+num+" 个产品，目前总数"+mObjectArrayList.size());
            }
        }

        public void consume(int num){
            Log.e("Test",Thread.currentThread().getName()+", consume num = "+num);
            synchronized (mObjectArrayList){
                Log.e("Test",Thread.currentThread().getName()+", enter consume");
                while (mObjectArrayList.size()-num < 0){
                    Log.e("Test",Thread.currentThread().getName()+", 需要消费 "+num+" 个， 目前有" +mObjectArrayList.size()+"个");
                    try {
                        mObjectArrayList.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                int size = mObjectArrayList.size();
                for(int i=0;i<num;i++){
                    mObjectArrayList.remove(0);
                }
                mObjectArrayList.notifyAll();
                Log.e("Test",Thread.currentThread().getName()+", 消费 "+num+" 个产品，目前总数"+mObjectArrayList.size());
            }
        }
    }

    public static class Producer extends Thread{
        private Storage mStorage;

        public int getNum() {
            return mNum;
        }

        public void setNum(int num) {
            mNum = num;
        }

        private int mNum;
        public Producer(Storage storage){
            mStorage = storage;
        }

        @Override
        public void run() {
            super.run();
            mStorage.produce(mNum);
        }
    }

    public static class Consumer extends Thread{
        private Storage mStorage;

        public int getNum() {
            return mNum;
        }

        public void setNum(int num) {
            mNum = num;
        }

        private int mNum;
        public Consumer(Storage storage){
            mStorage = storage;
        }

        @Override
        public void run() {
            super.run();
            mStorage.consume(mNum);
        }
    }

结果：

E/Test    (18509): p1, produce num = 10
E/Test    (18509): p1, enter produce
E/Test    (18509): p1, 生产 10 个产品，目前总数10
E/Test    (18509): p2, produce num = 10
E/Test    (18509): p2, enter produce
E/Test    (18509): p2, 生产 10 个产品，目前总数20
E/Test    (18509): c1, consume num = 15
E/Test    (18509): c1, enter consume
E/Test    (18509): c1, 消费 15 个产品，目前总数5
E/Test    (18509): c2, consume num = 15
E/Test    (18509): c2, enter consume
E/Test    (18509): c2, 需要消费 15 个， 目前有5个
E/Test    (18509): c3, consume num = 15
E/Test    (18509): c3, enter consume
E/Test    (18509): c3, 需要消费 15 个， 目前有5个
E/Test    (18509): p3, produce num = 10
E/Test    (18509): p3, enter produce
E/Test    (18509): p3, 生产 10 个产品，目前总数15
E/Test    (18509): c2, 消费 15 个产品，目前总数0
E/Test    (18509): c3, 需要消费 15 个， 目前有0个
E/Test    (18509): p4, produce num = 10
E/Test    (18509): p4, enter produce
E/Test    (18509): p4, 生产 10 个产品，目前总数10
E/Test    (18509): p5, produce num = 10
E/Test    (18509): c3, 需要消费 15 个， 目前有10个
E/Test    (18509): p5, enter produce
E/Test    (18509): p5, 生产 10 个产品，目前总数20
E/Test    (18509): c3, 消费 15 个产品，目前总数5

await()/signal()方法

http://blog.csdn.net/ghsau/article/details/7481142
其他代码不用修改，只需要修改Storage类

    public static class Storage{
        private static int MAX = 100;
        private ArrayList<Object> mObjectArrayList = new ArrayList<>(100);
        final Lock lock = new ReentrantLock();//锁对象
        final Condition produce  = lock.newCondition();//写线程条件
        final Condition consume = lock.newCondition();//读线程条件
        public void produce(int num){
            Log.e("Test", Thread.currentThread().getName() + ", produce num = " + num);
            lock.lock();
            Log.e("Test", Thread.currentThread().getName() + ", enter produce");
            try{
                while (mObjectArrayList.size()+num > MAX){
                    Log.e("Test",Thread.currentThread().getName()+", 需要生产 "+num+" 个， 目前有" +mObjectArrayList.size()+"个");
                    produce.await();
                }
                for(int i=1;i<=num;i++){
                    mObjectArrayList.add(new Object());
                }
                consume.signalAll();
                Log.e("Test",Thread.currentThread().getName()+", 生产 "+num+" 个产品，目前总数"+mObjectArrayList.size());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }

        public void consume(int num){
            Log.e("Test",Thread.currentThread().getName()+", consume num = "+num);
            lock.lock();
            Log.e("Test",Thread.currentThread().getName()+", enter consume");
            try{
                while (mObjectArrayList.size()-num < 0){
                    Log.e("Test",Thread.currentThread().getName()+", 需要消费 "+num+" 个， 目前有" +mObjectArrayList.size()+"个");
                    consume.await();
                }
                for(int i=0;i<num;i++){
                    mObjectArrayList.remove(0);
                }
                produce.signalAll();
                Log.e("Test",Thread.currentThread().getName()+", 消费 "+num+" 个产品，目前总数"+mObjectArrayList.size());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
    }

结果：

E/Test    (25741): p1, produce num = 10
E/Test    (25741): p1, enter produce
E/Test    (25741): p1, 生产 10 个产品，目前总数10
E/Test    (25741): p2, produce num = 10
E/Test    (25741): p2, enter produce
E/Test    (25741): p2, 生产 10 个产品，目前总数20
E/Test    (25741): c1, consume num = 15
E/Test    (25741): c1, enter consume
E/Test    (25741): c1, 消费 15 个产品，目前总数5
E/Test    (25741): c3, consume num = 15
E/Test    (25741): c2, consume num = 15
E/Test    (25741): c3, enter consume
E/Test    (25741): c3, 需要消费 15 个， 目前有5个
E/Test    (25741): c2, enter consume
E/Test    (25741): c2, 需要消费 15 个， 目前有5个
E/Test    (25741): p3, produce num = 10
E/Test    (25741): p3, enter produce
E/Test    (25741): p4, produce num = 10
E/Test    (25741): p3, 生产 10 个产品，目前总数15
E/Test    (25741): c3, 消费 15 个产品，目前总数0
E/Test    (25741): c2, 需要消费 15 个， 目前有0个
E/Test    (25741): p4, enter produce
E/Test    (25741): p4, 生产 10 个产品，目前总数10
E/Test    (25741): c2, 需要消费 15 个， 目前有10个
E/Test    (25741): p5, produce num = 10
E/Test    (25741): p5, enter produce
E/Test    (25741): p5, 生产 10 个产品，目前总数20
E/Test    (25741): c2, 消费 15 个产品，目前总数5

BlockingQueue方法

http://wsmajunfeng.iteye.com/blog/1629354
http://blog.csdn.net/ghsau/article/details/8108292
内部实现是用await()/signal()方法来实现的，具体可以查看源码。
其他代码不用修改，只需要修改Storage类

    public static class Storage{
        private static int MAX = 100;
        private BlockingQueue<Object> productQueue = new ArrayBlockingQueue<Object>(MAX);
        public void produce(int num){
            Log.e("Test",Thread.currentThread().getName()+", 需要生产 "+num+" 个， 目前有" +productQueue.size()+"个");
            try {
                for(int i=1;i<=num;i++){
                    productQueue.put(new Object());
                }
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
            Log.e("Test",Thread.currentThread().getName()+", 生产 "+num+" 个产品，目前总数"+productQueue.size());
        }

        public void consume(int num){
            Log.e("Test",Thread.currentThread().getName()+", 需要消费 "+num+" 个， 目前有" +productQueue.size()+"个");
            try {
                for(int i=1;i<=num;i++){
                    productQueue.take();
                }
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
            Log.e("Test",Thread.currentThread().getName()+", 消费 "+num+" 个产品，目前总数"+productQueue.size());
        }
    }

结果：

E/Test    (31235): p1, 需要生产 10 个， 目前有0个
E/Test    (31235): p2, 需要生产 10 个， 目前有10个
E/Test    (31235): p1, 生产 10 个产品，目前总数10
E/Test    (31235): p2, 生产 10 个产品，目前总数20
E/Test    (31235): c1, 需要消费 15 个， 目前有20个
E/Test    (31235): c1, 消费 15 个产品，目前总数5
E/Test    (31235): c2, 需要消费 15 个， 目前有5个
E/Test    (31235): c3, 需要消费 15 个， 目前有0个
E/Test    (31235): p3, 需要生产 10 个， 目前有0个
E/Test    (31235): p4, 需要生产 10 个， 目前有0个
E/Test    (31235): p3, 生产 10 个产品，目前总数4
E/Test    (31235): c2, 消费 15 个产品，目前总数2
E/Test    (31235): p5, 需要生产 10 个， 目前有2个
E/Test    (31235): p4, 生产 10 个产品，目前总数12
E/Test    (31235): p5, 生产 10 个产品，目前总数6
E/Test    (31235): c3, 消费 15 个产品，目前总数5

寒江蓑笠

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java多线程-生产者消费者几种实现方式

http://blog.csdn.net/monkey_d_meng/article/details/6251879wait()/notify()方法http://blog.csdn.net/ghsau/article/details/7433673 public void doWork(){ new Thread(new Runnable() { @O
复制链接

扫一扫