线程安全集合

比眉伴天荒 2022-03-15 16:08 297阅读 0赞

jdk 5 引入并发包

# 概要 #

## 1. 线程安全的集合 ##

*  遗留的线程安全集合，如 Hashtable, Vector
 *  Collections 里的一系列以 synchronized 开头的方法，可以把非线程安全的集合包装成线程安全的集合
    
     *  体现了设计模式中的装饰器模式

List list = new ArrayList();
    // 装饰器模式
    List list1 = Collections.synchronizedList(list);

*  juc 下的线程安全集合
    
     *  CopyOnWrite 开头的集合，采用了“写入时拷贝”的思想来提高并发度
     *  Concurrent 支持并发（线程安全）的集合
     *  Blocking 支持阻塞操作

## 2. CopyOnWriteArrayList -> Vector ##

支持多线程并发读取 (get, 遍历) ，只支持单线程写入 (add, remove)

当有修改操作发生时，会对原有的数组进行拷贝，拷贝出一个新的数组，修改操作在新的数组上发生，修改加锁。

原有数组的查询操作不需要加锁保护，当修改线程执行完毕，再用新的数组替换原有数组。

把读写操作分离开，读不加锁，写加锁，用空间换取读不加锁

适合读多写少的场景

## 3. ConcurrentHashMap -> Hashtable ##

1.7 以前  
分段锁

*  首先是一个 segment的数组, 每个segment的元素又是一个 HashEntry 数组，Node数组中  
    又存放了链表
 *  锁定以 segment 为单位
 *  初始化时，会创建所有segment数组的元素，而且 segment数组不能扩容，占用内存多
 *  put 操作会锁住key 对应的 segment，元素放入 HashEntry 的数组+链表结构中，元素放入链表头
 *  get 操作无锁
 *  扩容会加锁
 *  计算个数

1.8 又做了修改  
Hashtable 是锁住了整个map集合，而 ConcurrentHashMap，它只会锁住map集合中的一个桶，根据桶的多少，可以进一步提高并发度，只要读写操作落在不同的桶里，操作就可以并行执行

*  初始化数组时，懒惰初始化
 *  当容量小于64首先尝试扩容，当超过这个容量并且链表大于8  
    会将链表树化，树化过程中会锁住链表头
 *  put 操作会锁住链表头，新加的元素放入链表尾部
 *  get 操作不需要加锁，仅需要用cas保证元素的可见性
 *  扩容 以链表为单位扩容，当扩容时有多个线程来同时访问，这些线程会协助扩容

## 4. ConcurrentSkipListMap ##

*  类似于之前 LinkedHashMap ，都可以保持元素遍历的顺序和放入的顺序是一致的。  
    LinkedHashMap 非线程安全  
    ConcurrentSkipListMap 线程安全

数据结构 跳跃表

## 5. BlockingQueue 阻塞队列 ##

队列, 先进先出 FIFO  
经常用来实现生产消费模式，来解耦生产者、消费者线程

BlockingQueue<Item> queue = new LinkedBlockingDeque<>(5);
    Thread t1 = new Thread(()-> { 
        try { 
            for (int i = 0; i < 6; i++) { 
                Item item = new Item("产品" + i);
                queue.put(item);
                System.out.println(Thread.currentThread().getName() + "生产了商品:" + item.name);
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) { 
            e.printStackTrace();
        }
    });
    Thread t2 = new Thread(()-> { 
        try{ 
            for (int i = 0; i < 0; i++) { 
                Item item = queue.take();
                System.out.println(Thread.currentThread().getName() + "消费了商品:" + item.name);
            }
        } catch (Exception e) { 
    
        }
    });

## 6. cas ##

*  cas 乐观锁(无锁并发)， 不断重试直到成功，体现的是乐观的精神
 *  synchronized 悲观锁 , 同一时刻，只能有一个线程访问 synchronized 代码块的内容

Object object = new Object();
    // 线程2 
    synchronized(object) { 
        // 代码片段1
        // 代码片段2
    }
    // 线程1

线程1 假定没有别的线程干扰, 就直接执行完这些代码  
但如果执行过程有其他线程干扰，之前结果作废，重试一遍，如果不成功继续重试直到成功

线程2   cpu
                代码片段1
                代码片段2

代码片段1 cpu  
代码片段2 cpu

compareAndSwap(旧值，新值) 当旧值被别的线程改变，就认为这次操作失败，就进行重试。如果旧值没有被别的线程改变就认为这次操作成功

应用场景：

*  原子操作类 例如 AtomicInteger,AtomicBoolean… 它们内部用的都是 cas 的无锁并发
 *  适用于并发量较小，多cpu情况

## 7. volatile ##

配合 cas 编程时，共享变量的声明上必须用 volatile 因为要读取主存中最新的结果

## Lock与Synchronzied ##

在 jdk 1.5 时引入了 ReentrantLock 使用了队列和cas的功能实现加锁解锁，性能上在当时是优于 synchronized 的  
在 jdk 1.6 对 synchronzied 底层代码做了优化, 引入了偏向锁，轻量级锁，重量级锁，并发低时性能其实 比 ReentrantLock 更好