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

一、synchronized 关键字

1、synchronized 关键字回顾
  • synchronized 是 Java 中的关键字,是一种同步锁,它修饰的对象有以下几种

    • 修饰一个类:其作用的范围是 synchronized 后面括号括起来的部分,作用的对象是这个类的所有对象

    • 修饰一个方法:被修饰的方法称为同步方法,其作用的范围是整个方法,作用的对象是调用这个方法的对象

    • 修改一个静态方法:其作用的范围是整个静态方法,作用的对象是这个类的所有对象

    • 修饰一个代码块:被修饰的代码块称为同步语句块,其作用的范围是大括号({})括起来的代码块,作用的对象是调用这个代码块的对象

  • 虽然可以使用 synchronized 关键字来修饰方法,但 synchronized 关键字并不属于方法定义的一部分,因此,synchronized 关键字不能被继承,如果在父类中的某个方法使用了 synchronized 关键字,而在子类中覆盖了这个方法,在子类中的这个方法默认情况下并不是同步的,而必须显式地在子类的这个方法中加上 synchronized 关键字才可以,当然,还可以在子类方法中调用父类中相应的方法,这样虽然子类中的方法不是同步的,但子类调用了父类的同步方法,因此,子类的方法也就相当于同步了

  • 如果一个代码块被 synchronized 关键字修饰了,当一个线程获取了对应的锁,并执行该代码块时,其他线程便只能一直等待,等待获取锁的线程释放锁,而这里获取锁的线程释放锁只会有两种情况

    • 获取锁的线程执行完了该代码块,然后线程释放锁

    • 线程执行发生异常,JVM 会让线程自动释放锁

  • 如果某个获取锁的线程由于要等待 IO 或者其他原因(比如调用 sleep 方法)被阻塞了,但是又没有释放锁,其他线程便只能等待

2、多线程编程步骤(上)
  1. 创建资源类,在资源类中创建属性和操作方法

  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

相关推荐
yngsqq4 分钟前
批量改CAD图层颜色——CAD c#二次开发
开发语言·数据库·c#
顾林海5 分钟前
深度解析LinkedList工作原理
android·java·面试
uhakadotcom5 分钟前
Guava 简介:让 Java 开发更高效
后端·面试·github
茶本无香5 分钟前
CompletableFuture:整合、超时、完成事件与批量处理
java·超时·future·completable·completion·任务整合
Hello.Reader8 分钟前
迭代器介绍与使用(四十一)
开发语言·c++
雷渊10 分钟前
分析@Autowired和@Resource的使用场景
java·后端·面试
whisperrr.10 分钟前
【spring02】Spring 管理 Bean-IOC,基于 XML 配置 bean
xml·java·spring
Cloud_.16 分钟前
Spring Boot整合Elasticsearch
java·spring boot·后端·elasticsearch·es
储悠然19 分钟前
Lisp语言的物联网数据分析
开发语言·后端·golang
ghostmen27 分钟前
基于Spring Boot的HTTP请求签名验证实现解析
java·spring·http