JUC-02

6、集合类不安全

List 不安全

package com.won.unsafe;

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

public class ListTest {
    public static void main(String[] args) {
        // 并发下，ArrayList 不安全
        /**
         * List<String> list = new ArrayList<>(); ==> java.util.ConcurrentModificationException 并发修改异常！
         * 解决方案：
         * 1、List<String> list = new Vector<>();
         * 2、List<String> list = Collections.synchronizedList(new ArrayList<>());
         * 3、List<String> list = new CopyOnWriteArrayList<>();
         */
        // CopyOnWrite 写入时复制 COW：计算机程序设计领域的一种优化策略
        // 多个线程调用的时候，list唯一，读取的时候是固定的。写入时存在（覆盖）
        // 在写入的时候避免覆盖，造成数据问题
        // 读写分离
        // CopyOnWriteArrayList 比 Vector 好在哪里？
        // CopyOnWriteArrayList 的 add 方法利用 ReentrantLock 实现
        // Vector 的 add 方法使用 synchronized 实现
        List<String> list = new CopyOnWriteArrayList<>();
        for (int i = 1; i <= 10; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

Set 不安全

package com.won.unsafe;

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

/**
 * 同理可证，并发条件下：Set<String> set = new HashSet<>(); ==> 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 = new HashSet<>();
        //Set<String> set = Collections.synchronizedSet(new HashSet<>());
        Set<String> set = new CopyOnWriteArraySet<>();
        for (int i = 1; i <= 10; 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(); // 不变的值

Map 不安全

回顾Map基本操作

package com.won.unsafe;

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

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

        for (int i = 1; i <= 30; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
        // 加载因子、初始化容量
    }
}

7、Callable（简单）

1、可以有返回值

2、可以抛出异常

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

代码测试

package com.won.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 Runnable()).start();
        // new Thread(new FutureTask<V>()).start();
        // new Thread(new FutureTask<V>(Callable)).start();
        MyThread thread = new MyThread();
        FutureTask futureTask = new FutureTask(thread); // 适配类
        new Thread(futureTask,"A").start(); // 怎么启动Callable
        new Thread(futureTask,"B").start(); // 结果会被缓存，效率高

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

class MyThread implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("call()"); // 会打印几个call？
        // 耗时的操作
        return 1024;
    }
}

细节：

1、有缓存

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

8、常用的辅助类（必会）

8.1 CountDownLatch

注释掉 countDownLatch.await() 时：

package com.won.add;

import java.util.concurrent.CountDownLatch;

// 计数器
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        // 总数是6
        CountDownLatch countDownLatch = new CountDownLatch(6);

        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+" Go Out");
                countDownLatch.countDown(); // 减1
            },String.valueOf(i)).start();
        }
        
        //countDownLatch.await(); // 等待计数器归零，然后再向下执行

        System.out.println("Close the door!");
    }
}

调用 countDownLatch.await() 时：

package com.won.add;

import java.util.concurrent.CountDownLatch;

// 计数器
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        // 总数是6，必须要执行任务的时候，再使用！
        CountDownLatch countDownLatch = new CountDownLatch(6);

        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+" Go Out");
                countDownLatch.countDown(); // 数量减1
            },String.valueOf(i)).start();
        }

        countDownLatch.await(); // 等待计数器归零，然后再向下执行

        System.out.println("Close the door!");

    }
}

原理：

countDownLatch.countDown(); // 数量减1

countDownLatch.await();// 等待计数器归零，然后再向下执行

每次有线程调用countDown()数量减1，假设计数器变为0，countDownLatch.await()就会被唤醒，继续执行！

8.2 CyclicBarrier

加法计数器

package com.won.add;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        /**
         * 集齐7颗龙珠召唤神龙
         */

        // 召唤龙珠的线程
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("召唤神龙成功！");
        });
        for (int i = 1; i <= 7; i++) {
            final int temp = i;
            // lambda能操作到 i 吗？
            new Thread(()->{
                System.out.println(Thread.currentThread().getName() + "收集" + temp + "个龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

8.3 Semaphore

Semaphore：一个计数信号量

抢车位！

6车 — 3个停车位置

package com.won.add;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreDemo {
    public static void main(String[] args) {
        // 线程数量：停车位！限流！
        Semaphore semaphore = new Semaphore(3);
        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                // acquire() 得到
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"抢到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release(); // release() 释放
                }
            },String.valueOf(i)).start();
        }
    }
}

原理：

semaphore.acquire(); 获得，假设已经满了，等待，等待被释放为止！

semaphore.release(); 释放，会将当前的信号量释放，然后唤醒等待的线程！

作用：多个共享资源互斥的使用！并发限流，控制最大的线程数！