jdk并发包源码笔记1(1.8)

java并发包说明--队列：

1、具体实现类：

    ArrayBlockingQueue               一个由数组结构组成的有界阻塞队列；
    ConcurrentLinkedQueue       
    DelayQueue                           一个使用优先级队列实现的无界阻塞队列；
    LinkedBlockingDeque            一个由链表结构组成的双向阻塞队列；
    LinkedBlockingQueue            一个由链表结构组成的有界阻塞队列；
    LinkedTransferQueue            一个由链表结构组成的无界阻塞队列；
    PriorityBlockingQueue            一个支持优先级排序的无界阻塞队列；
    SynchronousQueue               一个不存储元素的阻塞队列；

2、继承类

    全部继承自抽象类AbstractQueue，

    AbstractQueue说明，继承抽象类AbstractCollection，实现接口Queue：
          boolean add(E e)   将指定的元素插入到此队列中，如果可以立即执行此操作而不违反容量限制， 则在成功后返回 true，如果当前没有可用空间，则抛出IllegalStateException
          E remove()  检索并删除此队列的头
          E element()  检索，但不删除，这个队列的头
          void clear()  从此队列中删除所有元素
          boolean addAll(Collection c)  将指定集合中的所有元素添加到此队列中

  

   AbstractCollection说明，实现接口Collection：

         abstract   Iterator iterator()   返回包含在该集合中的元素的迭代器

         abstract int size()  返回此集合中的元素数

         boolean isEmpty()  如果此集合不包含元素，则返回 true

         boolean contains(Object o)  如果此集合包含指定的元素，则返回 true

         Object[] toArray()  返回包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型

         boolean add(E e) 确保此集合包含指定的元素（可选操作），直接抛异常

         boolean remove(Object o)   从该集合中删除指定元素的单个实例（如果存在）（可选操作）

         boolean containsAll(Collection c)  如果此集合包含指定 集合中的所有元素，则返回true

         boolean addAll(Collection c)  将指定集合中的所有元素添加到此集合（可选操作）

         boolean removeAll(Collection c)  删除指定集合中包含的所有此集合的元素（可选操作）

         boolean retainAll(Collection c)  仅保留此集合中包含在指定集合中的元素（可选操作）。

         void clear()  从此集合中删除所有元素（可选操作）

  

3、实现接口

     ArrayBlockingQueue，DelayQueue，LinkedBlockingDeque，LinkedBlockingQueue，PriorityBlockingQueue，SynchronousQueue实现接口BlockingQueue;

    ConcurrentLinkedQueue实现接口Queue;

    LinkedTransferQueue实现接口TransferQueue;

 

    BlockingQueue说明，继承接口Queue：

          boolean add(E e)  将指定的元素插入到此队列中，如果可以立即执行此操作而不违反容量限制， true在成功后返回 IllegalStateException如果当前没有可用空间，则抛出IllegalStateException

          boolean offer(E e) 将指定的元素插入到此队列中，如果可以立即执行此操作，而不会违反容量限制， true在成功时 false如果当前没有可用空间，则返回false

          void put(E e) throws InterruptedException 将指定的元素插入到此队列中，等待队列有空位可用

          boolean offer(E e, long timeout, TimeUnit unit)  throws InterruptedException  将指定的元素插入到此队列中，等待指定的等待时间（如有必要）才能使空间变得可用

          E take() throws InterruptedException  检索并删除此队列的头，如有必要，等待元素可用

          E poll(long timeout, TimeUnit unit)  throws InterruptedException 检索并删除此队列的头，等待指定的等待时间（如有必要）使元素变为可用

          int remainingCapacity()  返回该队列最好可以（在没有存储器或资源约束）接受而不会阻塞，或附加的元素的数量 Integer.MAX_VALUE如果没有固有的限制

          boolean remove(Object o)  从该队列中删除指定元素的单个实例（如果存在）

          public boolean contains(Object o) 如果此队列包含指定的元素，则返回 true

          int drainTo(Collection c)从该队列中删除所有可用的元素，并将它们添加到给定的集合中

          int drainTo(Collection c, int maxElements)  最多从该队列中删除给定数量的可用元素，并将它们添加到给定的集合中

 

    TransferQueue说明，继承接口BlockingQueue：

          boolean tryTransfer(E e)  如果可能的话，将元件立即转移给等待的消费者

          void transfer(E e) throws InterruptedException 将元素转移给消费者，如有必要，等待

          boolean tryTransfer(E e, long timeout, TimeUnit unit)   throws InterruptedException  如果可以在超时过程之前将元素传送给消费者

          boolean hasWaitingConsumer()  返回 true如果存在至少一个消费者等待经由以接收元件 BlockingQueue.take()或定时 poll

          int getWaitingConsumerCount()  返回通过 BlockingQueue.take()或定时器 poll等待接收元素的消费者数量的估计

    

     Queue说明，继承接口Collection：

          boolean add(E e)  将指定的元素插入到此队列中，如果可以立即执行此操作，而不会违反容量限制， true在成功后返回 IllegalStateException如果当前没有可用空间，则抛出IllegalStateException

          boolean offer(E e)  如果在不违反容量限制的情况下立即执行，则将指定的元素插入到此队列中

          E remove()  检索并删除此队列的头

          E poll()  检索并删除此队列的头，如果此队列为空，则返回 null

          E element()  检索，但不删除，这个队列的头

          E peek()  检索但不删除此队列的头，如果此队列为空，则返回 null

 

     Collection说明，继承接口Iterable：

          int size()  返回此集合中的元素数

          boolean isEmpty()  如果此集合不包含元素，则返回 true

          boolean contains(Object o)  如果此集合包含指定的元素，则返回 true

          Iterator iterator()  返回此集合中的元素的迭代器

          Object[] toArray()  返回一个包含此集合中所有元素的数组

          T[] toArray(T[] a)  返回包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型

          boolean add(E e)  确保此集合包含指定的元素（可选操作）

          boolean remove(Object o) 从该集合中删除指定元素的单个实例（如果存在）（可选操作）

          boolean containsAll(Collection c)  如果此集合包含指定 集合中的所有元素，则返回true

          boolean addAll(Collection c) 将指定集合中的所有元素添加到此集合（可选操作）

          boolean removeAll(Collection c) 删除指定集合中包含的所有此集合的元素（可选操作）

          default boolean removeIf(Predicate filter) 1.8新增(具体实现)  删除满足给定谓词的此集合的所有元素

          boolean retainAll(Collection c) 仅保留此集合中包含在指定集合中的元素（可选操作）

          void clear() 从此集合中删除所有元素（可选操作）

          boolean equals(Object o)  将指定的对象与此集合进行比较以获得相等性

          int hashCode()  返回此集合的哈希码值

          default Spliterator spliterator()   1.8新增(具体实现)  创建一个Spliterator在这个集合中的元素

          default Stream stream()  1.8新增(具体实现)  返回以此集合作为源的顺序 Stream

          default Stream parallelStream()  1.8新增(具体实现)  返回可能并行的 Stream与此集合作为其来源

 

   Iterable说明：

          Iterator iterator()  返回类型为 T元素的迭代器

          default void forEach(Consumer action)   1.8新增(具体实现)  对 Iterable的每个元素执行给定的操作，直到所有元素都被处理或动作引发异常

          default Spliterator spliterator()  1.8新增(具体实现)  在Iterable描述的元素上创建一个Iterable

 

