java锁（公平锁和非公平锁、可重入锁(又名递归锁)、自旋锁、独占锁(写)/共享锁(读)/互斥锁、读写锁）

前言

本文对Java的一些锁的概念和实现做个整理，涉及：公平锁和非公平锁、可重入锁(又名递归锁)、自旋锁、独占锁(写)/共享锁(读)/互斥锁、读写锁

公平锁和非公平锁

概念

• 公平锁是指多个线程按照申请锁的顺序来获取锁。类似于进程的FCFS（先来先服务），队列的FIFO（先来先输出）
• 非公平锁是指在多线程获取锁的顺序并不是按照申请锁的顺序,有可能后申请的线程比先申请的线程优先获取到锁,在高并发的情况下,有可能造成优先级反转或者饥饿现象（长时间无法获得锁）

区别

公平锁：公平锁就很公平。在并发环境中，每个线程在获取锁时会先查看这个锁维护的等待队列，如果为空，即当前线程是等待队列中的第一个就占有锁，否则就加入等待队列中，根据FIFO的规则等待占有锁。
非公平锁：这个就很不公平了。在并发环境中，每个线程一上来不管三七二十一就尝试抢占锁，没有抢到锁再采用类似公平锁的那种机制。

实现

• sychronized就是一种非公平锁。
• ReentrantLock通过构造函数指定该锁是否是公平锁（true为公平锁，false为非公平锁），默认是非公平锁（false），非公平锁的优点在于吞吐量比公平锁大。

可重入锁

概念

可重入锁也叫递归锁，指同一个线程在获得了外层函数的锁后，内层递归函数仍然能获取该锁的代码。也就是说，同一线程在外层方法获得锁后，在进入内层方法会自动获取锁。

作用

可重入锁最大的作用就是避免死锁

实现

ReentrantLock和synchronized都是典型的可重入锁，给出ReentrantLock和synchronized同步锁的代码实现：
1.使用sychronized关键字演示可重入锁:

public class SychronizedDemo {

    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(()->{
            phone.call();
        },"thread1").start();
        new Thread(()->{
			try {
            TimeUnit.SECONDS.sleep(1);
        	} catch (InterruptedException e) {
            e.printStackTrace();
       		}
            phone.sendSMS();
        },"thread2").start();

    }
}

class Phone{
    public synchronized void call(){
        System.out.println(Thread.currentThread().getName() + "\t 拨打电话");
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        sendSMS();
    }
    public synchronized void sendSMS(){
        System.out.println(Thread.currentThread().getName() + "\t 发短信");
    }
}

代码解读：
这段代码的输出结果是多少呢？有人可能会认为是：

thread1	 拨打电话
thread2	 发短信
thread1	 发短信

因为在线程1获得了call方法的锁输出了“thread1拨打电话”之后睡眠了2秒，然后这时线程2肯定能够枪到sendSMS方法的锁输出“thread2发短信”最后才是线程1醒了获取到sendSMS方法的锁输出“thread1发短信”。
这种想法是没错，但不要忘了sychronized是可重入锁，在线程1得到call方法的锁后就已经得到了其方法内部的sendSMS方法的锁，这时线程2去执行sendSMS方法的时候会发现该方法是出于锁住的状态然后线程2阻塞，等到线程1执行完call方法释放sendSMS方法的锁之后线程2才能继续执行。所以正确的输出结果是：

thread1	 拨打电话
thread1	 发短信
thread2	 发短信

2.使用ReentrantLock演示可重入锁:

public class ReentrantLockDemo {

    public static void main(String[] args) {
        Phone2 phone = new Phone2();

        new Thread(()->{
            phone.call();
        },"thread1").start();
        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            phone.sendSMS();
        },"thread2").start();

    }
}

class Phone2{
    Lock lock = new ReentrantLock();
    public void call(){
        try{
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "\t 拨打电话");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            sendSMS();
        }finally {
            lock.unlock();
        }

    }
    public void sendSMS(){
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "\t 发短信");
        }finally {
            lock.unlock();
        }
    }
}

输出结果和使用sychronized一样。

自旋锁

概念

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

实现

其实CAS的核心实现类UnSafe采用的就是自旋锁：

 public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

自写自旋锁实现：

public class SpinLockDemo {

    private AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void myLock(){
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName() + " come in");
        while (!atomicReference.compareAndSet(null,thread)){

        }
        System.out.println(thread.getName() + " 获得锁");
    }
    public void myUnLock(){
        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread,null);
        System.out.println(thread.getName() + " myUnLock");
    }
    public static void main(String[] args) {
        SpinLockDemo spinLockDemo = new SpinLockDemo();
        new Thread(()->{
            spinLockDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.myUnLock();
        },"thread1").start();

        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.myLock();
            spinLockDemo.myUnLock();
        },"thread2").start();
    }
}

输出结果：

thread1 come in
thread1 获得锁
thread2 come in
thread1 myUnLock
thread2 获得锁
thread2 myUnLock

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

概念

独占锁：指该锁只能被一个线程所持有，如ReentrantLock和sychronized都是独占锁
共享锁：指该锁可以被多个线程所持有，如ReentrantReadWriteLock其读锁是共享锁，写是独占锁。
读的共享锁可以保证并发读是非常高效的。
互斥锁：互斥锁是一种简单的加锁的方法来控制对共享资源的访问，互斥锁只有两种状态,即上锁(lock)和解锁(unlock)。如ReentrantLock和sychronized都是互斥锁

实现

下面是使用ReentrantReadWriteLock实现读时共享写时独占

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCaChe myCaChe = new MyCaChe();
        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(() -> {
                myCaChe.put(temp + "", temp);
            }, String.valueOf(i)).start();
        }
        for (int i = 1; i <= 5; i++) {
            int finalI = i;
            new Thread(() -> {
                myCaChe.get(finalI + "");
            }, String.valueOf(i)).start();
        }
    }
}

class MyCaChe {

    private volatile Map<String, Object> map = new HashMap<>();
    private ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
    public void put(String key, Object value) {
        reentrantReadWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t正在写入" + key);
            //模拟网络延时
            try {
                TimeUnit.MICROSECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "\t完成写入" + key);
        } finally {
            reentrantReadWriteLock.writeLock().unlock();
        }
    }

    public void get(String key) {
        reentrantReadWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t正在读取" + key);
            //模拟网络延时
            try {
                TimeUnit.MICROSECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Object result = map.get(key);
            System.out.println(Thread.currentThread().getName() + "\t完成读取" + key);
        } finally {
            reentrantReadWriteLock.readLock().unlock();
        }
    }

    public void clearCaChe() {
        map.clear();
    }
}

代码

本文所涉及的所有代码都在我的GitHub上：代码