2. LOCK接口

已于 2022-08-23 00:11:46 修改
阅读量48 收藏
点赞数
分类专栏： JUC 文章标签： jvm
于 2022-08-19 13:02:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32498953/article/details/126422822
版权

2. LOCK接口

2.1 Synchronized

2.1.1 Synchronized关键字

synchronized 是一个Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

  1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；

  2. 修饰一个方法，被修饰的方法被称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；

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

  3. 修饰一个静态的方法，其作用范围是整个静态方法，作用的对象是这个类的所有对象。

  4. 修饰一个类，其作用范围是synchronized后面括号括起来的部分，作用主要的对象是这个类的所有对象。

2.12 售票案例

class Ticket {
    /**
     * 票数
     */
    private int number = 30;

    /**
     * 操作方法：是否有票
     */
    public synchronized void sale() {
        // 判断是否有票
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + " ：卖出前：" + (number--) + "剩下：" + number);
        }
    }
}

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

1. 获取锁的线程执行完了该代码块，然后线程释放对锁的占有；
2. 线程执行发生异常，此时JVM会让线程自动释放锁；

 那么如果这个获取锁的线程由于要等待IO或者其他原因(比如调用sleep方法)被阻塞了，但是又没有释放锁，其他线程只能干巴巴地等待，试想一下，这么多影响程序执行效率。

 因此就需要有一种机制可以不让等待的线程一直无期限等待下去（比如只等待一定的时间或者能够响应中断）,通过Lock就可以办到。

2.2 什么是LOCK

 Lock锁实现提供了比使用同步方法和语句可以获得更广泛的锁操作。它们允许更灵活的结构，可能具有非常不同的属性，并且可能支持多个关联条件对象。Lock提供了synchronized更多的功能。

2.2.1 LOCK与Synchronized区别

  • LOCK不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。LOCK是一个类，通过这个类可以实现同步访问；

  • LOCK和sychronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchroized方法或者 synchronized代码块执行完后，系统会自动让线程释放对锁的占用；而LOCK则必须要用户去手动释放锁，如果没有主动是否锁，就有可能导致死锁现象。

2.2.2 LOCK 接口

public interface Lock {

    void lock();

    boolean tryLock();

    boolean tryLock(long time, TimeUnit unit) throwsInterruptedException;

    void unlock();

    Condition newCondition();
}

2.2.3 Condition

  关键字synchronized与wait()/notiy() 这两个方法一起使用可以实现等待/通知模式，Lock锁的newContition()方法返回Condition对象，Condition类也可以实现等待/通知模式。

 用notify()通知时，JVM会随机唤醒某个等待的线程，使用Condition类可以进行选择性通知，Condition比较常用的两个方法：

  • await() 会使用当前线程等待，同时释放锁，当其他线程调用signal()时，线程会重新获得锁并继续执行。

  • signal() 用户唤醒一个等待的线程。

    注意： 在调用Condition的await()/signal() 方法前，也需要线程持有相关的LOCK锁，调用await() 后线程会释放这个锁，在singal() 调用后会从当前Condition 对象等待队列中，唤醒一个线程，唤醒的线程尝试获得锁，一旦获得锁成功就继续执行。

public class ConditionTest01 {
    /**
     * 定义锁
     */
    static Lock lock = new ReentrantLock();
    /**
     * 获得Condition对象
     */
    static Condition condition = lock.newCondition();

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            lock.lock();
            try {
                System.out.println("method lock");
                condition.await();
                System.out.println("method await");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
                System.out.println("method unlock");
            }
        }).start();
        Thread.sleep(3000);
        lock.lock();
        try {
            condition.signal();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }

    }
}

/**
 * 多个Condition实现通知部分线程，使用更灵活
 */
public class ConditionTest02 {
    static class Service {
        /**
         * 定义锁对象
         */
        private ReentrantLock lock = new ReentrantLock();
        /**
         * 定义两个Condition对象
         */
        private Condition conditionA = lock.newCondition();
        private Condition conditionB = lock.newCondition();

        /**
         * 定义方法，使用conditionA对象
         */
        public void waitMethodA() {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "begin A wait" + System.currentTimeMillis());
                conditionA.await();
                System.out.println(Thread.currentThread().getName() + "end A wait" + System.currentTimeMillis());
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
            }
        }

        /**
         * 定义方法，使用conditionB对象
         */
        public void waitMethodB() {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "begin B wait" + System.currentTimeMillis());
                conditionB.await();
                System.out.println(Thread.currentThread().getName() + "end B wait" + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

        /**
         * 定义方法唤醒conditionA对象上的等待
         */
        public void signalA() {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "sigal A start time" + System.currentTimeMillis());
                conditionA.signal();
                System.out.println(Thread.currentThread().getName() + "sigal A end time" + System.currentTimeMillis());
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

        public void signalB() {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "sigal B start time" + System.currentTimeMillis());
                conditionA.signal();
                System.out.println(Thread.currentThread().getName() + "sigal B end time" + System.currentTimeMillis());
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();
        new Thread(() -> {
            service.waitMethodA();
        }).start();

        new Thread(() -> {
            service.waitMethodB();
        }).start();

        Thread.sleep(3000);
        // 唤醒conditionB对象上的等待，conditionA上的等待继续
        service.signalB();
    }
}

