多线程之 JUC下的一些同步锁

• 原子类
  原子类的实现是CAS
• 使用AQS实现的各种同步锁（除LockSupport）
  
• ReentranLock 不谈
• CountDownLatch 门栓

package com.example.demo.thread.juc;

import java.util.concurrent.CountDownLatch;

/**
 * @author MasterYee
 * @Description： 门栓
 * 相当于做了一个门栓 调用了countDownLatch.await()的线程将阻塞住 直到门栓为0即门栓放开
 * @date: 2020/6/5
 */
public class CountDownLatchTest {
    public static void main(String[] args) throws Exception {
        CountDownLatch countDownLatch = new CountDownLatch(10); // 门栓大小为10


        for (int i = 0; i <20 ; i++) {
            new Thread(()->{
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
                countDownLatch.countDown(); // 门栓大小--
            }).start();
        }

        countDownLatch.await(); // 阻塞住，直到门栓为0
        System.out.println("ok main go!");

        System.out.println(countDownLatch.getCount()); // 减为0后再减 依然是0

    }
}

• CyclicBarrier 栅栏
  门栓是设定一个数，每个线程去countdown，到0后，await线程执行。
  栅栏是设定一个数，每个线程去await，到设定的这个数的时候，所有线程一起继续运行。

package com.example.demo.thread.juc;

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

/**
 * @author MasterYee
 * @Description：cyclicBarrier 栅栏
 * cyclicBarrier.await(); 线程调用这个方法相当于阻塞在了栅栏上
 * 两个参数 1. 栅栏的阈值 阻塞的线程数达到这个值时，线程全部放行
 *         2. 一个Runnable的实例，在栅栏放行后会运行
 * 栅栏放行后，栅栏的大小清空，继续阻塞下一波到达的线程
 * 有点类似于CountDownLatch
 * @date: 2020/6/4
 */
public class CyclicBarrierTest {

    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(20, () -> {
            System.out.println("ok go!");
        });

        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            }).start();
        }
    }
}

• Phaser 移相器
  https://www.cnblogs.com/huangzifu/p/7612547.html

• ReadWriteLock 读写锁
  读锁是共享锁，写锁是互斥锁，写时不允许读。

package com.example.demo.thread.juc;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author MasterYee
 * @Description：读写锁
 * 读锁为共享锁，写锁为排他锁
 * 读时可以一起读，但写时只有当前一个线程能写 其它线程不可读写
 *
 * @date: 2020/6/5
 */
public class ReadWirteLockTest {
    public static void main(String[] args) {
        ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        Lock readLock = readWriteLock.readLock(); // 读锁
        Lock writeLock = readWriteLock.writeLock();// 写锁

        // 5个线程访问同一个文件 做写操作
        for (int i = 0; i <5 ; i++) {
            new Thread(()->{
                try {

                    writeLock.lock();
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName() + " wirting...");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    writeLock.unlock();
                }
            }).start();
        }

        // 15个线程访问同一个文件 做读操作
        for (int i = 0; i <15 ; i++) {
            new Thread(()->{
                try {
                    readLock.lock();
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName() + " reading...");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    readLock.unlock();
                }
            }).start();
        }

        System.out.println("--------------------");

      /*  *//** 普通的锁的话 读也是互斥锁 导致需要20s **//*
        Lock lock = new ReentrantLock();

        // 5个线程访问同一个文件 做写操作
        for (int i = 0; i <5 ; i++) {
            new Thread(()->{
                try {

                    lock.lock();
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName() + " wirting...");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }).start();
        }

        // 15个线程访问同一个文件 做读操作
        for (int i = 0; i <15 ; i++) {
            new Thread(()->{
                try {
                    lock.lock();
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName() + " reading...");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }).start();
        }*/

    }
}

• Semaphore 信号量
  构造参数传入一个信号量的值。
  s.acquire()方法获取一个信号量，当acquire的线程达到信号量的值，再来新的线程acquire就阻塞
  s.release释放信号量

package com.example.demo.thread.juc;

import java.util.TreeMap;
import java.util.concurrent.Semaphore;

/**
 * @author MasterYee
 * @Description：信号量
 * 主要用于限流
 * 例如：这个程序同一时刻只会有最大5个线程（信号量的值）运行
 * @date: 2020/6/5
 */
public class SemaphoreTest {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(5,true); // 10是信号量的值 true表示为公平队列 新来的线程都到队列尾部

        for (int i = 0; i < 50; i++) {
            new Thread(()->{
                try {
                    semaphore.acquire();  // 获取一个信号量,信号量的值-- 信号量减为0了 阻塞 直到可以获取
                    System.out.println(Thread.currentThread().getName() + " get semaphore go!");
                    Thread.sleep(1000);
                    semaphore.release();  // 任务完成 释放信号量 信号量的值++
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }


    }
}

• Exchager 交换器
  用于2个线程间交换数据，exchange()方法是阻塞的，相当于把一个值放进这个容器里，然后阻塞，另外一个线程也exchange()时，容器里的2个数据交换，然后2个线程一起继续跑

package com.example.demo.thread.juc;

import java.util.concurrent.Exchanger;

/**
 * @author MasterYee
 * @Description：
 * 相当于创建了一个大小为2的容器
 * 线程1往里面仍东西 并阻塞住
 * 线程2往里面扔东西 并阻塞住
 * 当容器满了 （12都扔了东西） 交换 并重新赋值给线程12 然后放行
 * @date: 2020/6/5
 */
public class ExchangeTest {
    public static void main(String[] args) {
        Exchanger<String> stringExchanger = new Exchanger<>();

        new Thread(()->{
            String s = "我是线程1的";
            try {
                s = stringExchanger.exchange(s);
                System.out.println("线程1的s " + s);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(()->{
            String s = "我是线程2的";
            try {
                Thread.sleep(5000);
                s = stringExchanger.exchange(s);
                System.out.println("线程2的s " + s);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

• LockSupport
  AQS的阻塞都是通过LockSupport实现的
  LockSupport提供2个方法: park(),unpark(Thread)分别为阻塞和让线程继续运行下去，是用unsafe类里的方法实现的
  
  
  需要注意 lockSupport.park() 线程的状态是WAITING，而syncronized，线程的状态是BLOCKED