三、synchronized & lock

一、锁的类型

1.1 可重入锁

在执行对象中所有同步方法不用再次获得锁。
如果锁具备可重入性，则称作为可重入锁。synchronized 和 ReentrantLock 都是可重入锁。
可重入性表明了锁的分配机制：基于线程的分配，而不是基于方法调用的分配。
比如说，当一个线程执行到 method1 的 synchronized 方法时，而在 method1 中会调用另外一个 synchronized 方法 method2，此时该线程不必重新去申请锁，而是可以直接执行方法 method2。

1.2 读写锁

对资源读取和写入的时候拆分为2部分处理，读的时候可以多线程一起读，写的时候必须同步地写。
读写锁将对一个资源的访问分成了2个锁，如文件，一个读锁和一个写锁。正因为有了读写锁，才使得多个线程之间的读操作不会发生冲突。
ReadWriteLock 就是读写锁，它是一个接口，ReentrantReadWriteLock 实现了这个接口。可以通过 readLock() 获取读锁，通过 writeLock() 获取写锁。

1.3 可中断锁

在等待获取锁过程中可中断。
在Java中，synchronized 不是可中断锁，而 Lock 是可中断锁。
如果某一线程 A 正在执行锁中的代码，另一线程 B 正在等待获取该锁，可能由于等待时间过长，线程 B 不想等待了，想先处理其他事情，我们可以让它中断自己或者在别的线程中中断它，这种就是可中断锁。
Lock接口中的 lockInterruptibly() 方法就体现了Lock的可中断性。

1.4 公平锁

按等待获取锁的线程的等待时间进行获取，等待时间长的具有优先获取锁权利。
非公平锁即无法保证锁的获取是按照请求锁的顺序进行的，这样就可能导致某个或者一些线程永远获取不到锁。
synchronized 是非公平锁，它无法保证等待的线程获取锁的顺序。对于 ReentrantLock 和 ReentrantReadWriteLock，默认情况下是非公平锁，但是可以设置为公平锁。
而公平锁由于有挂起和恢复所以存在一定的开销，因此性能不如非公平锁，所以 ReentrantLock 和 synchronized 默认都是非公平锁的实现方式。

// 无参的构造函数创建了一个非公平锁，用户也可以根据第二个构造函数，设置一个 boolean 类型的值，来决定是否使用公平锁来实现线程的调度。
public ReentrantLock() {
    sync = new NonfairSync(); // 非公平锁
}
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

二、Lock

2.1 Lock 常用方法

public interface Lock {

    /**
     * 用来获取锁，如果锁被其他线程获取，处于等待状态。如果采用Lock，必须主动去释放锁，在发生异常时，不会自动释放锁。
     * 所以，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。
     */
    void lock();

    /**
     * 通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态，可以去做别的事。
     */
    void lockInterruptibly() throws InterruptedException;

    /**
     * 表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false。
     * 这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。
     */
    boolean tryLock();

    /**
     * 与tryLock类似，只不过是有等待时间，在等待时间内获取到锁返回true，超时返回false。
     */
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    /**
     * 释放锁，在finally 语句块中执行。
     */
    void unlock();
}

Demo：

public class LockTest {
    private Lock lock = new ReentrantLock();

    /**
     * 测试 lock
     * 结果：
     * 线程名t2获得了锁
     * 线程名t2释放了锁
     * 线程名t1获得了锁
     * 线程名t1释放了锁
     */
    private void method(Thread thread){
        lock.lock();
        try {
            System.out.println("线程名"+thread.getName() + "获得了锁");
        }catch(Exception e){
            e.printStackTrace();
        } finally {
            lock.unlock();
            System.out.println("线程名"+thread.getName() + "释放了锁");
        }
    }

    /**
     * 测试 tryLock()
     * 结果：
     * 我是t2有人占着锁，我就不要啦
     * 线程名t1获得了锁
     * 线程名t1释放了锁
     */
    private void method2(Thread thread){

        if(lock.tryLock()){
            try {
                System.out.println("线程名"+thread.getName() + "获得了锁");
            }catch(Exception e){
                e.printStackTrace();
            } finally {
                System.out.println("线程名"+thread.getName() + "释放了锁");
                lock.unlock();
            }
        }else{
            System.out.println("我是"+Thread.currentThread().getName()+"有人占着锁，我就不要啦");
        }
    }


    public static void main(String[] args) {
        LockTest lockTest = new LockTest();

        //线程1
        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                lockTest.method2(Thread.currentThread());
            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                lockTest.method2(Thread.currentThread());
            }
        }, "t2");

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

2.2 synchronized 和 lock 的对比

Lock 是一个接口，而 synchronized 是Java中的关键字，synchronized 是内置的语言实现；
synchronized 在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而 Lock 在发生异常时，如果没有主动通过 unLock() 去释放锁，则很可能造成死锁现象，因此使用 Lock 时需要在 finally 块中释放锁；
ReentrantLock 可设置为公平锁，而 synchronized 却不行；
Lock 可以让等待锁的线程响应中断，而 synchronized 却不行，使用 synchronized 时，等待的线程会一直等待下去，不能够响应中断；
通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到，lock 相比 synchronized 更加灵活；
Lock 有多个子类，功能较为丰富。