2.3 ReentrantLock

ReentrantLock，意思是，“可重入锁”，ReentranLock是唯一实现Lock接口的类，并且ReentranLock提供了更多的方法。

public class ReentrantLockTest {
    private ArrayList<Integer> arrayList = new ArrayList<>();

    public static void main(String[] args) throws InterruptedException {
        ReentrantLockTest reentrantLockTest = new ReentrantLockTest();
        new Thread(() -> {
            reentrantLockTest.insert(Thread.currentThread());
        }, "AA").start();
        new Thread(() -> {
            reentrantLockTest.insert(Thread.currentThread());
        }, "BB").start();

    }

    public void insert(Thread thread) {
        Lock lock = new ReentrantLock();
        lock.lock();
        try {
            System.out.println(thread.getName() + "得到了锁");
            for (int i = 0; i < 5; i++) {
                arrayList.add(i);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
            System.out.println(thread.getName() + "释放锁");
        }
    }
}

2.4 ReadWriteLock

ReadWriteLock也是一个接口，在它里面只有定义了两个方法。

public interface ReadWriteLock {

    Lock readLock();

    Lock writeLock();
}

  一个用来读取锁，一个用来获取写锁。也就说将读写操作分开，分成2个锁分配给线程可以使多个线程同时进行读操作。ReentrantReadWriteLock 实现了ReadWriteLock接口。

  ReentrantReadWriteLock里面提供了很多丰富的方法，不过最主要的有两个方法：readLock()和writeLock() 用来获取读锁和写锁。

 下面通过几个例子来看看ReentranReadWriteLock具体方法。

 假如有多个线程要同时进行读操作的话，先看下synchronized达到的效果：

public class SynchronizedTest {


    public static void main(String[] args) {
        SynchronizedTest synchronizedTest = new SynchronizedTest();

        new Thread(() -> {
            synchronizedTest.get(Thread.currentThread());
        }).start();

        new Thread(() -> {
            synchronizedTest.get(Thread.currentThread());
        }).start();
    }

    public synchronized void get(Thread thread) {
        long start = System.currentTimeMillis();
        while (System.currentTimeMillis() - start <= 1) {
            System.out.println(thread.getName() + "正在进行读操作");
        }
        System.out.println(thread.getName() + "读操作完毕");
    }
}

结果：

Thread-0正在进行读操作
Thread-0正在进行读操作
...
Thread-0读操作完毕
Thread-1正在进行读操作
Thread-1正在进行读操作
...
Thread-1读操作完毕

使用ReentrantReadWriteLock重写

public class ReentrantReadWriteLockTest {
    private ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();

    public static void main(String[] args) {
        ReentrantReadWriteLockTest reentrantReadWriteLockTest = new ReentrantReadWriteLockTest();
        new Thread(() -> {
            reentrantReadWriteLockTest.get(Thread.currentThread());
        }).start();

        new Thread(() -> {
            reentrantReadWriteLockTest.get(Thread.currentThread());
        }).start();
    }

    public void get(Thread thread) {
        reentrantReadWriteLock.readLock().lock();
        try {
            long start = System.currentTimeMillis();
            while (System.currentTimeMillis() - start <= 1) {
                System.out.println(thread.getName() + "正在进行读操作");
            }
            System.out.println(thread.getName() + "读操作完毕");
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            reentrantReadWriteLock.readLock().unlock();
        }
    }
}

结果

...
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
...
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1读操作完毕
Thread-0读操作完毕

 说明thread1和tread2在同时操作进行读操作，这样就大大提升了读操作的效率。

注意

  1. 如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。
  2. 如果有一个线程已经占用写锁，则此时其他线程如果申请写锁或者读锁，这申请的线程写锁或者读锁，则申请线程会一直等待释放写锁。

2.6 小结

  1. LOCK 和synchronized是Java中的关键字，synchronized是内置的语言实现。

  2. synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock() 去释放锁，则很可能造成锁死现象，因此使用Lock时需要在finally块中释放锁。

  3. Lock可以让等待锁的线程中断，而synchronized却不行，使用synchronized时，等待的线程会等待下去，不能够响应中断；

