深入了解JUC并发（六）并发容器

并发容器

List

ArrayList进行多线程操作：导致 ConcurrentModificationException 并发修改异常！

ArrayList 在并发情况下是不安全的

//java.util.ConcurrentModificationException 并发修改异常！
public class ListTest {
    public static void main(String[] args) {

        List<Object> arrayList = new ArrayList<>();

        for(int i=1;i<=10;i++){
            new Thread(()->{
                arrayList.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(arrayList);
            },String.valueOf(i)).start();
        }

    }
}

解决方案：

• new Vector<>();
• Collections.synchronizedList(new ArrayList<>());
• new CopyOnWriteArrayList<>();

public class ListTest {
    public static void main(String[] args) {
        /**
         * 解决方案
         * 1. List<String> list = new Vector<>();
         * 2. List<String> list = Collections.synchronizedList(new ArrayList<>());
         * 3. List<String> list = new CopyOnWriteArrayList<>();
         */
        List<String> list = new CopyOnWriteArrayList<>();
        

        for (int i = 1; i <=10; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

CopyOnWriteArrayList

1. 写入时复制（COW 计算机程序设计领域的一种优化策略）
2. 在写入的时候避免覆盖，造成数据错乱的问题

CopyOnWriteArrayList对比Vector

• Vector底层是使用synchronized关键字来实现的：效率特别低下。
• CopyOnWriteArrayList使用的是Lock锁，效率会更加高效！

Set

HashSet进行多线程操作：导致 ConcurrentModificationException 并发修改异常！

解决方案两种：

• Collections.synchronizedSet(new HashSet<>());
• new CopyOnWriteArraySet<>();

public class SetTest {
    public static void main(String[] args) {
        /**
         * 1. Set<String> set = Collections.synchronizedSet(new HashSet<>());
         * 2. Set<String> set = new CopyOnWriteArraySet<>();
         */
//        Set<String> set = new HashSet<>();
        Set<String> set = new CopyOnWriteArraySet<>();

        for (int i = 1; i <= 30; i++) {
            new Thread(() -> {
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            },String.valueOf(i)).start();
        }
    }
}

HashSet底层

hashSet底层就是一个HashMap

Map

HashMap进行多线程操作：导致 java.util.ConcurrentModificationException 并发修改异常！

//map 是这样用的吗？  不是，工作中不使用这个
//默认等价什么？ new HashMap<>(16,0.75);
Map<String, String> map = new HashMap<>();
//加载因子、初始化容量

默认加载因子是0.75,默认的初始容量是16

解决：

• Collections.synchronizedMap(new HashMap<>());
• new ConcurrentHashMap<>();

public class MapTest {
    public static void main(String[] args) {
        //map 是这样用的吗？  不是，工作中不使用这个
        //默认等价什么？ new HashMap<>(16,0.75);
        /**
         * 解决方案
         * 1. Map<String, String> map = Collections.synchronizedMap(new HashMap<>());
         *  Map<String, String> map = new ConcurrentHashMap<>();
         */
        Map<String, String> map = new ConcurrentHashMap<>();
        //加载因子、初始化容量
        for (int i = 1; i < 100; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

浅谈HashTable

java.util包中提供了线程安全的HashTable，但这家伙只是通过简单的同步来实现线程安全，因此效率低。只要有一条线程获取了容器的锁之后，其他所有的线程访问同步函数都会被阻塞。

队列

队列是Collection的一个子类

常用队列

阻塞原理

BlockingQueue

概念

它是一个队列，在进行检索或移除一个元素的时候，它会等待队列变为非空；当在添加一个元素时，它会等待队列中的可用空间。BlockingQueue接口是Java集合框架的一部分，主要用于实现生产者-消费者模式。我们不需要担心等待生产者有可用的空间，或消费者有可用的对象，因为它都在BlockingQueue的实现类中被处理了。

ArrayBlockingQueue

数组实现的线程安全的有限的阻塞队列

方式	抛出异常	不会抛出异常，有返回值	阻塞，等待	超时等待
添加	add	offer	put	offer(timenum.timeUnit)
移出	remove	poll	take	poll(timenum,timeUnit)
判断队首元素	element	peek	-	-

	/**
     * 抛出异常
     */
    public static void test1(){
        //需要初始化队列的大小
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

        System.out.println(blockingQueue.add("a"));//输出true
        System.out.println(blockingQueue.add("b"));//输出true
        System.out.println(blockingQueue.add("c"));//输出true
        System.out.println(blockingQueue.add("d"));//抛出异常java.lang.IllegalStateException：队列已满
        
        System.out.println(blockingQueue.remove());//输出a
        System.out.println(blockingQueue.element());//输出b
        System.out.println(blockingQueue.remove());//输出b
        System.out.println(blockingQueue.remove());//输出c
        System.out.println(blockingQueue.remove());//如果多移除一个,这也会造成java.util.NoSuchElementException：没有元素异常
    }

	/**
     * 不抛出异常，有返回值
     */
    public static void test2(){
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
        System.out.println(blockingQueue.offer("a"));//输出true
        System.out.println(blockingQueue.offer("b"));//输出true
        System.out.println(blockingQueue.offer("c"));//输出true
        System.out.println(blockingQueue.offer("d"));//会返回false 不会抛出异常
    
        System.out.println(blockingQueue.poll());//输出a
        System.out.println(blockingQueue.peek());//输出b
        System.out.println(blockingQueue.poll());//输出b
        System.out.println(blockingQueue.poll());//输出c
        System.out.println(blockingQueue.poll());//会返回null 不会抛出异常
    }

	/**
     * 等待 一直阻塞
     */
    public static void test3() throws InterruptedException {
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

        //一直阻塞 不会返回值
        blockingQueue.put("a");
        blockingQueue.put("b");
        blockingQueue.put("c");
        //队列已经满了，再进去一个元素，会一直等待这个队列，什么时候有了位置再进去，程序不会停止
        blockingQueue.put("d");

        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        //这种情况也会等待阻塞，程序会一直运行
        System.out.println(blockingQueue.take());
    }

	/**
     *  等待 超时阻塞
     *  这种情况也会等待队列有位置 或者有产品 但是会超时结束
     */
    public static void test4() throws InterruptedException {
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
        blockingQueue.offer("a");
        blockingQueue.offer("b");
        blockingQueue.offer("c");
        
        System.out.println("开始等待");
        blockingQueue.offer("d",2, TimeUnit.SECONDS);//超时时间2s 等待如果超过2s就结束等待
        System.out.println("结束等待");
        
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        
        System.out.println("开始等待");
        blockingQueue.poll(2,TimeUnit.SECONDS); //超过两秒 我们就不要等待了
        System.out.println("结束等待");
    }

LinkedBlockingQueue

单链表实现的线程安全的无限的阻塞队列

• LinkedBlockingQueue继承自AbstractQueue，实现了BlockingQueue接口
• LinkedBlockingQueue由单链表实现，因此是个无限队列。但为了方式无限膨胀，构造时可以加上容量加以限制
• LinkedBlockingQueue分别采用读取锁和插入锁控制读取/删除 和 插入过程的并发访问，并采用notEmpty和notFull两个Condition实现队满队空的阻塞与唤醒

SynchronousQueue

没有容量的同步队列

• put了一个元素，就必须从里面先take出来，否则不能再put进去值
• api：put方法 和 take方法

package com.marchsoft.queue;

import java.util.concurrent.BlockingDeque;
import java.util.concurrent.BlockingQueue;

/**
 * Description：
 *
 * @author jiaoqianjin
 * Date: 2020/8/12 10:02
 **/

public class SynchronousQueue {
    public static void main(String[] args) {
        BlockingQueue<String> synchronousQueue = new java.util.concurrent.SynchronousQueue<>();
        // 网queue中添加元素
        new Thread(() -> {
            try {
                System.out.println(Thread.currentThread().getName() + "put 01");
                synchronousQueue.put("1");
                System.out.println(Thread.currentThread().getName() + "put 02");
                synchronousQueue.put("2");
                System.out.println(Thread.currentThread().getName() + "put 03");
                synchronousQueue.put("3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        // 取出元素
        new Thread(()-> {
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + "take" + synchronousQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + "take" + synchronousQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + "take" + synchronousQueue.take());
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

关于使用选择

数组

不需要并发

• HashMap：一般就用这个
• TreeMap：需要排序时，使用这个
• LinkedhashMap：有序的Map

并发不是很大时

• Hashtable：早期的线程安全Map。速度较慢，高并发下不推荐使用
• Collections.sychronizedXxx：将不安全的容器包装成安全的容器后返回，返回的容器则为安全的容器

高并发时

• ConcurrentHashMap：线程安全Map，用来替代HashMap。采用粒度更细的加锁机制：分段锁，因此高并发下可以实现更高的吞吐量，单线程下也只会损失很小的性能
• ConcurrentSkipListMap ：线程安全Map，且为有序的Map，用于替代SortedMap，支持高并发。Set只需将Map换为Set即可

队列

不需要并发

• ArrayList：最常用
• LinkedList：支持队列操作

并发不是很大时

• vector：早期的线程安全容器，速度较慢，高并发下不推荐使用。
• Collections.sychronizedXxx：将不安全的容器包装成安全的容器后返回，返回的容器则为安全的容器。

高并发时

• CopyOnWriteList：避免了高并发下的脏读现象，写入速度贼慢，读取速度快，因此适用于读多写少的情况
• Queue（没啥特殊的，就是支持高并发而已）：
  • CocurrentLinkedQueue
  • BlockingQueue：阻塞队列
    • ArrayBlockingQueue：有界的阻塞队列
    • LinkedBlockingQueue：无界的阻塞队列