阻塞消息队列(1)------生产消费者模式实现

生产消费者模式实现------阻塞消息队列

前言

目前的java技术栈越来越丰富,除了平时用的Spring等还有各种中间件可以选择,相信MQ大家都用过,这次就来写一个简单的消息队列,希望有助于对MQ底层的理解吧.

正文

1. 涉及知识

1. volatile关键字
2. AtomicInteger
3. BlockingQueue

以上知识点不明白的地方均可在各大博客自行研究,当前博主也有类似博文,有兴趣的可以看看.

2. 设计思想

1. 首先,本着解耦并且兼并java各大队列类的方式,我们进行面向接口开发,在队列中使用所有队列的父接口BlockingQueue作为引用.
2. 考虑到多线程并发的情况,要保证逻辑的原子性,可以使用AtomicInteger类
3. 消息队列要支持关闭功能,也就是说要有方法可以关闭整个消息队列.

3. 代码实现

消息队列实现:

package com.xiaojian.demo1.controller;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 自定义阻塞消息队列
 */
public class MyQueue {

    //消息队列的开关,默认为true,如果调用关闭方法则停止生产消息
    //这里使用了volatile是要保证多线程情况下,FLAG的改变对其他线程改变(消费线程),及时停止
    private volatile boolean FLAG = true;

    //
    private AtomicInteger atomicInteger = new AtomicInteger();

    //面向接口,使用BlockingQueue来构造消息队列的父引用
    private BlockingQueue blockingQueue = null;

    //具体使用的队列类型在构造的时候传入

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

    //模拟生产方法
    public void myProd() throws Exception{
        String data = null;
        boolean result;
        while (FLAG) {
            //模拟获的向队列中保存的数据,在这里是字符串
            data = atomicInteger.incrementAndGet() + "";
            //向队列中提交数据,这里使用offer方法,因为它在插入失败的情况下回返回false,而不是抛异常
            result = blockingQueue.offer(data);
            if (result) {
                System.out.println(Thread.currentThread().getName() + "\t 插入数据:" + data + "成功");
            }else {
                System.out.println(Thread.currentThread().getName() + "\t 插入数据:" + data + "失败");
            }
            TimeUnit.SECONDS.sleep(1);
        }
        //逻辑运行到这里,说明FLAG为false,代表队列需要关闭
        System.out.println(Thread.currentThread().getName() + "\t FLAG为false,队列停止!");
    }

    //模拟消费方法
    public void myConsumer () throws Exception {
        //消费到的消息
        Object result = null;
        while (FLAG) {
            //2秒超时
            result = blockingQueue.poll(2, TimeUnit.SECONDS);
            if (null == result) {
                //如果是空的,说明队列为空,消费者需要退出
                FLAG = false;
                System.out.println(Thread.currentThread().getName() + "\t 超过2秒没有消费到消息,退出!");
                return;
            }
            System.out.println(Thread.currentThread().getName() + "\t 消费到消息:" + result);
        }

    }

    //消息队列关闭
    public void stop() {
        this.FLAG = false;
    }
}

测试:

package com.xiaojian.demo1.controller;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

public class MyQueueTest {

    public static void main(String[] args)  {
        //创建消息队列的实现,初始容量为10
        MyQueue myQueue = new MyQueue(new ArrayBlockingQueue<String>(10));

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t 生产者线程启动...");
            try {
                myQueue.myProd();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "Prod").start();

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t 消费者线程启动...");
            System.out.println();
            System.out.println();

            try {
                myQueue.myConsumer();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "Consumer").start();
        try {
            //5秒后关闭队列
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("消息队列关闭...");
        myQueue.stop();
    }
}

总结

总体来说,这个demo还是比较简单的,但是我们可以通过简单的代码来熟悉消息队列的实现原理,希望在以后能更加深入的了解~~~