04-集合类不安全&Callable

7.集合类不安全

list不安全

CopyOnWriteArrayList

package test02;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArrayList;

//java.util.ConcurrentModificationException 并发修改异常！
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 = 0; i <= 10; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

#copyonwrite写入时复制 cow计算机程序设计领域的一种优化策略,
#多个线程调用的时候,list 读取的时候,固定的,写入(覆盖)
#在写入的时侯避免覆盖，造成数据问题!
# 读写分离 mycat

copyonwriteArrayiist 比vector Nb在哪里？  看源码
比vector   用的 synchronized  效率较慢
copyonwriteArrayiist 用的lock

---

set不安全

CopyOnWriteArraySet

package test02;

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

/**
 * 同理可证 ：java.util.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 Obejct PRESENT =new  Object(); //不变的值

---

ConcurrentHashMap

Map不安全

package test02;

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

public class MapTest {
    public static void main(String[] args) {
        //map是这样用的嘛？ 不是 工作中不用hashmap
        //默认等价于 new HashMap<>(16,0.75);

        //java.util.ConcurrentModificationException
        // 1.Collections.synchronizedMap( new HashMap<>());
        // 2.Map<String, String> map = new ConcurrentHashMap<>();
        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);
            },String.valueOf(i)).start();
        }
    }
}

---

8.Callable

1.可以有返回值

2.可以抛出异常

3.方法不同 run() / call()

package test02;
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 Runnable()).start();
 //       new Thread(new futureTask<V>()).start();
//        new Thread(new futureTask<V>(Callable)).start();
        new Thread().start();//怎么启动Callable

        MyThread thread = new MyThread();
        FutureTask<Integer> futureTask = new FutureTask<>(thread);//适配类
        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start();//结果会被缓存 ，效率高 只打印一个call

        Integer o = (Integer)futureTask.get();//获取Callable的返回结果 
        //这个get方法可能会产生阻塞！ 把它放到最后 ，或者使用异步通信来处理！
        System.out.println(o);
    }
}
class MyThread implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println("Call");
        return 1;
    }

}

细节 ：

1.有缓存

2.结果可能需要等待，会阻塞！