NIO/Concurrent包/zookeeper/Avro-Concurrent（一）

1. 同步、异步、阻塞、非阻塞区别
   1. 同步：执行一个操作后，等待结果，然后才继续执行后续的操作
   2. 异步：执行一个操作后，可以去执行其它的操作，然后等待通知再回来执行刚才没执行玩的操作
   3. 阻塞：进程给CPU传达一个任务之后，一直等待CPU处理完成，然后才执行后面的操作
   4. 进程给CPU传达任务后，继续处理后续的操作，隔断时间再来询问之前的操作是否完成。这样的过程其实也叫轮询。
   5. 阻塞、非阻塞、多路IO复用，都是同步IO，异步必定是非阻塞的，所以不存在异步阻塞和异步非阻塞的说法。真正的异步IO需要CPU的深度参与。换句话说，只有用户线程在操作IO的时候根本不去考虑IO的执行全部都交给CPU去完成，而自己只等待一个完成信号的时候，才是真正的异步IO。所以，拉一个子线程去轮询、去死循环，或者使用select、poll、epool，都不是异步。

2. Concurrent包时JDK1.5提工的一个用域应对高并发的包主要包含：BlockingQueue、ConcurrentMap、ExecutorService、Lock、Atomic操作

3. BlockqingQueue阻塞式队列

   1. BlockqingQueue是阻塞式队列的顶级接口

   2. 不同以往的队列，BlockqingQueue一般是有界限的

   3. 在队列为空的时候进行获取操作会产生阻塞

   4. 在队列已满的情况下继续存储元素会产生阻塞

   5. 遵循先进先出（FIFO）的原则

   6. 适用于生产消费模型

   7. 重要方法

      	抛出异常	返回特殊值	阻塞	定时阻塞
      队列已满时，添加	add(o)	offer(o)	put(o)	offer(o, time, unit)
      队列为空时，获取	remove()	poll()	take()	poll(time, unit)

       

      8.ArrayBlockqingQueue-阻塞式顺序队列

      1. 在使用的时候需要指定容量/界限
      2. 底层基于数组来存储数据
      3. 容量在指定之后不能改动
      4. 遵循先进先出（FIFO）的原则

      9.LinkedBlockqingQueue-阻塞式链式队列

      1. 在使用的时候可以指定容量也可以不指定容量
      2. 如果不指定荣来给你，则荣来给你默认为interger.MAX_VALUE，此时认为容量是无限的
      3. 如果指定容量，则容量指定之后不可该百年
      4. 底层基于节点（链表）来存储数据
      5. 遵循先进先出（FIFO）的原则

      10.PriorityBlockqingQueue-阻塞式优先级队列

      1. 在使用的时候可以指定也可以不指定
      2. 如果不指定，则默认为11
      3. 如果指定容量则指定后不可改变
      4. 在指定容量的时候，最大不能超过Integer.MAX_VALUE-8
      5. PriorityBlockingQueue要求存储的元素对应的类必须实现Comparable接口，重写其中的compareTo方法来指定比较规则
      6. PriorityBlockingQueue在存储元素的时候会根据指定的比较规则对元素进行排序
      7. PriorityBlockingQueue在迭代的时候不保证元素的排序顺序

         示例
         public class PriorityBlockingQueueDemo {
          
             public static void main(String[] args) throws Exception {
          
                 // 创建队列
                 PriorityBlockingQueue<Student> queue = new PriorityBlockingQueue<>();
          
                 // 添加元素
                 queue.put(new Student("Amy", 16));
                 queue.put(new Student("Bob", 25));
                 queue.put(new Student("Cathy", 20));
                 queue.put(new Student("David", 13));
          
                 // 遍历队列
                 // 需要注意的是，如果想要拿到排序的结果，不能以迭代的方法获取
                 for (int i = 0; i < 4; i++) {
                     System.out.println(queue.take());
                 }
          
             }
          
         }
          
         class Student implements Comparable<Student> {
          
             private String name;
             private int age;
          
             public Student(String name, int age) {
                 super();
                 this.name = name;
                 this.age = age;
             }
          
             @Override
             public String toString() {
                 return "Student [name=" + name + ", age=" + age + "]";
             }
          
             // 在这个方法中指定比较规则
             // 根据学生的年龄进行升序排序
             @Override
             public int compareTo(Student o) {
                 return this.age - o.age;
             }
          
         }
         
         六、SynchronousQueue - 同步队列
         	1. 容量默认为1，并且只能为1，因此只能存储1个元素
         	2. 如果该队列已有一个元素，则试图向队列中新添一个新元素的线程将会阻塞，直到另一个线程将该元素从队列中抽走
         	3. 如果该队列为空，则试图从队列中抽取一个元素的线程将会阻塞，直到另一个线程向队列中添加了一个新的元素
         	4. 一般会将同步队列称之为是数据的汇合点
         
         七、BlockingDeque - 阻塞式双向队列
         	1. BlockingDeque继承了BlockingQueue
         	2. 在使用的时候，也是需要指定容量的
         	3. 该队列称之为双向队列，即队列的两端都可以添加元素，也可以从队列的两端获取元素