高并发与多线程第二篇-锁的实现

1、锁的作用

在多线程运行状态下，为保证部分共享数据的线程安全，所以在需要实现线程安全的代码块需要加锁控制

2、锁的类型

从大方向来说锁主要分为 synchronized和lock锁，以及通过lock实现的其他锁，例如：ReentrantLock、CountDownLatch、CyclicBarrier等。其下又可根据实际的特性分为乐观锁，悲观锁等

3、锁的介绍

（1）Synchronized 关键字锁

class syncTest {

    static Thread t1 = null;
    static Thread t2 = null;
    
    /**
     *synchronized锁升级的过程：
     *                    无锁：没有线程访问的时候为无锁状态
     *                    偏向锁：第一个线程访问的时候，会在锁对象的head中标记当前线程的ID，用以确认是否还是只有一个线程访问
     *                    自旋锁(CAS)：当第二个线程访问的时候，sync就会升级为自旋锁，通过CAS来保证线程安全
     *                    重量级锁：这是sync最终的锁，当一个线程在自旋的状态下自旋10以上，sync就会向内核申请重量级锁
     *                注意：sync锁升级过程是不可逆的。一旦升级为重量级锁，就会一直以重量级锁的状态也存在
     * synchronized（new Object）以一个对象作为锁
     * public void synchronized methods()；将sync加到方法上则是相当于synchronized(this)
     * public void static synchronized methods()；将sync加到方法上则是相当于synchronized(this.Class)
     *  注意：锁对象不能用基础数据类型
     * 锁释放：sync中只能用wait()方法
     * 锁唤醒：sync锁唤醒需要用natify()或者notifyAll()
     */
    public static void main(String[] args) {

        List list = Collections.synchronizedList(new ArrayList<>());

        Object o = new Object();

        t1 = new Thread(() -> {
            System.out.println("t1启动");
            synchronized (o) {
                try {
                    o.wait();
                    System.out.println("t1结束");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                o.notify();
            }
        });

        t2 = new Thread(() -> {
            System.out.println("t2启动");
            synchronized (o) {
                for (int i = 0; i < 10; i++) {
                    list.add(new Object());
                    System.out.println("添加" + list.size());
                    if (list.size() == 5) {
                        o.notify();
                        try {
                            o.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
            System.out.println("t2结束");

        });
        t1.start();
        t2.start();
    }
}

（2）LockSupport

public class LockSupportTest {

    static Thread t1 = null;
    static Thread t2 = null;

    public static void main(String[] args) {
        List list = Collections.synchronizedList(new ArrayList<>());
        t2 = new Thread(() -> {
            System.out.println("t2启动");
            for (int i = 0; i < 10; i++) {
                list.add(new Object());
                System.out.println("添加" + list.size());
                if (list.size() == 5) {
                    LockSupport.unpark(t1);
                    LockSupport.park();
                }
            }
        });
        t1 = new Thread(() -> {
            System.out.println("t1启动");
            LockSupport.park();
            if (list.size() == 5) {
                System.out.println("t1结束");
                LockSupport.unpark(t2);
            }
        });
        t1.start();
        t2.start();
    }
}

（3）ReentrantLock

class ReentrantLockTest {
    static ReentrantLock reentrantLock = new ReentrantLock();
    Condition condition = reentrantLock.newCondition();
    static volatile int count = 0;

    /**
     * ReentrantLock 是可重入锁，同一个线程执行获取锁后，后续其他锁可以重入
     * reentrantLock.lock(); 获取锁
     * reentrantLock.unlock(); 释放锁，必须放在finally中，防止死锁
     * new ReentrantLock();默认是非公平锁，线程执行到lock时，会直接去抢锁
     * new ReentrantLock(true); 公平锁，线程执行到lock时会先去查看等待队列中是否有线程，如果有就去排队
     * reentrantLock.newCondition();可以创建一个Condition锁，主要适用于线程交互、通知场景，作用于精准唤醒
     * 
     */
    public static void main(String[] args) {
        Thread[] threads = new Thread[10];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(() -> {
                reentrantLock.lock();
                try {
                    TimeUnit.SECONDS.sleep(1);
                    System.out.println(Thread.currentThread().getName() + "线程执行");
                    getCount();
                    System.out.println("count:" + count);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    reentrantLock.unlock();
                }
            });
        }
        for (int i = 0; i < threads.length; i++) {
            threads[i].start();
        }
    }

    static void getCount() {
        reentrantLock.lock();
        try {
            TimeUnit.SECONDS.sleep(1);
            count++;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            reentrantLock.unlock();
        }
    }
}

（4）CountDownLatch

class CountDownLatchTest{
    static CountDownLatch count = new CountDownLatch(3);
    /**
     * CountDownLatch(3) 相当于一个倒数计数器
     * count.countDown();每调用一次减一
     * count.await();括号内的数大于零的时候阻塞
     */
    public static void main(String[] args) throws InterruptedException{
        Thread[] threads = new Thread[3];
        for (int i = 0; i <threads.length ; i++) {
            threads[i] = new Thread(()->{
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"来了");
                count.countDown();
            },"小"+i);
        }
        for (int i = 0; i < threads.length; i++) {
            threads[i].start();
        }
        count.await();
      
        System.out.println("人来齐了");
    }
}

（5）CyclicBarrier

class CyclicBarrierTest{

   static CyclicBarrier cyclicBarrier = new CyclicBarrier(10);
    public static void main(String[] args){
        /*
         *new CyclicBarrier(10) 是一个循环栅栏，参数是需要拦住的线程数，在线程数达到阈值的时候统一方形
         * cyclicBarrier.await() 当前线程进入等待中
         */
        Thread[] threads = new Thread[11];
        for (int i = 0; i <threads.length ; i++) {
            threads[i] = new Thread(()->{
                try {
                    TimeUnit.SECONDS.sleep(1);
                    System.out.println(Thread.currentThread().getName()+"来了");
                    cyclicBarrier.await();
                    System.out.println(Thread.currentThread().getName()+"冲破了栅栏");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },"小"+i);
        }
        for (int i = 0; i < threads.length; i++) {
            threads[i].start();
        }
    }
}