生产者消费者模型.md

手写 生产者 消费者模型

纯手写，如果有报错很正常，没有经过IDEA的校验

// 生产者代码
public class Producer implements Runnable {
    private BlockingQueue<String> blockingQueue;

    public Producer (BlockingQueue<String> blockingQueue) {
        this.blockingQueue = blockingQueue;
    }

    public void run() {
        try {
            String temp = "生产者"+Thread.currentThread().getName();
            blockingqueue.put(temp);
        } catch(Exception e) {
            e.printStackTrace();
        }
    }
}

// 消费者代码
public class Consumer implements Runnable {
    private BlockingQueue<String> blockQueue;
    public Consumer(BlockingQueue queue) {
        this.blockQueue = queue;
    }
    
    public void run() {
        try {
            String temp = "消费者"+Thread.currentThread().getName();
            blockQueue.take();
        }catch(Exception e) {

        }
    }

    // test
    public static void main(String ... args) {
        BlockingQueue<Sting> blockQueue = new LindedBlockingQueue<String>();
        Producer producer = new Producer(blockQueue);
        Consumer consumer = new Consumer(blockQueue);
        for (int i=0;i<5;i++) {
            new Thread(producer).start();
            new Thread(consumer).start();
        }
    }
}

20191025 可运行版本

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;

public class ProConTest
{
    // producer and consumer
    public static void main(String[] args) throws Exception{
        BlockingQueue blockingQueue = new LinkedBlockingDeque(1);
        Producer<String> producer = new Producer<>(blockingQueue);
        Consumer<String> consumer = new Consumer<>(blockingQueue);
        new Thread(producer).start();
        new Thread(consumer).start();
    }
    static class Producer<T> implements Runnable {
        private BlockingQueue<T> blockingQueue;
        public Producer(BlockingQueue<T> blockingQueue) {
            this.blockingQueue = blockingQueue;
        }
        @Override
        public void run() {
            try {

                for (int i=0;i<10;i++){
                    T proName = (T)("生产者"+i);
                    blockingQueue.put(proName);
                    System.out.println(proName); // 因为只有blockQueue是阻塞的，所以存在sof打印先后问题
                }
            }catch (Exception e) {
            }
        }
    }
    static class Consumer<T> implements Runnable {
        private BlockingQueue<T> blockingQueue;
        public Consumer(BlockingQueue<T> blockingQueue) {
            this.blockingQueue = blockingQueue;
        }

        @Override
        public void run() {
            try {
                while (true) {
                    T data = blockingQueue.take();
                    System.out.println(data+"消费");
                }
            }catch(Exception e) {

            }
        }
    }
}

20191224 练习版本

public class PCModelTest {
    // 生产者消费者模型 练习
    public static void main(String[] args) {
        BlockingQueue<String> queue = new ArrayBlockingQueue<>(3); // 注意必须限制长度
        new Thread(new Producer<>(queue), "thread1").start();
        new Thread(new Consumer<>(queue), "thread2").start();
    }

}
class Producer<T> implements Runnable{
    BlockingQueue<T> queue;
    int count = 0;
    public Producer(BlockingQueue<T> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true) {
            try {
                queue.put((T)("count" +(++count))); // put 会阻塞
            }catch (Exception e) {

            }
        }
    }
}
class Consumer<T> implements Runnable {
    BlockingQueue<T> queue;
    public Consumer(BlockingQueue<T> queue) {
        this.queue = queue;
    }
    @Override
    public void run() {
        while (true) {
            try {
                T t = queue.take(); // take 会阻塞
                System.out.println(t);
            }catch (Exception e) {

            }
        }
    }
}