Concurrent

jdk1.5提供的一个针对高并发进行编程的包

阻塞式队列 - BlockingQueue
遵循先进先出（FIFO）原则。阻塞式队列本身使用的时候是需要指定界限。

ArrayBlockingQueue - 阻塞式顺序队列 - 底层基于数组来进行存储，使用的时候需要指定一个容量，容量指定后不可改变 ----常用于生产-消费模型

    // 这个队列在创建的时候需要指定容量,容量在指定之后不可变
        ArrayBlockingQueue queue = new ArrayBlockingQueue<>(5);

        // 添加队列
        queue.add("a");
        queue.add("b");
        queue.add("c");
        queue.add("d");
        queue.add("e");

        // 如果队列已满,则抛出异常 - IllegalStateException
        // queue.add("a");
        // 返回值标记元素是否成功添加到队列里面
        // 如果队列已满,则返回false
        // boolean b = queue.offer("b");
        // System.out.println(b);
        // 如果队列已满,会产生阻塞 --- 直到这个队列中有元素被取出,才会放开阻塞
        // queue.put("c");

        // 定时阻塞
        // 在3s之内如果有元素被取出,那么元素就会添加到队列中
        // 如果3s之后队列依然是满的,那么返回false表示添加失败
        boolean b = queue.offer("d", 3000, TimeUnit.MILLISECONDS);
        System.out.println(b);
        System.out.println(queue);
                ArrayBlockingQueue queue2 = new ArrayBlockingQueue<>(5);

        // 队列为空,抛出异常:NoSuchElementException
        // String str = queue2.remove();
        // 队列为空,返回null
        // String str = queue2.poll();
        // 队列为空,产生阻塞 - 直到有其他线程向队列中添加元素,才会放开阻塞
        // String str = queue2.take();
        // 定时阻塞
        String str = queue2.poll(3, TimeUnit.SECONDS);
        System.out.println(str);

LinkedBlockingQueue - 阻塞式链式队列 - 底层基于链表（节点来进行数据的存储），在使用时可以指定初始容量，也可以不指定，如果指定了容量，就以指定的容量为准进行存储，如果不指定容量，那么默认容量是Integer.MAX_VALUE=2^31-1，如果不指定容量，一般认为这个容量是无限的。

PriorityBlockingQueue - 具有优先级的阻塞式队列 - 如果不指定容量默认容量为11 。如果将元素一一取出（只限普通for循环），那么会对元素进行自然排序--要求存储的对象所对应得类必须实现Comparable,重写ComparaTo方法指定排序规则

//  @Override
//  // 指定比较规则
//  // 如果返回值>0,那么this就要排到o的后边
//  // 如果返回值<0,那么this就要排到o的前边
//  public int compareTo(Student o) {
//      return this.age - o.age;
//  }

    @Override
    public int compareTo(Student o) {
        return o.score - this.score;
    }

SynchronousQueue - 同步队列 - 只允许存储一个元素

并发映射 - ConcurrentMap

HashMap - 底层依靠数组加链表的形式存储，默认初始容量16，默认加载因子为0.75f、每次扩容增加一倍，本身是一个异步式线程不安全的映射

Hashtable - 同步式线程安全映射 -- 对外提供的都是同步方法。

ConcurrentHashMap - 异步式线程安全的映射 - 在jdk1.8之前，采用分段（分桶）锁，分段锁采用的是读写锁的机制（读锁：允许多个线程读，但是不允许线程写；写锁，允许一个线程写，但是不允许线程读）
jdk1.8不再采用锁机制，而是CAS(Compate and Swap)算法，减小了锁的开销；
如果一个桶中的元素个数超过了8个，哪个会将这个桶的链表扭转成一颗红黑树（自平衡二叉树的结构）