Java并发编程学习笔记2

5.八锁现象

判断锁的是谁
锁new的对象或类的Class对象
8锁就是关于锁的8个问题
参考博客：https://www.cnblogs.com/itiaotiao/p/12651573.html

6.集合类不安全

并发下ArrayList不安全
解决方案

1、List<String> list=new Vector<>();
2、List<String> list=new Collections.synchronizedList(new ArrayList<>())
3、List<String> list=new CopyOnWriteArrayList<>();

package jug;
import java.util.*;

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

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

package jug;

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

public class TestList {
    public static void main(String[] args) {
        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();
        }
    }
}

HashSet底层是HashMap

public HashSet() {
    map = new HashMap<>();
}

HashMap线程不安全，ConcurrentHashMap线程安全

package jug;

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

public class TestMap {
    public static void main(String[] args) {
        Map<String,String> map=new ConcurrentHashMap<>();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

7.Callable用法

package jug;

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

public class TestCallable {
    public static void main(String[] args) {
        try {
            Mythread mythread = new Mythread();
            FutureTask futureTask=new FutureTask(mythread);
            new Thread(futureTask).start();
            Integer i=(Integer) futureTask.get();//get方法可能产生阻塞
            System.out.println(i);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}
class Mythread implements Callable<Integer>{

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

有缓存，结果可能需要等待