集合类不安全问题

List

ArrayList不是线程安全类，在多线程同时写的情况下，会抛出java.util.ConcurrentModificationException异常。

private static void listNotSafe() {
    List<String> list=new ArrayList<>();
    for (int i = 1; i <= 30; i++) {
        new Thread(() -> {
            //add方法并未上锁
            list.add(UUID.randomUUID().toString().substring(0, 8));
            System.out.println(Thread.currentThread().getName() + "\t" + list);
        }, String.valueOf(i)).start();
    }
}

导致原因：并发修改异常

解决方法：

1. 使用Vector（ArrayList所有方法加synchronized，太重）。
2. 使用Collections.synchronizedList()转换成线程安全类。
3. 使用java.concurrent.CopyOnWriteArrayList（推荐）。

CopyOnWriteArrayList

这是JUC的类，通过写时复制来实现读写分离。比如其add()方法，就是先复制一个新数组，长度为原数组长度+1，然后将新数组最后一个元素设为添加的元素。

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

Set

跟List类似，HashSet和TreeSet都不是线程安全的，与之对应的有CopyOnWriteSet这个线程安全类。这个类底层维护了一个CopyOnWriteArrayList数组。

private final CopyOnWriteArrayList<E> al;
public CopyOnWriteArraySet() {
    al = new CopyOnWriteArrayList<E>();
}

HashSet和HashMap

HashSet底层是用HashMap实现的。既然是用HashMap实现的，那HashMap.put()需要传两个参数，而HashSet.add()只传一个参数，这是为什么？实际上HashSet.add()就是调用的HashMap.put()，HashSet的add都值其实是HashMap的Key，只不过Value被写死了，是一个private static final Object对象。

Map

HashMap不是线程安全的，和上面的List、Set类似。Hashtable是线程安全的，但是跟Vector类似，太重量级。所以也有类似CopyOnWriteMap，只不过叫ConcurrentHashMap。

关于集合不安全类请看ContainerNotSafeDemo。

Java锁

公平锁/非公平锁

概念：所谓公平锁，就是多个线程按照申请锁的顺序来获取锁，类似排队，先到先得。而非公平锁，则是多个线程抢夺锁，会导致优先级反转或饥饿现象。

区别：公平锁在获取锁时先查看此锁维护的等待队列，为空或者当前线程是等待队列的队首，则直接占有锁，否则插入到等待队列，FIFO原则。非公平锁比较粗鲁，上来直接先尝试占有锁，失败则采用公平锁方式，排在等待队列的队尾。juc.ReentrantLock默认都是非公平锁，非公平锁的优点是吞吐量比公平锁更大。

synchronized和juc.ReentrantLock默认都是非公平锁。ReentrantLock在构造的时候传入true则是公平锁。

可重入锁/递归锁

可重入锁又叫递归锁，指的同一个线程在外层方法获得锁时，进入内层方法会自动获取锁。也就是说，线程可以进入任何一个它已经拥有锁的代码块。比如get方法里面有set方法，两个方法都有同一把锁，得到了get的锁，就自动得到了set的锁。

就像有了家门的锁，厕所、书房、厨房就为你敞开了一样。可重入锁的作用就是避免死锁的问题。

可重入锁(递归)的情形：

• 同一类的两个同步方法可以相互调用，因为锁的都是一个对象
• 子类的同步方法调用父类的同步方法，其锁定的还是子类的this对象

注意：ReentrantLock和synchronized都是可重入的。并且只要lock和unlock的个数匹配，加几把锁都是可以的。如果lock和unlock的个数不匹配，编译会通过，但是运行会出错。

 public void get(){
        //多把锁，既能编译通过，也能运行正常
        lock.lock();
        lock.lock();
        lock.lock();
        try{
            System.out.println(Thread.currentThread().getId()+"\t"+"get()");
            set();
        }finally {
            //前提是unlock()和unlock()的个数对应即可
            lock.unlock();
            lock.unlock();
            lock.unlock();
        }
}
public void set(){
        lock.lock();
        try{
            System.out.println(Thread.currentThread().getId()+"\t"+"set()");
        }finally {
            lock.unlock();
        }
}
    
 get();

详见ReentrantLockDemo。

自旋锁

所谓自旋锁，就是尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取。自己在那儿一直循环获取，就像“自旋”一样。这样的好处是减少线程切换的上下文开销（自旋锁主要是避免用户空间和内核空间之间的切换），缺点是会消耗CPU。CAS底层的getAndAddInt就是自旋锁思想。

//跟CAS类似，一直循环比较。
while (!atomicReference.compareAndSet(null, thread)) { }

CAS底层实现

package thread;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