4、详细介绍

     4.1   ArrayBlockingQueue采用对象数组Object[]保存元素，记录出队、下一个入队位置(takeIndex， putIndex)，当前队列有效元素个数count，对象锁ReentrantLock，以及非空、非满的Condition(notEmpty，notFull)

     构造方法：ArrayBlockingQueue(int capacity)       ArrayBlockingQueue(int capacity, boolean fair)

                     capacity队列容量，fair是否公平锁

                     ArrayBlockingQueue(int capacity, boolean fair, Collection c)  用指定的集合初始化队列，整个过程要加锁，保持队列的可见性，防止某个线程在初始化过程中，另一个线程操作队列引起数据不一致的问题

 

     方法： 凡是阻塞的入队、出队操作加锁方式’lock.lockInterruptibly()，非阻塞采用lock.lock()

　　　　  add(E e)    offer(E e)                  put(E e)     offer(E e, long timeout, TimeUnit unit)入队操作

 

                 add(E e)底层调用offer(E e)，如果队列满时，抛异常IllegalStateException

                 offer(E e)返回true/false

                 以上两种方法，队列正常加锁lock.lock()，如果队列满时，不会阻塞，立即返回；

 

                 put(E e)     offer(E e, long timeout, TimeUnit unit)  阻塞入队操作，如果队列满时，当前操作阻塞，两者用的都是可中断锁lock.lockInterruptibly()，可由当前线程自行中断，抛异常InterruptedException

 

                 E poll()    E take()    E poll(long timeout, TimeUnit unit) 出队操作，同时删除对首元素

                 E poll()不会阻塞，  E take()    E poll(long timeout, TimeUnit unit)会阻塞

 

　　 　　  E peek() 获取但不删除对首元素

　　　　   int size() 队列大小  

                 int remainingCapacity()  剩余可用队列大小

                 remove(Object o)  删除指定元素

                 boolean contains(Object o)  是否包含元素

                 Object[] toArray()  将队列转换成Object数组，底层采用System.arraycopy复制

                 T[] toArray(T[] a)   将队列转换成对象数组，底层采用System.arraycopy复制

                 clear() 清空队列

                 drainTo(Collection c)  拷贝队列到集合c，并清空队列

                 drainTo(Collection c, int maxElements)  拷贝队列指定个数的元素到集合c，并清除队列中该元素

                 Spliterator spliterator()  1.8新增

   

     4.2   LinkedBlockingQueue 内部属性包含队列容量(capacity)，当前队列有效元素个数count，队列头head，队列尾last，takeLock读锁，读锁对应的条件Condition(notEmpty)，putLock写锁，写锁对应的条件Condition(notFull)

             读和写分别由两把锁控制，两把锁分别管理head节点和last节点的操作，读和写可能同时修改count字段的值，所以count是原子类型

             int size()       int remainingCapacity()    返回的数据不准确

             重写了序列化方法，只把节点下的元素信息序列化，具体的链接关系没有序列化

 

     4.3   LinkedBlockingDeque 双向链表，单锁lock

 

     4.4   DelayQueue 延迟队列

           

                

                    

转载于:https://www.cnblogs.com/wrking/p/8530497.html