并发编程整理笔记04-集合类不安全

集合类不安全

List不安全

• 单线程

public static void main(String[] args) {
    List<String> list = Arrays.asList("1","2","3");
    // 函数式接口
    list.forEach(System.out::println);
}

• 多线程

public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
        new Thread(()->{
            list.add(UUID.randomUUID().toString().substring(1,5));
            System.out.println(list);
        },String.valueOf(i)).start();
    }
}

并发修改异常
java.util.ConcurrentModificationException

• 线程不安全的解决方案

1. Vector代替ArrayList（Vector是加同步关键字synchronized的ArrayList）
2. 利用Collections工具类将ArrayList变成线程安全
3. 利用JUC包下的读写时复制类,CopyOnWriteArrayList

public static void main(String[] args) {
    /* 解决方案：三种
    1. 利用Vector代替
     List<String> list = new Vector<>();
    2. 利用Collections下的工具类将ArrayList变成安全
    List<String> list = Collections.synchronizedList(new ArrayList<>());
    3.利用JUC下的写入时复制类 （推荐）
    List<String> list = new CopyOnWriteArrayList<>();
    * */
    //List<String> list = new Vector<>();
    //List<String> list = Collections.synchronizedList(new ArrayList<>());
    //List<String> list = new CopyOnWriteArrayList<>();
    List<String> list = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
        new Thread(()->{
            list.add(UUID.randomUUID().toString().substring(1,5));
            System.out.println(list);
        },String.valueOf(i)).start();
    }
}

• CopyOnWrite原理
  CopyOnWrite是 写入时复制，计算机程序设计领域的一种优化策略，
  当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。
  这样做的好处是我们可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。
  写数据的时候需要加锁，避免复制多个容器。

 /**
  * Appends the specified element to the end of this list.
  *
  * @param e element to be appended to this list
  * @return {@code true} (as specified by {@link Collection#add})
  */
 public boolean add(E e) {
     final ReentrantLock lock = this.lock;
     lock.lock();
     try {
         Object[] elements = getArray();
         int len = elements.length;
         Object[] newElements = Arrays.copyOf(elements, len + 1);
         newElements[len] = e;
         setArray(newElements);
         return true;
     } finally {
         lock.unlock();
     }

• CopyOnWrite 比Vector 好在哪？
  Vector是同步代码synchronized关键字实现的，效率很低
  copyonwrite读写分离的思想，读的时候不需要加锁，效率要高
• CopyOnWrite的缺点

1. 内存占用高，复制容器，内存中会同时存在两个容器，占用内存。可能会导致频繁的GC操作
2. 数据一致性问题，读的时候读取的是旧容器的数据，如果希望马上读到刚写入的数据，就不能使用COW

Set不安全

• 不安全

public class SetTest {
    public static void main(String[] args) {
        Set<String> sets = new HashSet<>();
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                sets.add(UUID.randomUUID().toString().substring(1,5));
                System.out.println(sets);
            },String.valueOf(i)).start();
        }
    }
}

• 同List解决方案的解决方案：
• java Set<String> sets = Collections.synchronizedSet(new HashSet<>());
• java Set<String> sets = new CopyOnWriteArraySet<>();

public class SetTest {
    public static void main(String[] args) {
        //Set<String> sets = new HashSet<>();
        //Set<String> sets = new CopyOnWriteArraySet<>();
        Set<String> sets = Collections.synchronizedSet(new HashSet<>());
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                sets.add(UUID.randomUUID().toString().substring(1,5));
                System.out.println(sets);
            },String.valueOf(i)).start();
        }
    }
}

• HashSet底层是HashMap

/**
 * Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
 * default initial capacity (16) and load factor (0.75).
 */
public HashSet() {
    map = new HashMap<>();
}
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}

Map不安全

public class MapTest {
    public static void main(String[] args) {

        Map<String,String> map = new HashMap<>();
        for (int i = 0; i < 30; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(1,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

• 解决方案
• java Map<String,String> map1 = new ConcurrentHashMap<>();
• java Map<String,String> map2 = Collections.synchronizedMap(new HashMap<>());
• juc

public class MapTest {
    public static void main(String[] args) {

        // 解决办法
        Map<String,String> map1 = new ConcurrentHashMap<>();
        Map<String,String> map2 = Collections.synchronizedMap(new HashMap<>());

        Map<String,String> map = new HashMap<>();
        for (int i = 0; i < 30; i++) {
            new Thread(()->{
                map1.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(1,5));
                System.out.println(map1);
            },String.valueOf(i)).start();
        }
    }
}