三、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 有多个子类，功能较为丰富。