  4. 通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。

  5. Lock 可以提高多个线程进行读操作。

    在性能上来说，如果竞争资源不激烈，两者性能是差不多的，而当竞争资源非常激烈时(既有大量线程同时竞争)，此时Lock的性能要远远优于synchronized。

兰朝晖
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 并发编程详解：Lock 接口及其实现 ReentrantLock
微笑听雨
05-31 5281
Lock接口 提供了比 synchronized 关键字更灵活和丰富的锁机制。是 Lock 接口的一个实现，支持可重入、可选择的公平锁以及提供 Condition 对象来实现复杂的线程间协调。使用 ReentrantLock 可以提高多线程环境下程序的并发性能和可控性，适用于需要复杂锁控制的场景。通过合理使用 Lock 接口及其实现 ReentrantLock，可以更有效地管理并发，确保线程安全，提高程序的可靠性和性能。
深入Synchronized和java.util.concurrent.locks.Lock的区别详解
09-05
而Lock接口，它是Java并发包（java.util.concurrent.locks）的一部分，提供了比synchronized更高级和灵活的锁操作。Lock接口的实现类，如ReentrantLock，提供了尝试获取锁、可中断的锁等待、定时锁等待等功能。使用...
lock.lock()使用，与synchronized对比
技匠而已
02-18 3184
Lock锁 锁实现提供了比使用synchronized方法和语句更广泛的锁操作。它们允许更灵活的结构，可能有不同的属性，可能支持多个关联的Condition对象。 锁是用于控制多个线程对共享资源的访问的工具。 通常，锁提供对共享资源的独占访问:一次只有一个线程可以获得锁，并且所有访问共享资源的访问都需要先获得锁。但是，有些锁可能允许并发访问共享资源。例如readwritellock的读锁。 同步方法或语句的使用提供了对每个对象关联的隐式监视器锁的访问，但强制所有锁的获取和释放都以块结构的方式进行:当多个锁
java.util.concurrent.locks.Lock锁
专注写bug
03-09 978
文章目录Lock(锁)synchronized和Lock的区别 Lock(锁) 先看一个简单的卖票例子(无锁)： package demo1; public class SaleTicketTest { public static void main(String[] args) { // lambda 表达式 ()表示run() 其中"()"中可以写明参数 ，->{} 表示 run后的代码块{} // 支持 lambda 表达式，必须是接口上有 @Funct
package.json.lock 文件
extendworld的博客
12-05 2039
package.json.lock: 由于^的向后兼容的特性，在package.json里面是^8.1.3, 但是在执行npm install的时候，在保证大的版本号不变的情况下下载的可能是8.1.5版本，这个时候node_modules中存放的就是这个版本的模块。npm 包有一个规则就是同一个大版本号的包的接口符合兼容的要求，所以可以下载比现在版本号大的版本进行安装。但是npm包的世界实在太大，所
Lock接口与Synchronized关键字的区别
01-23 1320
首先，Lock接口与Synchronized关键字都能提供相同的同步功能，只是Lock接口在使用时，需要显示地获取和释放锁。从而使Lock接口没有像Synchronized关键字那样隐式获取锁来的便捷，然而，Lock接口可以拥有获取锁和释放锁的可操作性、可中断的获取锁以及超时获取锁等多种Synchronized关键字不具备的特性。具体如下： 特性 描述 尝试非阻塞地获取锁 当前线程尝试
lock.lock() 写在 try 代码块内部行吗？
To be a great coder
08-05 9239
熟悉 Java 并发的朋友，想必都会对 Lock 接口很熟悉，它是从 JDK1.5 以后提供给开发者的另一种线程同步的方式。下面是使用它的一个具体实现类：ReentrantLock 进行加锁解锁的一个小例子： Lock lock = new ReentrantLock(); lock.lock(); try { // access the resource protected by t...
MAVEN依赖jar版本下载错误：xxx.pom.part.lock (文件名、目录名或卷标语法不正确。)
nakey_xie的博客
03-04 4728
maven依赖不了新版本jar
Lock接口的介绍及使用
babylove_BaLe的博客
10-17 1727
一、Lock的介绍我们知道，在Java中锁的实现可以由synchronized关键字来完成，但在Java5之后，出现了一种新的方式来实现——Lock接口。那么为什么提出这种新的方式呢？ 在多线程的情况下，当一段代码被synchronized修饰之后，同一时刻只能被一个线程访问，其他线程都必须等到该线程释放锁之后才能有机会获取锁访问这段代码，占用锁的线程只有在两种情况下才能释放锁： 线程执行完了
java中的Lock锁
热门推荐
纯洁的小魔鬼
07-15 1万+
一. 概述 Lock 是 java.util.concurrent.locks 包 下的接口，Lock 实现提供了比 synchronized 关键字 更广泛的锁操作，它能以更优雅的方式处理线程同步问题。Lock提供了比synchronized更多的功能。 1.Lock和ReadWriteLock是两大锁的根接口，Lock代表实现类是ReentrantLock（可重入锁），ReadWriteLock（读写锁）的代表实现类是ReentrantReadWriteLock。 　2.Lock 接口支...
lock接口的lock()和tryLock()区别
小雨的光的博客
11-09 8090
正文开始前先把lock接口的源码摆出来（精简后的，特意保留了部分注释） public interface Lock { /** * Acquires the lock. */ void lock(); /** * Acquires the lock unless the current thread is * {@linkpl...
Java Lock接口实现原理及实例解析
08-19
Java Lock接口实现原理及实例解析 Java Lock接口是Java concurrency API中的一部分，提供了比synchronized关键字更强大的锁操作。下面是对Java Lock接口实现原理及实例解析的详细介绍： 首先，Lock接口是Java ...
Java synchronized关键字和Lock接口实现原理
08-25
Java synchronized关键字和Lock接口实现原理 Java 中的 synchronized 关键字和 Lock 接口是两种常用的线程同步机制，它们都可以用来解决并发问题。下面我们将详细介绍 synchronized 关键字和 Lock 接口的实现原理。...
java Lock接口详解及实例代码
08-31
Java Lock接口是Java并发编程中一个重要的组成部分，它提供了一种更为灵活的锁机制，相比传统的`synchronized`关键字，Lock接口允许我们进行更细粒度的控制，包括可中断的锁等待、尝试获取锁以及定时等待等。...
Lock接口与synchronized关键字
04-19
2. **Lock接口**： - 更底层的同步机制，提供了更丰富的功能。 - 需要显式地获取和释放锁，通常通过其实现类如`ReentrantLock`来使用。 - 使用时需调用`lock()`方法获取锁，通过`unlock()`方法释放锁。 - 适用于...
【JVM基础11】——垃圾回收-说一下JVM的分代回收？
weixin_44382896的博客
08-04 1048
说一下JVM的分代回收？
JVM知识总结（内存结构）
月伴飞鱼
08-04 598
在JVM中，一个类的方法名、类名、修饰符、返回值等等都是一系列的符号，而这些符号都是一个个的常量，存储在常量池中。由于类的元数据分配在本地内存中，元空间的最大可分配空间就是系统可用内存空间，不会遇到永久代存在时的内存溢出错误。如果是对象类型，局部变量表中存放的是堆给对象分配的内存地址，也就是指针，而不是对象直接存在局部变量表中。JDK 1.8 开始，移除永久代，并把方法区移至元空间，它位于本地内存中，而不是虚拟机内存中。它的大小不容易确定，因为这其中有很多影响因素，比如类的总数，常量池的大小和方法数量等，
JVM的组成 -- 字节码文件
gghhb12的博客
08-04 500
作用是在Java代码中获取类的信息以及存储的静态字段的数据(JDK8之后)（JAVA编写）验证字节码信息是否满足《Java虚拟机规范》，比如对头魔数的校验(ca fe ba be)、版本号等的校验、元信息的校验(必须有父类)、指令是否正确等。该阶段会执行方法中的clinit方法中的部分指令，clinit方法是与JAVA代码中的方法顺序执行一致。常量池中的数据都有一个编号，编号从1开始，在字段或字节码指令中通过编号可以快速的找到对应的数据。将常量池中的符号引用替换成指向内存的直接引用。
Java面试题--JVM大厂篇之Parallel GC与其他垃圾回收器的对比与选择
最新发布
青云交的博客
08-04 233
选择一款合适的垃圾回收器，并充分理解其优缺点，是每一个Java工程师必须掌握的技能。在实际应用中，结合你的场景需求，选择最合适的GC，这不仅能显著提升你的应用性能，也能让你在团队中成为性能优化的专家。选择错误的垃圾回收器，可能会导致频繁的停顿、性能下降，甚至系统崩溃。这就像你有一辆豪车，但汽油却是劣质的，你感受到的只会是频繁熄火带来的无尽困扰。Java的世界就如同一个战场，垃圾回收器就是你的武器，选择好你的武器，你才能在这个战场中所向披靡。：几乎可以做到毫秒级的暂停时间，非常适合对延迟敏感的应用。
java lock.lock实例代码
04-29
Java中的Lock接口提供了一种更加灵活和强大的机制来控制线程的访问同步代码块。在使用Lock接口时，需要先创建一个Lock对象，然后再调用它的lock和unlock方法来控制访问同步代码块。 下面是Java中Lock接口的一个实例...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值