JAVAEE初阶相关内容第八弹--多线程（初阶）

public class ThreadD21 {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<>();
        blockingQueue.put("hi");
        String s = blockingQueue.take();
        System.out.println(s);
    }
}

生产者消费者模型

public class ThreadD22 {
    public static void main(String[] args) {
        BlockingQueue<Integer> blockingQueue = new LinkedBlockingQueue<>();
        //创建两个线程
        //消费者线程
        Thread customer = new Thread(() ->{
            while (true){
                try {
                    Integer result = blockingQueue.take();
                    System.out.println("消费元素" +result);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        customer.start();
        Thread producer = new Thread(() ->{
            int count = 0;
            while(true){
                try {
                    blockingQueue.put(count);
                    System.out.println("生产元素 " + count);
                    count++;
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        producer.start();
    }
}

运行代码结果：

阻塞队列的实现

普通队列实现：

实现阻塞队列，首先要实现普通队列，构建一个类，名为MyBlockingQueue1，在这个类中写出入队列和出队列的两个操作。

首先定义四个变量。定义一个数组，数组的长度，队首标记和队尾标记。

   private int[] items= new int[1000];
    private int tail = 0;
    private int head = 0;
    private int size = 0;

入队列：

传值进入，进行条件判断

如果元素个数与数组的长度相同，这时队满，没空插入新元素，进行返回。

将想入队列的元素赋值给尾标记的位置，将尾标记向后加加指向后一个元素。

如果尾标记指向的位置大于或者等于数组的长度，则将尾标记置为0。

最后数组进行size++操作。

迷糊点：items.length与size的区别！一个是系统就给这个数组分配了这么多的存储空间，而size是实际上数组这里存储的长度。

还要注意tali++的位置！

//入队列操作
 public void put(int value){
        if(size == items.length){
            return;
        }
        items[tail] = value;
        tail ++;
        if(tail >= items.length ){
            tail = 0;
        }
        size++;
    }

出队列：

首先进行判断，假如队列为空，size等于0，则不能出队列，返回。

如果头标记的位置大于等于整个数组的长度，则需要将头标记位记为0.

进行修改，设置一个变量result,将头标记指向的元素存到result中，返回。

head标记为进行向后挪动，数组里真正的元素少1所以进行size--操作。

注意代码执行的位置！！

//出队列操作
public Integer take(){
        if(size == 0){
            return null;
        }
        int result =items[head];
        head++;

        if(head >= items.length){
            head = 0;
        }
        size--;
        return result;
    }

完整代码：

在主函数中需要注意的点：

拿出元素queue.take()

放入元素queue.put(value)

class MyBlockingQueue1{
    private int[] items= new int[1000];
    private int tail = 0;
    private int head = 0;
    private int size = 0;

    //入队列
    public void put(int value){
        if(size == items.length){
            return;
        }
        items[tail] = value;
        tail ++;
        if(tail >= items.length ){
            tail = 0;
        }
        size++;
    }

    //出队列

    public Integer take(){
        if(size == 0){
            return null;
        }
        int result =items[head];
        head++;

        if(head >= items.length){
            head = 0;
        }
        size--;
        return result;
    }
}
public class ThreadD23 {
    public static void main(String[] args) throws InterruptedException {
        MyBlockingQueue queue = new MyBlockingQueue();
        queue.put(1);
        queue.put(2);
        queue.put(3);
        queue.put(4);
        int result = queue.take();
        System.out.println("result = "+result);
        result = queue.take();
        System.out.println("result = "+result);
        result = queue.take();
        System.out.println("result = "+result);
        result = queue.take();
        System.out.println("result = "+result);

    }
}

加阻塞

需要注意的是，这里加阻塞功能就以为着程序是要在多线程条件下。要想实现阻塞功能，首先要保证需要实现线程安全。

加锁

首先为了保证线程安全，就需要将代码上锁，如图：

加阻塞

自己版本的阻塞队列最终版代码实现：

class MyBlockingQueue1{
    private int[] items= new int[1000];
    private int tail = 0;
    private int head = 0;
    private int size = 0;

    //入队列
    public void put(int value) throws InterruptedException {
        synchronized (this) {
            while(size == items.length){
                //return;
                this.wait();
            }
            items[tail] = value;
            tail ++;
            if(tail >= items.length ){
                tail = 0;
            }
            //这个notify唤醒的是take的wait
            this.notify();
            size++;
        }
    }

    //出队列

    public Integer take() throws InterruptedException {
        int result = 0;
        synchronized (this) {
            while(size == 0){
               // return null;
                this.wait();
            }
             result =items[head];
            head++;

            if(head >= items.length){
                head = 0;
            }
            size--;

            //唤醒put中的wait;
            this.notify();
        }
        return result;
    }
}
public class ThreadD23 {
    public static void main(String[] args) throws InterruptedException {
        MyBlockingQueue queue = new MyBlockingQueue();
        queue.put(1);
        queue.put(2);
        queue.put(3);
        queue.put(4);
        int result = queue.take();
        System.out.println("result = "+result);
        result = queue.take();
        System.out.println("result = "+result);
        result = queue.take();
        System.out.println("result = "+result);
        result = queue.take();
        System.out.println("result = "+result);

    }
}