Java多线程之并发包，并发队列

目录

1 并发包

1.1同步容器类

1.1.1Vector与ArrayList区别

1.1.2HasTable与HasMap

1.1.3 synchronizedMap

1.1.4 ConcurrentHashMap

1.1.5 CountDownLatch​​​​​​

1.1.6 CyclicBarrier

1.1.6 Semaphore

2 并发队列

2.1 ConcurrentLinkedQueue

2.2 BlockingQueue

2.3 ArrayBlockingQueue

2.4 LinkedBlockingQueue

2.5 PriorityBlockingQueue

2.6 SynchronousQueue

2.7 使用BlockingQueue模拟生产者与消费者

---

1 并发包

1.1同步容器类

1.1.1Vector与ArrayList区别

1.1.1.1 ArrayList是最常用的List实现类，内部是通过数组实现的，它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要增加存储能力，就要讲已经有数组的数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插入和删除。

1.1.1.2.Vector与ArrayList一样，也是通过数组实现的，不同的是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费，因此，访问它比访问ArrayList慢

注意: Vector线程安全、ArrayList

Vector源码类

Add方法源码类

 

    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

Arraylist源码

Add方法源码

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

1.1.2HasTable与HasMap

1.1.2.1 HashMap不是线程安全的 

HashMap是一个接口 是map接口的子接口，是将键映射到值的对象，其中键和值都是对象，并且不能包含重复键，但可以包含重复值。HashMap允许null key和null value，而hashtable不允许。

1.1.2.2 HashTable是线程安全的一个Collection。

1.1.2.3 HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，效率上可能高于Hashtable。
HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。
HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。

注意: HashTable线程安全，HashMap线程不安全。

1.1.3 synchronizedMap

 Collections.synchronized*(m) 将线程不安全额集合变为线程安全集合

1.1.4 ConcurrentHashMap

ConcurrentMap接口下有俩个重要的实现 :
ConcurrentHashMap
ConcurrentskipListMap (支持并发排序功能。弥补ConcurrentHas hMa p)
ConcurrentHashMap内部使用段(Segment)来表示这些不同的部分，每个段其实就是一个
小的HashTable,它们有自己的锁。只要多个修改操作发生在不同的段上，它们就可以并
发进行。把一个整体分成了16个段(Segment.也就是最高支持16个线程的并发修改操作。
这也是在重线程场景时减小锁的粒度从而降低锁竞争的一种方案。并且代码中大多共享变
量使用volatile关键字声明，目的是第一时间获取修改的内容，性能非常好。

1.1.5 CountDownLatch​​​​​​

 CountDownLatch类位于java.util.concurrent包下，利用它可以实现类似计数器的功能。比如有一个任务A，它要等待其他4个任务执行完毕之后才能执行，此时就可以利用CountDownLatch来实现这种功能

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(2);
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("我是子线程开始执行。。。。");
                try {
                    Thread.sleep(1000);//子线程处理事情
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                countDownLatch.countDown();//每次减一
                System.out.println("我是子线程执行结束。。。。");
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("我是子线程开始执行。。。。");
                try {
                    Thread.sleep(1000);//子线程处理事情
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                countDownLatch.countDown();
                System.out.println("我是子线程执行结束。。。。");
            }
        }).start();
        countDownLatch.await();//如果不为0，则一直等待
        System.out.println("主线程开始执行任务");
        for (int i = 0; i < 10; i++) {
            System.out.println("main: i="+i);
        }
    }
}

1.1.6 CyclicBarrier

CyclicBarrier初始化时规定一个数目，然后计算调用了CyclicBarrier.await()进入等待的线程数。当线程数达到了这个数目时，所有进入等待状态的线程被唤醒并继续。

CyclicBarrier就如同他的名字一样，可看成是一个障碍，所有的线程必须到齐后才能一起通过这个障碍。

CyclicBarrier初始时还可带一个Runnable的参数，该Runnable任务在CyclicBarrier的数目达到后，所有其他的线程被唤醒前被执行。 

