分析Java锁机制，快速理解每一种锁

Lock与synchronized的区别

Synchronized	Lock
内置的Java关键字	一个Java类
无法判断获取锁的状态	可以判断是否获取到了锁
会自动释放锁	必须要手动释放锁
可重入锁 ，不可以中断的，非公平	可重入锁，可以判断锁，公平/非公平
适合锁少量的同步代码	适合锁大量的同步代码

死锁

• 当第一个线程拥有A对象锁标记，并等待B对象锁标记，同时第二个线程拥有B对象锁标记，并等待A对象锁标记时，产生死锁。
• 一个线程可以同时拥有多个对象的锁标记，当线程阻塞时，不会释放已经拥有的锁标记，由此可能造成死锁。

死锁的四个条件：互斥、持有并等待、不可剥夺、循环等待

如何避免死锁：只需破坏死锁的四个条件之一即可

锁的四种状态

无锁：不对资源上锁，所有线程都可以访问资源，但只有一个能修改成功

偏向锁：当一个同步代码块一直被同一个线程访问时，会自动获取锁，提高性能

轻量级锁：当一个资源上的锁是偏向锁的时候，有另外一个线程访问，就会自动升级为轻量级锁，其它线程通过自旋来尝试获取锁，不会阻塞，从而提高了性能

重量级锁：当一个线程获取锁失败时，会阻塞

乐观锁vs悲观锁

乐观锁：在自己修改数据的时候，认为不会有别的线程来修改数据，只是在更新数据的时候，判断数据是否被其它数据修改了，如果没被修改，则直接更新数据，如果被修改了，则使用其它方法来解决，例如在Java中使用CAS算法

悲观锁：指对数据被外界修改持保守态度，认为数据很容易就会被其他线程修改，所以在数据被处理前先对数据进行加锁，并在整个数据处理过程中，使数据处于锁定状态。

自旋锁vs自适应自旋锁

自旋锁：不断尝试去获取锁，如果获取不到，则一直循环去尝试

自适应自旋锁：不断尝试去获取锁，如果获取不到，会根据一定的算法，很快的判断出是否还需要再去获取，而不必一直循环尝试

公平锁vs非公平锁

公平锁：多个线程按照锁的申请顺序来获取锁

• 优点：不会出现线程饿死的情况，每个线程排队获取
• 缺点：整体的效率低

private Lock lock = new ReentrantLock();

非公平锁：多个线程不按照申请顺序来获取锁，会插队申请锁

• 优点：整体效率高
• 缺点：有可能最先来的线程也一直获取不到锁，出现线程饿死的情况

private Lock lock = new ReentrantLock(false);

重入锁vs非重入锁

可重入锁：上锁之后，还可以再次获取锁，此时就上了两层锁，那么解锁的时候，就需要解锁两次

• ReentrantLock和synchronized都是重入锁

// 创建可重入锁
private Lock lock = new ReentrantLock();

• 比如一个方法被锁住之后，在此方法的内部又调用了另一个方法，那么内部的那个方法仍然可以获取到锁
• 此时锁的数量加1，解锁时锁的数量减1，直到减为0时，此线程最终释放锁

public synchronized void fun() {
    fun2();
}

非重入锁：只能上锁一次

• 如果方法内部还需再次获取锁，则获取不到

// 实现不可重入锁
public class NoReentrantLockTest {

    private volatile boolean locked = false;

    public synchronized void lock() {
        while (locked) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            locked = true;
        }
    }
    public synchronized void unlock() {
        locked = false;
        notify();
    }
}

独占锁vs共享锁

独占锁（排它锁）：一次只允许一个线程上锁，（比如写锁，上了锁之后，其它线程既不能读，也不能写）

共享锁：可以被多个线程共享，当一个线程上了共享锁之后，其它线程只能再对其上共享锁，不能上独享锁

读写锁的原理就是：独占锁与共享锁，以下以读写锁的例子测试独享锁与共享锁

读写锁

• 一种支持一写多读的同步锁，读写分离，可分别分配读锁、写锁

• 支持多次分配读锁，使多个读操作可以并发执行。

互斥规则

• 读的时候上读锁，写的时候上写锁
• 一个线程读的时候，其它线程可以读，但不可以写
• 一个线程写的时候，其它线程不可以读，也不可以写

在读操作远远高于写操作的环境中，可在保障线程安全的情况下，提高运行效率

使用

对同一个资源，2个线程写，20个线程读，使用读写锁实现

package com.robot.juc.lock;

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

/**
 * 读写锁。
 * @author 张宝旭
 */
public class ReadWrite {
    // 创建读写锁
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    // 创建资源
    private int value;

    /**
     * 读操作
     * @return 读取到的值
     */
    public int read() {
        // 上读锁
        lock.readLock().lock();
        try {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return value;
        } finally {
            // 释放读锁
            lock.readLock().unlock();
        }
    }

    /**
     * 写操作
     * @param value 写入的值
     */
    public void write(int value) {
        // 上写锁
        lock.writeLock().lock();
        try {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.value += value;
        } finally {
            // 释放写锁
            lock.writeLock().unlock();
        }
    }
}

package com.robot.juc.lock;

import java.util.Random;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author 张宝旭
 */
public class ReadWriteTest {
    public static void main(String[] args) {
        ReadWrite readWrite = new ReadWrite();

        Runnable read = () -> {
            System.out.println(Thread.currentThread().getName() + " 读: " + readWrite.read());
        };
        Runnable write = () -> {
            int random = new Random().nextInt(25);
            readWrite.write(random);
            System.out.println(Thread.currentThread().getName() + " 写: " + random);
        };

        // 创建线程池
        ThreadPoolExecutor pool = new ThreadPoolExecutor(22, 25, 60,
                TimeUnit.SECONDS, new LinkedBlockingDeque<>(1), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        // 2个线程写
        for (int i = 0; i < 2; i++) {
            pool.submit(write);
        }
        // 20个线程读
        for (int i = 0; i < 20; i++) {
            pool.submit(read);
        }
        pool.shutdown();
    }
}

如果不使用读写锁，只使用了普通的互斥锁，那么2个线程写，20个线程读，会执行22秒左右

如果使用读写锁，那么2个线程写，20个线程读，则会执行3秒左右（因为2个写线程是互斥的，需要2秒，而20个线程可以同时读，共需1秒即可）