并发-并发容器

ArrayList并发遇到的问题

package com.yg.edu.list;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;


public class CopyOnWriteArrayListRunner {
    /**
     * 读线程
     *
     */
    private static class ReadTask implements Runnable {
        List<String> list;

        public ReadTask(List<String> list) {
            this.list = list;
        }

        public void run() {
            for (String str : list) {
                System.out.println(str);
            }
        }
    }
    /**
     * 写线程
     *
     */
    private static class WriteTask implements Runnable {
        List<String> list;
        int index;

        public WriteTask(List<String> list, int index) {
            this.list = list;
            this.index = index;
        }

        public void run() {
            list.remove(index);
            list.add(index, "write_" + index);
        }
    }

    public void run() {
        final int NUM = Runtime.getRuntime().availableProcessors();
        System.out.println(NUM);
//        List<String> list = new CopyOnWriteArrayList<>();//new ArrayList<String>();
        List<String> list = new ArrayList<>();//new ArrayList<String>();

        for (int i = 0; i < NUM; i++) {
            list.add("main_" + i);
        }
        ExecutorService executorService = Executors.newFixedThreadPool(NUM);
        for (int i = 0; i < NUM; i++) {
            executorService.execute(new ReadTask(list));
            executorService.execute(new WriteTask(list, i));
        }
        executorService.shutdown();
    }

    public static void main(String[] args) {
        new CopyOnWriteArrayListRunner().run();
    }
}

优化版本1 ：针对读写分别加ReentrantLock，存在粒度过大的问题 针对读写分别ReentrantLoc，存在粒度过大的问题
优化版本2 ：针对读写都比较多的场景，ReentrantReadWriteLock
优化版本3：针对读多写少的场景，CopyOnWriteArrayList

• CopyOnWrite机制

核心思想：读写分离，空间换时间，避免为保证并发安全导致的激烈的锁竞争。
划关键点：
1、CopyOnWrite适用于读多写少的情况，最大程度的提高读的效率；
2、CopyOnWrite是最终一致性，在写的过程中，原有的读的数据是不会发生更新的，只有新的读
才能读到最新数据；
3、如何使其他线程能够及时读到新的数据，需要使用volatile变量；
4、写的时候不能并发写，需要对写操作进行加锁；

• ConcurrentHashMap

HashMap数据结构

1.7-hashtable = 数组（基础） + 链表   单线程扩容的时候头插法会出现顺序反了的问题；多线程扩容导致形成的链表环---死锁问题。

（>=）1.8 = 数组 + 链表 + 红黑树

优先扩容；当链表长度达到一定长度时，转换为红黑树。

1.7 分段锁（ReentrantLock）+数组（基础） + 链表 

1.8  synchronized+CAS+HashEntry+红黑树,

---

常见问题

• jdk1.8为什么会抛弃分段锁，它有什么毛病吗?

在一个ConcurrentHashMap创建后Segment的个数是不能变的，扩容过程过改变的是每个Segment的大小。

分成很多段时会比较浪费内存空间(不连续，碎片化); 操作map时竞争同一个分段锁的概率非常小时，分段锁反而会造成更新等操作的长时间等待; 当某个段很大时，分段锁的性能会下降

• 知道红黑树的transfer过程么？简单的描述一下

参考链接：

​​​​​​JDK8的 CHM 为何放弃分段锁_普通网友的博客-CSDN博客_jdk8为什么不用分段锁了