class Writer extends Thread{
    CyclicBarrier cyclicBarrier;
    public Writer(CyclicBarrier cyclicBarrier){
        this.cyclicBarrier=cyclicBarrier;
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始写入数据.....");
        try {
            Thread.sleep(1000);//模拟耗时
            System.out.println(Thread.currentThread().getName()+"写入数据成功.....");
            cyclicBarrier.await();
            System.out.println(Thread.currentThread().getName()+"写入数据完毕.....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }
}
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(5);
        for (int i = 0; i < 5; i++) {
            new Writer(barrier).start();
        }
    }
}

输出：
Thread-0开始写入数据.....
Thread-1开始写入数据.....
Thread-2开始写入数据.....
Thread-3开始写入数据.....
Thread-4开始写入数据.....
Thread-0写入数据成功.....
Thread-1写入数据成功.....
Thread-2写入数据成功.....
Thread-4写入数据成功.....
Thread-3写入数据成功.....
Thread-3写入数据完毕.....
Thread-4写入数据完毕.....
Thread-2写入数据完毕.....
Thread-1写入数据完毕.....
Thread-0写入数据完毕.....
如果不加CyclicBarrier则：
Thread-0开始写入数据.....
Thread-1开始写入数据.....
Thread-2开始写入数据.....
Thread-3开始写入数据.....
Thread-4开始写入数据.....
Thread-0写入数据成功.....
Thread-0写入数据完毕.....
Thread-1写入数据成功.....
Thread-1写入数据完毕.....
Thread-2写入数据成功.....
Thread-2写入数据完毕.....
Thread-3写入数据成功.....
Thread-3写入数据完毕.....
Thread-4写入数据成功.....
Thread-4写入数据完毕.....

1.1.6 Semaphore

Semaphore是一种基于计数的信号量，它可以设定一个阈值，基于此，多个线程竞争获取许可信号，做自己的申请后归还，超过阈值后，线程申请许可信号将被阻塞。Semaphore可以用来构建一些对象池，资源池之类的，比如数据库连接池，我们也可以创建计数为1的Semaphore,将其作为一种类似互斥锁的机制，这也叫二元信号量，表示两种互斥状态。用法如下：

availablePermits函数用来获取当前可用的资源数量

wc.acquire();//申请资源

wc.release();//释放资源

案例:

需求: 一个厕所只有3个坑位，但是有10个人来上厕所，那怎么办？假设10的人的编号分别为1-10，并且1号先到厕所，10号最后到厕所。那么1-3号来的时候必然有可用坑位，顺利如厕，4号来的时候需要看看前面3人是否有人出来了，如果有人出来，进去，否则等待。同样的道理，4-10号也需要等待正在上厕所的人出来后才能进去，并且谁先进去这得看等待的人是否有素质，是否能遵守先来先上的规则。

class User extends Thread{
    Semaphore wc;
    String name;

    public User(Semaphore wc, String name) {
        this.wc = wc;
        this.name = name;
    }

    @Override
    public void run() {
        int availablePermits = wc.availablePermits();
        if(availablePermits>0){
            System.out.println(name+":天助我也，我有茅坑的哟");
        } else {
            System.out.println(name+":我靠，居然没有茅坑了");
        }
        try {
            wc.acquire();
            System.out.println(name+":终于能上厕所了，倍儿爽！！！！");
            Thread.sleep(new Random().nextInt(1000));
            System.out.println(name+":厕所上完了");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            wc.release();
        }
    }
}
public class SemaphoreDemo {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);//最多支持多少个线程
        for (int i = 1; i <= 10; i++) {
            new User(semaphore, i+"").start();
        }
    }
}

输出如下：
1:天助我也，我有茅坑的哟
1:终于能上厕所了，倍儿爽！！！！
2:天助我也，我有茅坑的哟
2:终于能上厕所了，倍儿爽！！！！
3:天助我也，我有茅坑的哟
3:终于能上厕所了，倍儿爽！！！！
4:我靠，居然没有茅坑了
5:我靠，居然没有茅坑了
6:我靠，居然没有茅坑了
7:我靠，居然没有茅坑了
8:我靠，居然没有茅坑了
9:我靠，居然没有茅坑了
10:我靠，居然没有茅坑了
1:厕所上完了
4:终于能上厕所了，倍儿爽！！！！
4:厕所上完了
5:终于能上厕所了，倍儿爽！！！！
2:厕所上完了
6:终于能上厕所了，倍儿爽！！！！
3:厕所上完了
7:终于能上厕所了，倍儿爽！！！！
7:厕所上完了
8:终于能上厕所了，倍儿爽！！！！
5:厕所上完了
9:终于能上厕所了，倍儿爽！！！！
6:厕所上完了
10:终于能上厕所了，倍儿爽！！！！
8:厕所上完了
10:厕所上完了
9:厕所上完了

2 并发队列

