26.Java Lock 接口（synchronized 关键字回顾、可重入锁快速入门、Lock 对比 synchronized）

一、synchronized 关键字

1、synchronized 关键字回顾

synchronized 是 Java 中的关键字，是一种同步锁，它修饰的对象有以下几种
- 修饰一个类：其作用的范围是 synchronized 后面括号括起来的部分，作用的对象是这个类的所有对象
- 修饰一个方法：被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象
- 修改一个静态方法：其作用的范围是整个静态方法，作用的对象是这个类的所有对象
- 修饰一个代码块：被修饰的代码块称为同步语句块，其作用的范围是大括号（{}）括起来的代码块，作用的对象是调用这个代码块的对象
虽然可以使用 synchronized 关键字来修饰方法，但 synchronized 关键字并不属于方法定义的一部分，因此，synchronized 关键字不能被继承，如果在父类中的某个方法使用了 synchronized 关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上 synchronized 关键字才可以，当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了
如果一个代码块被 synchronized 关键字修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况
- 获取锁的线程执行完了该代码块，然后线程释放锁
- 线程执行发生异常，JVM 会让线程自动释放锁
如果某个获取锁的线程由于要等待 IO 或者其他原因（比如调用 sleep 方法）被阻塞了，但是又没有释放锁，其他线程便只能等待

2、多线程编程步骤（上）

创建资源类，在资源类中创建属性和操作方法
创建多个线程，调用资源类中的操作方法

3、售票案例

（1）资源类

Ticket 类

java 复制代码

package com.my.lock;

public class Ticket {

    // 票数
    private int number = 40;

    // 售票方法
    public synchronized void sell() {
        if (number > 0) {
            number--;
            System.out.println(Thread.currentThread().getName() + " 卖出了一张票 剩下 " + number + " 张");
        }
    }
}

（2）多线程测试

SellTicket 类

java 复制代码

package com.my.lock;

public class SellTicket {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();

        // 创建并运行三个售票线程
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticket.sell();
            }
        }, "AA");
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticket.sell();
            }
        }, "BB");
        Thread thread3 = new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticket.sell();
            }
        }, "CC");

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

二、Lock 接口

1、概述

Lock 提供了比使用同步方法和语句可以获得的更广泛的锁操作，它允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的 Condition 对象

java 复制代码

public interface Lock {

    void lock();

    void lockInterruptibly() throws InterruptedException;

    boolean tryLock();

    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    void unlock();

    Condition newCondition();
}

Lock 接口的实现类有
- ReentrantLock：可重入锁
- ReentrantReadWriteLock.ReadLock，ReentrantReadWriteLock.WriteLock：读写锁

2、可重入锁快速入门

可重入锁，ReentrantLock 类，Lock 接口实现类

（1）资源类

LTicket 类

java 复制代码

package com.my.lock;

import java.util.concurrent.locks.ReentrantLock;

public class LTicket {

    // 票数
    private int number = 40;

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

    // 售票方法
    public synchronized void sell() {

        // 上锁
        lock.lock();

        try {
            if (number > 0) {
                number--;
                System.out.println(Thread.currentThread().getName() + " 卖出了一张票 剩下 " + number + " 张");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {

            // 解锁
            lock.unlock();
        }
    }
}

（2）多线程测试

LSellTicket 类

java 复制代码

package com.my.lock;

public class LSellTicket {
    public static void main(String[] args) {
        LTicket lTicket = new LTicket();

        // 创建并运行三个售票线程
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                lTicket.sell();
            }
        }, "AA");
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                lTicket.sell();
            }
        }, "BB");
        Thread thread3 = new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                lTicket.sell();
            }
        }, "CC");

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

3、Lock 对比 synchronized

Lock 不是 Java 内置的，synchronized 是 Java 的关键字，因此是内置的，Lock 是一个接口，通过这个接口可以实现同步
采用 synchronized 不需要去手动释放锁，当 synchronized 方法或者 synchronized 代码块执行完之后，系统会自动让线程释放对锁的占用，而 Lock 则必须要用户去手动释放锁，如果没有手动释放锁，就有可能导致出现死锁现象
Lock 可以让等待锁的线程响应中断，而 synchronized 却不行，使用synchronized 时，等待的线程会一直等待下去，不能够响应中断
通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到
Lock可以提高多个线程进行读操作的效率
在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时 Lock 的性能要远远优于 synchronized