互联网技术06——使用wait/notify模拟Quene

BlockingQuene，Block即阻塞队列，在这里我们试着实现LinkBlockQuene的put和take两个方法

put：把数据放入队列中，如果队列没空间，则一直阻塞，直到quene中有空间剩余，然后将数据放入队列中。

take:从quene中取第一个（FIFO）元素，如果队列中没有元素，则阻塞，直到队列有数据进来，然后继续执行取操作。

代码如下

package com.company;

import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Created by BaiTianShi on 2018/8/16.
 */
public class BlockQueueModal {
    //有序的存放元素的容器（linkList删减元素效率高）
    private final LinkedList<String> list = new LinkedList<>();

    private int minSize = 0 ;
    private int maxSize = 1;

    //原子性计数器
    private AtomicInteger count = new AtomicInteger(minSize);

    //两线程间通信的锁
    private final Object lock = new Object();

//    构造方法，指定maxSize大小
    public BlockQueueModal(int maxSize) {
        this.maxSize = maxSize;
    }
    //默认的构造方法
    public BlockQueueModal() {

    }
    //放元素
    public void put(String str){
        //上锁
        synchronized (lock){
            //如果队列满了，则线程阻塞等待
            if(count.intValue() == this.maxSize){
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //如果未队列没满，则加入元素
            this.list.add(str);
            //计数器加1
            count.incrementAndGet();
            //通知等待的线程，可以取元素了。
            //如果在此之前，有一线程 A 向队列中取首元素，但是队列是空的，则此线程一直等待着呢
            //正好本线程 B 刚刚执行了put方法，向队列中放入了元素，那线程 A 就可以结束阻塞状态，取走队列中的首元素
            lock.notify();
        }
    }

    public String take(){
        synchronized (lock){
            //如果队列大小等于最小值，则进入阻塞状态，直到有新元素放入
            if(count.get() == this.minSize){
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //如果大于最小值，则计数器减1，准备取出首元素
            count.decrementAndGet();
            //并通知肯能等待的put方法，可以继续放元素了
            lock.notify();
        }
        //取出首元素作为返回值返回
        return  list.removeFirst();
    }

    public static void main(String[] args) {
        BlockQueueModal bm =new BlockQueueModal(3);
        bm.put("str ="+ String.valueOf(1));
        bm.put("str ="+ String.valueOf(2));
        bm.put("str ="+ String.valueOf(3));
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=4;i<6;i++){
                    bm.put("str ="+ String.valueOf(i));
                    System.out.println("添加的："+"str ="+ String.valueOf(i));
                }
            }
        },"t1");
        t1.start();
        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                Object o1 = bm.take();
                System.out.println("移除的元素为："+o1);
                Object o2 = bm.take();
                System.out.println("移除的元素为："+o2);
            }
        },"t2");

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();
    }
}

执行结果：

移除的元素为：str =1
移除的元素为：str =2
添加的：str =4
添加的：str =5

由执行结果，我们可以看得出，只有在取出两个元素str=1和str=2时，才能继续放入str=4和str=5；

 

下面我们改变main方法，来测试取元素时，队列为空的情况

public static void main(String[] args) {
        BlockQueueModal bm =new BlockQueueModal(3);

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=4;i<6;i++){
                    bm.put("str ="+ String.valueOf(i));
                    System.out.println("添加的："+"str ="+ String.valueOf(i));
                }
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                Object o1 = bm.take();
                System.out.println("移除的元素为："+o1);
                Object o2 = bm.take();
                System.out.println("移除的元素为："+o2);
            }
        },"t2");
        t2.start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t1.start();
    }

结果：

添加的：str =4
添加的：str =5
移除的元素为：str =4
移除的元素为：str =5

main方法中，我们先执行的t2线程的take方法，并且中间线程sleep了2秒，但是打印的结果是先放元素再取元素。这就是因为队列中没有元素，线程t2只能等待，随后t1执行了put方法，并通知了t2可以取元素了