在并发队列上JDK提供了两套实现，一个是以ConcurrentLinkedQueue为代表的高性能队列，一个是以BlockingQueue接口为代表的阻塞队列，无论哪种都继承自Queue。

2.1 ConcurrentLinkedQueue

ConcurrentLinkedQueue:是一个适用于高并发场景下的队列，通过无所的方式，实现了高并发状态下的高性能，通常ConcurrentLinkedQueue性能好于BlockingQueue。他是一个基于连接节点的无界线程安全队列。该队列的线程遵循FIFO的原则，不允许null元素。

add 和offer() 都是加入元素的方法(在ConcurrentLinkedQueue中这俩个方法没有任何区别)
poll() 和peek() 都是取头元素节点，区别在于前者会删除元素，后者不会。

2.2 BlockingQueue

阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作是：

在队列为空时，获取元素的线程会等待队列变为非空。

当队列满时，写入（存储）元素的线程会等待队列可用。

在Java中，BlockingQueue的接口位于java.util.concurrent 包中(在Java5版本开始提供)，由上面介绍的阻塞队列的特性可知，阻塞队列是线程安全的。

在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了BlockingQueue家庭中的所有成员，包括他们各自的功能以及常见使用场景。

常用的队列主要有以下两种：（当然通过不同的实现方式，还可以延伸出很多不同类型的队列，DelayQueue就是其中的一种）

　　先进先出（FIFO）：先插入的队列的元素也最先出队列，类似于排队的功能。从某种程度上来说这种队列也体现了一种公平性。

　　后进先出（LIFO）：后插入队列的元素最先出队列，这种队列优先处理最近发生的事件。

      多线程环境中，通过队列可以很容易实现数据共享，比如经典的“生产者”和“消费者”模型中，通过队列可以很便利地实现两者之间的数据共享。假设我们有若干生产者线程，另外又有若干个消费者线程。如果生产者线程需要把准备好的数据共享给消费者线程，利用队列的方式来传递数据，就可以很方便地解决他们之间的数据共享问题。但如果生产者和消费者在某个时间段内，万一发生数据处理速度不匹配的情况呢？理想情况下，如果生产者产出数据的速度大于消费者消费的速度，并且当生产出来的数据累积到一定程度的时候，那么生产者必须暂停等待一下（阻塞生产者线程），以便等待消费者线程把累积的数据处理完毕，反之亦然。然而，在concurrent包发布以前，在多线程环境下，我们每个程序员都必须去自己控制这些细节，尤其还要兼顾效率和线程安全，而这会给我们的程序带来不小的复杂度。好在此时，强大的concurrent包横空出世了，而他也给我们带来了强大的BlockingQueue。（在多线程领域：所谓阻塞，在某些情况下会挂起线程（即阻塞），一旦条件满足，被挂起的线程又会自动被唤醒）

2.3 ArrayBlockingQueue

ArrayBlockingQueue是一个有边界的阻塞队列，它的内部实现是一个数组。有边界的意思是它的容量是有限的，我们必须在其初始化的时候指定它的容量大小，容量大小一旦指定就不可改变。

ArrayBlockingQueue是以先进先出的方式存储数据，最新插入的对象是尾部，最新移出的对象是头部。下面是一个初始化和使用ArrayBlockingQueue的例子：

     ArrayBlockingQueue<String> arrays = new ArrayBlockingQueue<String>(3);

     arrays.add("李四");

      arrays.add("张军");

     arrays.add("张军");

     // 添加阻塞队列

     arrays.offer("张三", 1, TimeUnit.SECONDS);

2.4 LinkedBlockingQueue

LinkedBlockingQueue阻塞队列大小的配置是可选的，如果我们初始化时指定一个大小，它就是有边界的，如果不指定，它就是无边界的。说是无边界，其实是采用了默认大小为Integer.MAX_VALUE的容量 。它的内部实现是一个链表。

和ArrayBlockingQueue一样，LinkedBlockingQueue 也是以先进先出的方式存储数据，最新插入的对象是尾部，最新移出的对象是头部。下面是一个初始化和使LinkedBlockingQueue的例子：

LinkedBlockingQueue linkedBlockingQueue = new LinkedBlockingQueue(3);

linkedBlockingQueue.add("张三");

linkedBlockingQueue.add("李四");

linkedBlockingQueue.add("李四");

System.out.println(linkedBlockingQueue.size());

2.5 PriorityBlockingQueue

PriorityBlockingQueue是一个没有边界的队列，它的排序规则和 java.util.PriorityQueue一样。需要注意，PriorityBlockingQueue中允许插入null对象。

