01蚂蚁-并发编程——并发编程线程池原理——1.阻塞队列与非阻塞队列并发队列

1.并发队列ConcuttrentLinkedQueue(非阻塞)、BlockingQueue(阻塞式)

阻塞式与非阻塞式队列的区别

1. 入列、出列
   阻塞式：
   入列（存队列）阻塞式队列，如果超出队列总数，这时候会进行等待。
   出列（获取队列），如果获取队列为空的情况下，这时候也会进行等待（阻塞）。
   队列：主要遵循先进先出、后进后出。
   
   注意事项：消费者，在消费队列信息的时候，一定要清空掉。
   1.当消费者，获取队列的之后，这个直接被删除。

阻塞式队列

package thread_day05;

import java.util.concurrent.ConcurrentLinkedQueue;

public class Test0002 {
    //阻塞式队列最大的好处，能够防止队列容器溢出，防止丢失数据。
    public static void main(String[] args) {
        //非阻塞式队列，无界队列
        ConcurrentLinkedQueue<String> concurrentLinkedQueue = new ConcurrentLinkedQueue();
        concurrentLinkedQueue.offer("张三");
        concurrentLinkedQueue.offer("李四");
        concurrentLinkedQueue.offer("吴坚");
        //获取队列 只能获取一个队列元素
        System.out.println(concurrentLinkedQueue.peek());//取玩不会删除
        System.out.println(concurrentLinkedQueue.poll());//取完会删除
        //获取队列的个数
        System.out.println(concurrentLinkedQueue.size());
    }
}

非阻塞式队列

package thread_day05;

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

public class Test0003 {
    //如果存队列的时候，如果满了，就会等待，如果取队列的时候，如果获取不到，也会等待
    public static void main(String[] args) throws InterruptedException {
        //最多支持3队列总数，阻塞式队列
        BlockingQueue blockingQueue = new ArrayBlockingQueue(3);
        blockingQueue.offer("张三");//添加非阻塞式
        blockingQueue.offer("李四",3, TimeUnit.SECONDS);
        System.out.println(blockingQueue.poll());
        //不会等待
        System.out.println(blockingQueue.poll(3,TimeUnit.SECONDS));
        System.out.println(blockingQueue.poll(3,TimeUnit.SECONDS));
    }
}

单个jvm做并发队列

package thread_day05;
//使用BlockingQueue(队列)模拟生产者与消费者

import com.produceConsumer.ConsumeThread;
import org.apache.commons.lang.StringUtils;

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

//生产者 添加队列
class ProducerThread implements Runnable{
    public BlockingQueue<String> blockingQueue;
    public volatile  boolean FLAG = true;
    AtomicInteger atomicInteger = new AtomicInteger();
    public ProducerThread(BlockingQueue<String> blockingQueue){
        this.blockingQueue = blockingQueue;
    }
    @Override
    public void run() {
        System.out.println("###生产者线程已经启动###");
        try {
            while(FLAG) {
                String data = atomicInteger.incrementAndGet() + ""; //每次会加一
                boolean offer = blockingQueue.offer(data, 2, TimeUnit.SECONDS);//阻塞式队列 存放队列
                if (offer) {
                    System.out.println("生产者存入队列成功！data:" + data);
                } else {
                    System.out.println("生产者存入队列失败！data:" + data);
                }
                Thread.sleep(1000);
              }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
            System.out.println("生产者已经结束。。。");
        }
    }
    public void stop(){
        this.FLAG = false;
    }
}

//消费者队列 获取队列
class ConsumerThread implements Runnable{
    public BlockingQueue<String> blockingQueue;
    public volatile  boolean FLAG = true;
    public ConsumerThread(BlockingQueue<String> blockingQueue){
        this.blockingQueue = blockingQueue;
    }
    @Override
    public void run() {
        System.out.println("消费者线程已经启动");
        try {
            while (FLAG){
                String data = blockingQueue.poll(2,TimeUnit.SECONDS);
                if(data == null){
                    System.out.println("消费者超过2秒时间，没有获取队列信息");
                    FLAG = false;
                    return;
                }
                System.out.println("消费者获取到data:"+data);
            }
        }catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            System.out.println("消费者已经停止。。。");
        }
    }
}

public class Test0004 {
    public static void main(String[] args) {
        BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<String>(10);
        ProducerThread producerThread = new ProducerThread(blockingQueue);
        ConsumerThread consumeThread = new ConsumerThread(blockingQueue);
        Thread p1 = new Thread(producerThread);
        Thread c1 = new Thread(consumeThread);
        p1.start();
        c1.start();
        try {
            //等待10秒的时间
            Thread.sleep(1000*10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        producerThread.stop();
    }
}