public class SpinLockDemo {
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public static void main(String[] args) {
        SpinLockDemo spinLockDemo = new SpinLockDemo();
        new Thread(() -> {
            spinLockDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (Exception e) {
                e.printStackTrace();
            }
            spinLockDemo.myUnlock();
        }, "AA").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            spinLockDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            }
            spinLockDemo.myUnlock();
        }, "BB").start();
    }

    public void myLock() {
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "\t" + " come in ...");
        //自旋锁：阻塞循环等待
        while (!atomicReference.compareAndSet(null, thread)) { }
    }

    public void myUnlock() {
        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread, null);
        System.out.println(Thread.currentThread().getName() + "\t" + " unlock ...");
    }
}

读写锁（独占/共享锁）

读锁是共享的，写锁是独占的。juc.ReentrantLock和synchronized都是独占锁，独占锁就是一个锁只能被一个线程所持有。有的时候，需要读写分离，那么就要引入读写锁，即juc.ReentrantReadWriteLock。

• 读-读能共存
• 读-写不能共存
• 写-写不能共存

比如缓存，就需要读写锁来控制。缓存就是一个键值对，以下Demo模拟了缓存的读写操作，读的get方法使用了ReentrantReadWriteLock.ReadLock()，写的put方法使用了ReentrantReadWriteLock.WriteLock()。这样避免了写被打断，实现了多个线程同时读。

package thread;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache cache = new MyCache();
        //写
        for (int i = 1; i <= 5; i++) {
            final int tempInt = i;
            new Thread(() -> {
                cache.put(tempInt + "", tempInt + "");
            }, String.valueOf(i)).start();
        }
        //读
        for (int i = 1; i <= 5; i++) {
            final int tempInt = i;
            new Thread(() -> {
                cache.get(tempInt + "");
            }, String.valueOf(i)).start();
        }
    }
}

class MyCache {
    //缓存更新快，需要用volatile修饰
    private volatile Map<String, Object> map = new HashMap<>();
    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

    public void put(String key, Object value) {
        //读写锁可以看作是“雌雄同体”，只到用的时候才确定是读还是写
        rwLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t" + "正在写入： " + key);
            //模拟网络传输
            try {
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                rwLock.writeLock().unlock();
            }
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "\t" + "写入完成");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void get(String key) {    
         //读写锁可以看作是“雌雄同体”，只到用的时候才确定是读还是写
        rwLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t" + "正在读取： " + key);
            //模拟网络传输
            try {
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (Exception e) {
                e.printStackTrace();
            }
            Object result = map.get(key);
            System.out.println(Thread.currentThread().getName() + "\t" + "读取完成： " + result);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            rwLock.readLock().unlock();
        }
    }
}

Synchronized和Lock的区别

synchronized关键字和java.util.concurrent.locks.Lock都能加锁，两者有什么区别呢？

1. 原始构成：sync是JVM层面的，底层通过monitorenter和monitorexit来实现的。Lock是JDK API层面的。（sync一个enter会有两个exit，一个是正常退出，一个是异常退出）
2. 使用方法：sync不需要手动释放锁，而Lock需要手动释放。
3. 是否可中断：sync不可中断，除非抛出异常或者正常运行完成。Lock是可中断的，通过调用interrupt()方法。
4. 是否为公平锁：sync只能是非公平锁，而Lock既能是公平锁，又能是非公平锁。
5. 绑定多个条件：sync不能，只能随机唤醒。而Lock可以通过Condition来绑定多个条件，精确唤醒。

精确唤醒Demo：A唤醒B，B唤醒C，C唤醒A

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 线程的精确唤醒Demo：
 * A唤醒B，B唤醒C，C唤醒A
 * */

public class  Test{
    // 0：A   1：B   2：C
    private int num = 0;
    private Lock lock = new ReentrantLock();

    Condition A = lock.newCondition();
    Condition B = lock.newCondition();
    Condition C = lock.newCondition();

