Java锁

锁

公平锁和非公平锁

公平锁

是指多个线程按照申请锁的顺序来获取锁。先来后到，先来先服务，就是公平的，也就是队列

非公平锁

是指多个线程获取锁的顺序，并不是按照申请锁的顺序，有可能申请的线程比先申请的线程优先获取锁，在高并发环境下，有可能造成优先级翻转，或者饥饿的线程（也就是某个线程一直得不到锁）

使用

Lock lock = new ReentrantLock(true);// 创建公平锁
Lock lock = new ReentrantLock();// 构造参数默认或者是false为非公平锁

可重入锁(递归锁)

递归锁指的是同一线程外层函数获得锁之后，内层递归函数仍然能获取到该锁的代码，在同一线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。

ReentrantLock/ Synchronized 都是递归锁

自旋锁(spinLock)

自旋锁是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU。

自旋锁的原理就是 CAS(compare and swap)

独占锁(写锁) / 共享锁(读锁) / 互斥锁

独占锁： 该锁一次只能被一个线程所持有，ReentrantLock和Synchronized 都是独占锁
共享锁： 该锁可以被多个线程所持有

对ReentrantReadWriteLock其读锁是共享，其写锁是独占

ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
reentrantReadWriteLock.readLock().lock();
reentrantReadWriteLock.readLock().unlock();
reentrantReadWriteLock.writeLock().lock();
reentrantReadWriteLock.writeLock().unlock();

并发工具类

CountDownLatch

作用：允许一个或者多个线程等待其他线程完成操作
使用场景：多个线程同时执行不同的操作，当所有线程完成后，输出完成
实现原理：CountDownLatch设置一个计数器，每当执行countDown方法的时候，计数器就会减一，当计数器为0的时候，就调用await方法被阻塞的线程会被唤醒，继续执行

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

        for (int i = 0; i <= 6; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread();
                countDownLatch.countDown();
            }, String.valueOf(i)).start();
        }
        //唤醒
        countDownLatch.await();

        System.out.println(Thread.currentThread().getName());
    }
}

CyclicBarrier

作用：让一组线程到达一个屏障时被阻塞，直到最后一个线程到达屏障，屏障才会打开，所有被屏障拦截的进程才会继续运行
使用场景：多个进程进行并行计算，需要得到当前所有的进程的结果，才能进行下一步计算。
实现原理：CyclicBarrier会设置一个目标数值和达到目标后需要执行的方法。每次调用CyclicBarrier的await方法时，CyclicBarrier的实际数值就会加一，当实际数值与目标相等时，就会调用目标方法。

public static void main(String[] args) {
        /**
         * 定义一个循环屏障，参数1：需要累加的值，参数2 需要执行的方法
         */
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
            System.out.println("end");
        });

        for (int i = 0; i < 7; i++) {
            final Integer tempInt = i;
            new Thread(() -> {
                System.out.println(Thread.currentThread());
                try {
                    // 先到的被阻塞，等全部线程完成后，才能执行方法
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }, String.valueOf(i)).start();
        }
    }

Semaphore

作用：用来控制同时访问特定资源的线程数量，它通过协调各个线程，以保证合理的使用公共资源。
使用场景：做流量控制
实现原理：Semaphore设置一个目标值，表示有这么多个令牌。当线程要访问公共资源的时候，需要先通过acquire方法获取令牌才能访问。当不需要的时候，通过release方法归还令牌。

public static void main(String[] args) {
    Semaphore semaphore = new Semaphore(2);
    for (int i = 0; i < 5; i++) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    // 获取令牌
                    semaphore.acquire();
                    TimeUnit.SECONDS.sleep(1);
                    System.out.println(Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //释放令牌
                    semaphore.release();
                }
            }
        },String.valueOf(i)).start();
    }
}

Exchanger

作用：用于进行线程间的数据交换
使用场景：遗传算法
实现原理：通过提供一个同步点，在这个同步点。两个线程可以通过exchange方法交换数据。如果第一个线程执行exchange()方法，那么它会等第二个线程也执行exchange()方法。当两个线程都到达同步点时，交换数据

public static void main(String[] args) {
    Exchanger<String> nameExchanger = new Exchanger<>();
    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                String exchange = nameExchanger.exchange(Thread.currentThread().getName());
                System.out.println(Thread.currentThread().getName() + "   " + exchange);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }, "A").start();

    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                String exchange = nameExchanger.exchange(Thread.currentThread().getName());
                System.out.println(Thread.currentThread().getName() + "   " + exchange);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }, "B").start();
}

Synchronized和Lock的区别

1. synchronized属于JVM层面，属于java的关键字,Lock是具体类（java.util.concurrent.locks.Lock）是api层面的锁
2. synchronized底层是通过monitor对象来完成，wait/notify等方法也依赖于monitor对象 只能在同步块或者方法中才能调用 wait/ notify等方法
3. synchronized不需要用户去手动释放锁，当synchronized代码执行后，系统会自动让线程释放对锁的占用。ReentrantLock：则需要用户去手动释放锁，若没有主动释放锁，就有可能出现死锁的现象，需要lock() 和 unlock() 配置try catch语句来完成
4. synchronized：不可中断，除非抛出异常或者正常运行完成。而ReentrantLock是可中断，可以设置超时方法，或者调用interrupt() 方法中断
5. synchronized是非公平锁。ReentrantLock默认是非公平锁，构造函数可以传递boolean值，true为公平锁，false为非公平锁
6. synchronized：没有，要么随机，要么全部唤醒线程。ReentrantLock用来实现分组唤醒需要唤醒的线程，可以精确唤醒，而不是像synchronized那样，要么随机，要么全部唤醒

死锁

死锁的原因

• 系统资源不足
• 进程运行推进的顺序不对
• 资源分配不当

死锁产生的四个必要条件

• 互斥：可以通过将互斥的共享资源封装成可同时访问
• 占有并等待：要求进程必须一次性申请到所有资源，不占有任何资源
• 非抢占式：如果进程不能立即分配资源，要求它不占有任何其他资源，只有同时获取所有资源时，才执行分配动作
• 循环等待：对资源进行排序，要求进程按照顺序请求资源