JUC并发编程-02-CopyOnWriteArrayList、CopyOnWriteArraySet、ConcurrentHashMao、Callable

3、集合类不安全

List不安全

CopyOnWriteArrayList

package com.bjw.unsafe;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

//java.util.ConcurrentModificationException 并发修改异常！
public class ListTest {
    public static void main(String[] args) {
        //并发下ArrayList 不安全的
        /*
        * 解决方案:
        * 1、List<String> list = new Vector<>()
        * 2、List<String> list = Collections.synchronizedList(new ArrayList<>());
        * 3、List<String> list = new CopyOnWriteArrayList<>();
        * */
        //CopyOnWrite写入时复制 COW 计算机程序设计领域的一种优化策略
        //多个线程调用的时候， list，读取的问题，固定的，写入（覆盖）
        //在写入的时候避免覆盖，造成数据问题

        //读写分离 mycat
        //CopyOnWriteArrayList比Vector优势在哪里：   Vector的add方法底层用synchronized效率低，CopyOnWriteArrayList用的是lock锁（写入时复制）
        List<String> list = new CopyOnWriteArrayList<>();
        for (int i = 0; i <= 1000; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

Set不安全

package com.bjw.unsafe;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;

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

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

hashset的底层是什么

  public HashSet() {
  		map = new HashMap<>();
  }
  //add    set本质就是map      key是无法重复的
  public boolean add(E e) {
  		return map.put(e, PRESENT)==null;
  }
  private static final Object PRESENT = new Object(); //不变的值

Hashmap不安全

package com.bjw.unsafe;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

//ConcurrentModificationException
public class MapTest {
    public static void main(String[] args) {
        //map是这样用的吗？ 不是，工作中不用HashMao
        // 默认等价于什么？
        /* Map<String, String> map = new HashMap<>();*/


        Map<String, String> map = new ConcurrentHashMap<>();


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

4、Callable

1、可以有返回值
2、可以抛出异常
3、方法不同，run()/call()

package com.bjw.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        new Thread(new Thread()).start();

        new Thread().start(); //怎么启动callable
        MyThread thread = new MyThread();
        FutureTask futureTask = new FutureTask(thread);
        //适配类

        new Thread(futureTask, "A").start();
        Integer o = (Integer) futureTask.get(); // 获取callable的返回结果
        System.out.println(o);

    }
}

class MyThread implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("call()");
        return 1024;
    }
}

细节
1、有缓存
2、结果可能需要等待，会阻塞