JUC (java.util.concurrent)

1、什么是线程？什么是进程?

　　

2、多线程的状态？

 public enum State {
        //6种状态
        NEW,
        RUNNABLE, //可运行
        BLOCKED, //阻塞
        WAITING,  //等待：一直等待，不见不散
        TIMED_WAITING,//过期不候
        TERMINATED;
    }

3、并发？并行？※ ※ ※

　　并发：同一时间间隔，交替执行任务。

　　并行：同一时刻执行多个任务。

4、三个售票员卖票

　　（1） 线程　　操作　　资源类

　　（2）高内聚　　低耦合

　　代码在github上。

5、Lambda表达式

　　函数式为实现接口：接口中有一个为实现的函数。jdk8接口，新增了静态方法和默认方法。因为有一个抽象方法，所以调用哪个方法是确定的。

　　如何实现函数式接口：当只有一个抽象方法时，默认就是函数式接口。第二就是注解声明下，@FunctionalInterface

　　口诀：拷贝小括号，写死右箭头，落地大括号。

6、ArrayList是线程安全的吗？不是

　　并发修改会报错：java.util.ConcurrentModificationException

　　Vector是线程安全的吗？是的，但是使用的synchronized,效率低？为啥synchronized就效率低呢？

　　它是重量级锁，让线程排队一次执行，并发最差。

　　怎么让ArrayList安全呢？

List<String> list = Collections.synchronizedList(new ArrayList<>());
//但是不推荐，高并发不好

7、juc最终boss，企业高并发用这个

List list = new CopyOnWriteArrayList();//写时复制技术

高并发集合容器

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

        notSafeHashMap();
    }

    private static void notSafeHashMap() {
        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, 4));
                System.out.println(map);
            }, String.valueOf(i)).start();
        }
    }

    private static void notSafeHashSet() {

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

    private static void noSafeArrayList() {
        List list = new CopyOnWriteArrayList();//写时复制技术

        //并发写，会报错：java.util.ConcurrentModificationException
        for (int i = 0; i < 30; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0, 4));
                System.out.println(list);
            }, String.valueOf(i)).start();
        }
    }
}

　　底层原理：写时复制技术（写之前先复制一份，然后添加完，把引用指向写后的数组）

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();
    }
}