所有插入PriorityBlockingQueue的对象必须实现 java.lang.Comparable接口，队列优先级的排序规则就是按照我们对这个接口的实现来定义的。

另外，我们可以从PriorityBlockingQueue获得一个迭代器Iterator，但这个迭代器并不保证按照优先级顺序进行迭代。

2.6 SynchronousQueue

SynchronousQueue队列内部仅允许容纳一个元素。当一个线程插入一个元素后会被阻塞，除非这个元素被另一个线程消费。

 

2.7 使用BlockingQueue模拟生产者与消费者

class ProducerThread extends Thread{
    private BlockingQueue queue;
    private volatile boolean flag=true;
    private static AtomicInteger count=new AtomicInteger();

    public ProducerThread(BlockingQueue queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        System.out.println("生产者线程启动。。。。。。。");
        try{
            while (flag){
                System.out.println("生产者正在生产队列");
                String data=count.incrementAndGet()+"";
                //添加队列
                boolean offer=queue.offer(data);
                if(offer){
                    System.out.println("生产者添加队列"+data+"成功！");
                } else{
                    System.out.println("生产者添加队列"+data+"失败！");
                }
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println("生产者线程停止。。。。。。。。");
        }
    }
    public void stopThread(){
        this.flag=false;
    }
}

class ConsumerThread extends Thread{
    private BlockingQueue queue;
    private volatile boolean flag=true;
    private static AtomicInteger count=new AtomicInteger();

    public ConsumerThread(BlockingQueue queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        System.out.println("消费者线程启动。。。。。。。");
        try{
            while (flag){
                //获取完毕后，队列会删除头元素
                String data = (String) queue.poll(2, TimeUnit.SECONDS);
                if(data!=null){
                    System.out.println("消费者获取data："+data+"成功！");
                } else{
                    System.out.println("消费者获取data失败！");
                    this.flag=false;
                }
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println("消费者线程停止。。。。。。。。");
        }
    }
    public void stopThread(){
        this.flag=false;
    }
}
public class ProConDemo {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> queue=new LinkedBlockingQueue<>(10);
        ProducerThread p1=new ProducerThread(queue);
        ProducerThread p2=new ProducerThread(queue);

        ConsumerThread c1=new ConsumerThread(queue);
//        ConsumerThread c2=new ConsumerThread(queue);
        p1.start();
        p2.start();
        c1.start();
        Thread.sleep(10*1000);
        p1.stopThread();
        p2.stopThread();
    }

}


生产者线程启动。。。。。。。
生产者正在生产队列
生产者添加队列1成功！
生产者线程启动。。。。。。。
生产者正在生产队列
生产者添加队列2成功！
消费者线程启动。。。。。。。
消费者获取data：1成功！
生产者正在生产队列
生产者添加队列3成功！
生产者正在生产队列
生产者添加队列4成功！
消费者获取data：2成功！
生产者正在生产队列
生产者添加队列5成功！
生产者正在生产队列
生产者添加队列6成功！
消费者获取data：3成功！
生产者正在生产队列
生产者添加队列7成功！
生产者正在生产队列
生产者添加队列8成功！
消费者获取data：4成功！
生产者正在生产队列
生产者添加队列9成功！
生产者正在生产队列
生产者添加队列10成功！
消费者获取data：5成功！
生产者正在生产队列
生产者添加队列11成功！
生产者正在生产队列
生产者添加队列12成功！
消费者获取data：6成功！
生产者正在生产队列
生产者添加队列13成功！
生产者正在生产队列
生产者添加队列14成功！
消费者获取data：7成功！
生产者正在生产队列
生产者添加队列15成功！
生产者正在生产队列
生产者添加队列16成功！
消费者获取data：8成功！
生产者正在生产队列
生产者添加队列17成功！
生产者正在生产队列
生产者添加队列18成功！
消费者获取data：9成功！
生产者正在生产队列
生产者添加队列19成功！
生产者正在生产队列
生产者添加队列20失败！
消费者获取data：10成功！
生产者线程停止。。。。。。。。
生产者线程停止。。。。。。。。
消费者获取data：11成功！
消费者获取data：12成功！
消费者获取data：13成功！
消费者获取data：14成功！
消费者获取data：15成功！
消费者获取data：16成功！
消费者获取data：17成功！
消费者获取data：18成功！
消费者获取data：19成功！
消费者获取data失败！
消费者线程停止。。。。。。。。