目录

一、JUC(java.util.concurrent) 的常见类

1.1 信号量 Semaphore

1.2 CountDownLatch

1.3 CyclicBarrier -循环栅栏

二、线程安全的集合类

 2.1 多线程环境使用 ArrayList

2.2 多线程环境使用队列

2.3 多线程环境使用哈希表

 三、死锁

3.1 死锁是什么

3.2 如何避免死锁

3.3 避免死锁的解决方案

四、ThreadLocal

一、JUC(java.util.concurrent) 的常见类

1.1 信号量 Semaphore

理解信号量

可以把信号量想象成是停车场的展示牌 : 当前有车位 100 个 . 表示有 100 个可用资源 .

当有车开进去的时候 , 就相当于申请一个可用资源 , 可用车位就 -1 ( 这个称为信号量的 P 操作 )

当有车开出来的时候 , 就相当于释放一个可用资源 , 可用车位就 +1 ( 这个称为信号量的 V 操作 )

如果计数器的值已经为 0 了 , 还尝试申请资源 , 就会阻塞等待 , 直到有其他线程释放资源 .

Semaphore semaphore = new Semaphore(4);
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        try {
            System.out.println("申请资源");
            semaphore.acquire();
            System.out.println("我获取到资源了");
            Thread.sleep(1000);
            System.out.println("我释放资源了");
            semaphore.release();
       } catch (InterruptedException e) {
            e.printStackTrace();
       }
   }
};
for (int i = 0; i < 20; i++) {
    Thread t = new Thread(runnable);
    t.start();
}

 CountDownLatch的作用，是可以设置所有的线程必须都到达某一个关键点然后再执行后续的操作

 应用场景：把一个大任务分成若干个小任务，或是等待一些前置资源时，可以考虑使用CountDownLatch

1.3 CyclicBarrier -循环栅栏

CountDownLatch的升级版，可以实现线程间的相互等待，计数重置

二、线程安全的集合类

 2.1 多线程环境使用 ArrayList

 实现方式是在普通集合对象外层又包裹了一层synchronized完成的线程安全，也不推荐

2.2 多线程环境使用队列

2.3 多线程环境使用哈希表

• Hashtable
• ConcurrentHashMap

• 如果多线程访问同一个 Hashtable 就会直接造成锁冲突.
• size 属性也是通过 synchronized 来控制同步, 也是比较慢的.
• 一旦触发扩容, 就由该线程完成整个扩容过程. 这个过程会涉及到大量的元素拷贝, 效率会非常低.

• 读操作没有加锁(但是使用了 volatile 保证从内存读取结果), 只对写操作进行加锁. 加锁的方式仍然是用 synchronized, 但是不是锁整个对象, 而是 "锁桶" (用每个链表的头结点作为锁对象), 大大降低了锁冲突的概率.
• 充分利用 CAS 特性. 比如 size 属性通过 CAS 来更新. 避免出现重量级锁的情况.  
• 优化了扩容方式: 化整为零 发现需要扩容的线程, 只需要创建一个新的数组, 同时只搬几个元素过去. 扩容期间, 新老数组同时存在. 后续每个来操作 ConcurrentHashMap 的线程, 都会参与搬家的过程. 每个操作负责搬运一小部分元素.搬完最后一个元素再把老数组删掉. 这个期间, 插入只往新数组加. 这个期间, 查找需要同时查新数组和老数组
• 典型的以空间换时间的用例
• 

三、死锁

3.1 死锁是什么

有个桌子 , 围着一圈 哲 ♂ 家 , 桌子中间放着一盘意大利面 . 每个哲学家两两之间 , 放着一根筷子. 每个 哲 ♂ 家 只做两件事 : 思考人生 或者 吃面条 . 思考人生的时候就会放下筷子 . 吃面条就会拿起左 右两边的筷子 ( 先拿起左边 , 再拿起右边 ).

如果 哲 ♂ 家 发现筷子拿不起来了 ( 被别人占用了 ), 就会阻塞等待.

[关键点在这] 假设同一时刻 , 五个 哲 ♂ 家 同时拿起左手边的筷子 , 然后再尝试拿右手的筷子 , 就会 发现右手的筷子都被占用了. 由于 哲 ♂ 家 们互不相让 , 这个时候就形成了 死锁

 3.2 如何避免死锁

• 互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用
• 不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。
• 请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。
• 循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样

其中最容易破坏的就是 " 循环等待".

最常用的一种死锁阻止技术就是 锁排序 . 假设有 N 个线程尝试获取 M 把锁 , 就可以针对 M 把锁进行编号 (1, 2, 3...M).

N 个线程尝试获取锁的时候 , 都按照固定的按编号由小到大顺序来获取锁 . 这样就可以避免环路等待 .

两个线程对于加锁的顺序没有约定 , 就容易产生环路等待

Object lock1 = new Object();
Object lock2 = new Object();
Thread t1 = new Thread() {
    @Override
    public void run() {
        synchronized (lock1) {
            synchronized (lock2) {
                // do something...
           }
       }
   }
};
t1.start();
Thread t2 = new Thread() {
    @Override
    public void run() {
        synchronized (lock2) {
            synchronized (lock1) {
                // do something...
           }
       }
   }
};
t2.start();

Object lock1 = new Object();
Object lock2 = new Object();
Thread t1 = new Thread() {
    @Override
    public void run() {
        synchronized (lock1) {
            synchronized (lock2) {
                // do something...
           }
       }
   }
};
t1.start();
Thread t2 = new Thread() {
    @Override
    public void run() {
        synchronized (lock1) {
            synchronized (lock2) {
                // do something...
           }
       }
   }