    private void awake_A(){
        //上锁
        lock.lock();
        try {
            while (num!=0){
                try {
                    //非A就等待
                    A.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("A");
            //设置num，并唤醒B
            num = 1;
            B.signal();


        }catch (Exception e){
            e.printStackTrace();
        }
        finally {
            //释放锁
            lock.unlock();
        }

    }

    private void awake_B(){
        //上锁
        lock.lock();
        try {
            while (num!=1){
                try {
                    //非B就等待
                    B.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("B");
            //设置num，并唤醒C
            num = 2;
            C.signal();


        }catch (Exception e){
            e.printStackTrace();
        }
        finally {
            //释放锁
            lock.unlock();
        }

    }

    private void awake_C(){
        //上锁
        lock.lock();
        try {
            while (num!=2){
                try {
                    //非C就等待
                    C.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            System.out.println("C");
            //设置num，并唤醒A
            num = 0;
            A.signal();


        }catch (Exception e){
            e.printStackTrace();
        }
        finally {
            //释放锁
            lock.unlock();
        }

    }

    public static void main(String[] args) {

        Test t = new Test();

        for (int i = 1; i < 4; i++) {
            new Thread(()->{
                t.awake_A();
            },"AAA").start();
        }

        for (int i = 1; i < 4; i++) {
            new Thread(()->{
                t.awake_B();
            },"BBB").start();
        }

        for (int i = 1; i < 4; i++) {
            new Thread(()->{
                t.awake_C();
            },"CCC").start();
        }

    }
}

/*====================output========================
A
B
C
A
B
C
A
B
C
 */

CountDownLatch/CyclicBarrier/Semaphore

CountDownLatch

CountDownLatch内部维护了一个计数器，只有当计数器==0时，某些线程才会停止阻塞，开始执行。

CountDownLatch主要有两个方法，countDown()来让计数器-1，await()来让线程阻塞。当count==0时，阻塞线程自动唤醒。

案例一班长关门：main线程是班长，6个线程是学生。只有6个线程运行完毕，都离开教室后，main线程班长才会关教室门。

案例二秦灭六国：只有6国都被灭亡后（执行完毕），main线程才会显示“秦国一统天下”。

枚举类的使用

在案例二中会使用到枚举类，因为灭六国，循环6次，想根据i的值来确定输出什么国，比如1代表楚国，2代表赵国。如果用判断则十分繁杂，而枚举类可以简化操作。

枚举类就像一个简化的数据库，枚举类名就像数据库名，枚举的项目就像数据表，枚举的属性就像表的字段。

public enum countryEnum {
    ONE(1,"齐"),TWO(2,"楚"),THREE(3,"燕"),FOUR(4,"赵"),FIVE(5,"魏"),SIX(6,"韩");

    public Integer getRetCode() {
        return retCode;
    }

    public String getRetMessage() {
        return retMessage;
    }

    private Integer retCode;
    private String retMessage;

    countryEnum(Integer retCode, String retMessage) {
        this.retCode = retCode;
        this.retMessage = retMessage;
    }

    public static countryEnum forEach_countyEnum(int index){
         countryEnum [] myArray = countryEnum.values();
         for(countryEnum element : myArray){
             if(index == element.getRetCode()){
                 return element;
             }
         }
         return null;
    }
}

××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××

import java.util.concurrent.CountDownLatch;


public class CountDownLatchDemo {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(6);

        for (int i = 1; i <=6 ; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+ "\t 国，破灭");
                countDownLatch.countDown();
            },countryEnum.forEach_countyEnum(i).getRetMessage()).start();
        }

        countDownLatch.await();

        System.out.println(Thread.currentThread().getName() + "\t 秦国，统一");


    }

}

CyclicBarrier

CyclicBarrier字面意思就是可循环(Cyclic)使用的屏障(Barrier)。他的作用就是让一组线程达到一个屏障(也叫同步点)时才会被阻塞，知道最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。线程进入屏障使用CyclicBarrier的await()方法
CountDownLatch是减，而CyclicBarrier是加，理解了CountDownLatch，CyclicBarrier就很容易。比如召集7颗龙珠才能召唤神龙:

package thread;

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier=new CyclicBarrier(7,()->{
            System.out.println("*****召唤神龙");
        });
        for (int i = 1; i <=7 ; i++) {
            final int tempInt=i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+
                        "\t 收集到第"+tempInt+"颗龙珠");
                try{
                    cyclicBarrier.await();
                }catch (Exception e){
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
}

Semaphore

Semaphore的主要目的有两个：一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制。CountDownLatch的问题是不能复用。比如count=3，那么加到3，就不能继续操作了。而Semaphore可以解决这个问题，比如6辆车3个停车位，对于CountDownLatch只能停3辆车，而Semaphore可以停6辆车，车位空出来后，其它车可以占有，这就涉及到了Semaphore.accquire()和Semaphore.release()方法。

Semaphore semaphore=new Semaphore(3);
for (int i = 1; i <=6 ; i++) {
    new Thread(()->{
        try {
            //占有资源
            semaphore.acquire();
            System.out.println(Thread.currentThread().getName()+"\t抢到车位");
            try{ TimeUnit.SECONDS.sleep(3);} catch (Exception e){e.printStackTrace(); }
        System.out.println(Thread.currentThread().getName()+"\t停车3秒后离开车位");
        } 
        catch (InterruptedException e) {e.printStackTrace();} 
        //释放资源
        finally {semaphore.release();}
    },String.valueOf(i)).start();
}

/*====================output========================
2   抢到车位
3   抢到车位
1   抢到车位
2   停车3秒后离开车位
3   停车3秒后离开车位
1   停车3秒后离开车位
5   抢到车位
4   抢到车位
6   抢到车位
6   停车3秒后离开车位
4   停车3秒后离开车位
5   停车3秒后离开车位
*/

参考：https://github.com/MaJesTySA/JVM-JUC-Core/blob/master/docs/JUC.md#jmm