Java基础集合（二）

目录：

1. Java Collection架构图
2. Queue实现详解
3. Queue实现生产者消费者

1. Java Collection架构图

2. Queue实现详解

• ArrayBlockingQeue：基于数据数据结构的有界队列，FIFO先进先出模式
• LinkedBlockingQueue：基于链表数据结构的无界队列，FIFO先进先出模式，吞吐量要优于ArrayBlockingQueue。
• PriorityBlockingQueue：具有优先级的无界队列（有一个比较器，根据排序规则来比较哪个元素可以优先出列），内部机制为PriorityQueue，只是加了阻塞。
• SynchronousQueue：一个不存储元素的阻塞队列，每插入一个元素必须等到另外一个线程把当前的元素移除才能再次插入元素。通过Transfer实现。

3.Queue实现生产者消费者

package com.jh.collection;

import java.util.Random;
import java.util.TreeSet;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * @program:
 * @description:
 * @author: lishijia
 * @create: 2019-07-12 14:44
 **/
public class CollectionTest {

    public static void main(String args[]) throws InterruptedException {
        testTreeSet();
        testQueue();
    }

    private static void testQueue() throws InterruptedException {
        BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<String>();
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        executorService.submit(new ProduceApple(blockingQueue));
        executorService.submit(new EatApple(blockingQueue));
    }

    static class ProduceApple implements Runnable {
        BlockingQueue<String> blockingQueue;

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

        @Override
        public void run() {
            while (true) {
                Random random = new Random();
                int randomInt = random.nextInt(10);
                String appleName = "apple" + randomInt;
                System.out.println("生产苹果 " + appleName);
                blockingQueue.add(appleName);
                try {
                    Thread.sleep(randomInt * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    static class EatApple implements Runnable {
        BlockingQueue<String> blockingQueue;

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

        @Override
        public void run() {
            while (true) {
                try {
                    String appleName = blockingQueue.take();
                    System.out.println("吃苹果 ：= " + appleName);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void testTreeSet() {
        TreeSet<Integer> treeSet = new TreeSet<Integer>();
        treeSet.add(5);
        treeSet.add(1);
        treeSet.add(3);
        System.out.println(treeSet.first());
        System.out.println(treeSet.last());
    }


}