Java中的Lock接口，比起synchronized，优势在哪里？

最新推荐文章于 2025-06-04 09:14:05 发布
原创 最新推荐文章于 2025-06-04 09:14:05 发布
· 2.7k 阅读 · 13 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

如果需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写，一次来保证它的完整性，该如何实现？

Lock接口在多线程和并发编程中最大的优势是它们分别为读和写提供了锁。

       读写锁ReentrantReadWriteLock，它表示有两个锁，一个是读操作相关的锁，也称为共享锁；另一个是写操作相关的锁，也叫排他锁。“读写”、“写读”、和 “写写“ 都是互斥的；而 ”读读“ 是异步的，非互斥的。

即：多个线程可以同时进行读取操作，但是同一时刻只允许一个线程进行写入操作。

本题目就可以使用读写锁ReentrantReadWriteLock来实现。

“读读共享”例子:

package com.learn.ReentrantReadWriteLockTest;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 读读共享
 */
public class ReadWriteLockTest1 {
    public static void main(String[] args) {
        Service service = new Service();
        ThreadA a = new ThreadA(service);
        a.setName("A");
        ThreadB b = new ThreadB(service);
        b.setName("B");
        a.start();
        b.start();
    }

}
class Service{
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    public void read(){
        try{
            lock.readLock().lock();
            System.out.println("获得读锁："+Thread.currentThread().getName()+" "+System.currentTimeMillis());
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }finally{
            lock.readLock().unlock();
        }
    }
}

class ThreadA extends Thread{
    private Service service;

    public ThreadA(Service service){
        this.service = service;
    }

    @Override
    public void run() {
        super.run();
        service.read();
    }
}

class ThreadB extends Thread{
    private Service service;

    public ThreadB(Service service){
        this.service = service;
    }

    @Override
    public void run() {
        super.run();
        service.read();
    }
}

"写写互斥"例子：

package com.learn.ReentrantReadWriteLockTest;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 写写互斥
 */
public class ReadWriteLockTest2 {
    public static void main(String[] args) {
        Service2 service2 = new Service2();
        ThreadA2 a = new ThreadA2(service2);
        a.setName("A");
        ThreadB2 b = new ThreadB2(service2);
        b.setName("B");
        a.start();
        b.start();
    }

}
class Service2{
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    public void write(){
        try{
            lock.writeLock().lock();
            System.out.println("获得写锁："+Thread.currentThread().getName()+" "+System.currentTimeMillis());
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }finally{
            lock.writeLock().unlock();
        }
    }
}

class ThreadA2 extends Thread{
    private Service2 service;

    public ThreadA2(Service2 service){
        this.service = service;
    }

    @Override
    public void run() {
        super.run();
        service.write();
    }
}

class ThreadB2 extends Thread{
    private Service2 service;

    public ThreadB2(Service2 service){
        this.service = service;
    }

    @Override
    public void run() {
        super.run();
        service.write();
    }
}

“读写互斥”例子：

package com.learn.ReentrantReadWriteLockTest;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 读写互斥
 */
public class ReadWriteLockTest3 {
    public static void main(String[] args) {
        Service3 service3 = new Service3();
        ThreadA3 a = new ThreadA3(service3);
        a.setName("A");
        ThreadB3 b = new ThreadB3(service3);
        b.setName("B");
        b.start();
        a.start();
    }

}
class Service3{
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    public void read(){
        try{
            lock.readLock().lock();
            System.out.println("获得读锁 "+Thread.currentThread().getName()+" "+System.currentTimeMillis());
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }finally{
            lock.readLock().unlock();
        }
    }

    public void write(){
        try{
            lock.writeLock().lock();
            System.out.println("获得写锁 "+Thread.currentThread().getName()+" "+System.currentTimeMillis());
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }finally{
            lock.writeLock().unlock();
        }
    }
}

class ThreadA3 extends Thread{
    private Service3 service;

    public ThreadA3(Service3 service){
        this.service = service;
    }

    @Override
    public void run() {
        super.run();
        service.read();
    }
}

class ThreadB3 extends Thread{
    private Service3 service;

    public ThreadB3(Service3 service){
        this.service = service;
    }

    @Override
    public void run() {
        super.run();
        service.write();
    }
}

“写读互斥”例子：

package com.learn.ReentrantReadWriteLockTest;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 读写互斥
 */
public class ReadWriteLockTest3 {
    public static void main(String[] args) {
        Service3 service3 = new Service3();
        ThreadA3 a = new ThreadA3(service3);
        a.setName("A");
        ThreadB3 b = new ThreadB3(service3);
        b.setName("B");
        b.start();
        a.start();
    }

}
class Service3{
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    public void read(){
        try{
            lock.readLock().lock();
            System.out.println("获得读锁 "+Thread.currentThread().getName()+" "+System.currentTimeMillis());
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }finally{
            lock.readLock().unlock();
        }
    }

    public void write(){
        try{
            lock.writeLock().lock();
            System.out.println("获得写锁 "+Thread.currentThread().getName()+" "+System.currentTimeMillis());
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }finally{
            lock.writeLock().unlock();
        }
    }
}

class ThreadA3 extends Thread{
    private Service3 service;

    public ThreadA3(Service3 service){
        this.service = service;
    }

    @Override
    public void run() {
        super.run();
        service.read();
    }
}

class ThreadB3 extends Thread{
    private Service3 service;

    public ThreadB3(Service3 service){
        this.service = service;
    }

    @Override
    public void run() {
        super.run();
        service.write();
    }
}

如果需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写，一次来保证它的完整性，该如何实现？代码如下：

package com.learn.ReentrantReadWriteLockTest;

import java.util.Random;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockTest5 {
    public static void main(String[] args) {
        ReadWrite readWrite = new ReadWrite();
        //创建3个写线程
        for (int i=0;i<3;i++){
            ThreadWrite write = new ThreadWrite(readWrite,new Random().nextInt(100));
            write.setName("write"+i+":");
            write.start();
        }
        //创建3个读线程
        for (int i=0;i<3;i++){
            ThreadRead read = new ThreadRead(readWrite);
            read.setName("read"+i+":");
            read.start();
        }

    }
}

class ReadWrite{
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private Object data=null;
    public void read(){
        try{
            lock.readLock().lock();
            try {
                System.out.println(Thread.currentThread().getName()+"is ready to read");
                Thread.sleep(new Random().nextInt(100));
                System.out.println(Thread.currentThread().getName()+"have read date "+data);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }finally{
            lock.readLock().unlock();
        }
    }

    public void write(Object data){
        try{
            lock.writeLock().lock();
            try {
                System.out.println(Thread.currentThread().getName()+"is ready to write");
                this.data = data;
                Thread.sleep(new Random().nextInt(100));
                System.out.println(Thread.currentThread().getName()+"have write date "+data);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }finally{
            lock.writeLock().unlock();
        }
    }
}

class ThreadRead extends Thread{
    private ReadWrite readWrite;

    public ThreadRead(ReadWrite readWrite){
        this.readWrite = readWrite;
    }

    @Override
    public void run() {
        super.run();
        //while(true){
            readWrite.read();
        //}

    }
}

class ThreadWrite extends Thread{
    private ReadWrite readWrite;
    private Object data;


    public ThreadWrite(ReadWrite readWrite,Object data){
        this.readWrite = readWrite;
        this.data = data;
    }

    @Override
    public void run() {
        super.run();
        //while(true){
            readWrite.write(data);
        //}
    }
}

Lock 接口比 synchronized 块的优势是什么？你需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写，以此来保持它的完整性，你会怎样去实现它？
学无止境
09-20 359
读操作使用读锁，写操作使用写锁，从而实现了多读单写的缓存策略。这样可以提高并发性能，允许多个线程同时读取缓存，但只允许一个线程进行写操作以维护缓存的一致性。在写操作中获取写锁：在对缓存进行写操作（例如添加、更新或删除数据）时，线程应该获取写锁。这个类提供了读锁和写锁，允许多个线程同时获取读锁，但只允许一个线程获取写锁。接口提供了更多的锁定控制方法，允许你更精细地控制锁定的行为。接口的一些实现类允许你指定锁的公平性，以确保等待时间最长的线程优先获取锁。块中，锁的获取是不公平的，没有公平性选项。
Java并发_第六篇：synchronized的缺陷，Lock的诞生
毛毛的专栏
08-02 1009
文章目录一、前言辨析Lock接口、ReentrantLock类、ReadWriteLock接口、ReentrantReadWriteLock类二、synchronized的缺陷三、java.util.concurrent.Lock包下常用的类3.1 Lock接口及其四个方法的使用3.1.1 Lock接口的lock()3.1.2 Lock接口的tryLock()3.1.2 Lock接口的lockInterruptibly()3.2 ReentrantLock类及其四个方法的使用3.2.1 ReentrantL
在Java中Lock接口比synchronized块的优势是什么？
wzxue1984的博客
09-01 457
尽管Lock接口提供了更多的灵活性和功能，但与synchronized块相比，Lock接口的使用需要手动显示地进行锁的获取和释放，并且多了一些复杂性。显式控制锁的获取和释放：Lock接口提供了显式的lock()方法用于获取锁，并提供了unlock()方法用于释放锁。支持尝试获取锁：Lock接口提供了tryLock()方法，可以尝试获取锁而不会阻塞。支持可中断锁：Lock接口提供了lockInterruptibly()方法，支持在等待获取锁的过程中响应中断请求，使得等待锁的线程可以及时退出等待状态。
synchronized和lock的使用分析（优缺点对比详解）
小东升职记
11-17 5395
1.synchronized 加同步格式： synchronized(需要一个任意的对象(锁)){      代码块中放操作共享数据的代码。 } synchromized缺陷 synchronized是java中的一个关键字，也就是说是java语言的内置的特性。 如果一个代码块被synchronized修饰，当一个线程获取了对应的锁，并执行代码块时，其他线程只能一直等待，等待获取锁的...
面经 - 【多线程】在Java中Lock接口比synchronized块的优势是什么？你需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写，以此来保持它的完整性，你会怎样去实现它？
04-11 990
解析：lock接口在多线程和并发编程中最大的优势是它们为读和写分别提供了锁，它能满足你写像 ConcurrentHashMap这样的高性能数据结构和有条件的阻塞。Java线程面试的问题越来越会根据面试者的回答来提问。我强烈建议在你去参加多线程的面试之前认真读一下Locks，因为当前其大量用于构建电子交易终统的客户端缓存和交易连接空间。Lock读写锁机制可以实现！在Java中Lock接口比synchronized块的优势是什么？ Lock接口最大的优势是为读和写分别提供了锁。 package ...
java中的lock和synchronized
caoliangbo的博客
03-21 268
1、ReentrantLock 拥有Synchronized相同的并发性和内存语义，此外还多了 锁投票，定时锁等候和中断锁等候 线程A和B都要获取对象O的锁定，假设A获取了对象O锁，B将等待A释放对O的锁定， 如果使用 synchronized ，如果A不释放，B将一直等下去，不能被中断 如果 使用ReentrantLock，如果A不释放，可以使B在等待了足够长...
Java多线程的同步：synchronized关键字、Lock接口、volatile关键字
pan_junbiao的博客
05-16 762
Java 多线程同步是解决资源共享冲突的核心机制，主要通过协调线程对共享资源的访问顺序与权限，避免数据不一致和竞态条件。在多线程的环境中，经常会碰到数据的共享问题，即当多线程需要访问同一个资源时，它们需要以某种顺序来确保该资源在某一时刻只能被一个线程使用，否则，程序的运行结果将会是不可预料的，在这种情况下就必须对数据进行同步。例如多个线程同时对同一数据进行写操作。
灵魂大拷问：Lock 到底比 synchronized 强在哪？
最新发布
喵手的博客
06-04 432
我们都知道一个真相，在 Java 里，和Lock都是用于实现线程同步的机制。它们的主要目的是确保多个线程在并发执行时不会对共享资源进行冲突的访问，从而保证数据的一致性。虽然和Lock都能解决多线程的同步问题，但它们在一些特性和使用场景上存在明显的差异。到底有哪些差异呢？我们接着往下看。尽管已经足够满足大部分简单的线程同步需求，但在一些复杂的多线程场景中，Lock提供的更多功能使得它更加灵活和强大。特别是在需要可中断的锁、尝试获取锁、可重入锁、条件变量等功能时，Lock显示出了它的优势。对于复杂的业务逻辑，
锁的艺术：Java并发中的常用锁策略与实践
热门推荐
张彦峰的博客
05-12 169万+
对java锁相关内容进行整理分析：乐观锁 VS 悲观锁+自旋锁 VS 适应性自旋锁+无锁 VS 偏向锁 VS 轻量级锁 VS 重量级锁+公平锁 VS 非公平锁+可重入锁 VS 非可重入锁+独享锁 VS 共享锁
Lock接口和synchronized同步 对比它有什么优势？
xzc的博客
08-30 494
Lock接口比提供了。他们允许。可以具有完全不同的性质，并且 可以支持多个相关类的条件对象它的优势有：1.可以使锁更公平2. 可以使线程在等待所的时候3.可以让线程尝试获取锁，并在无法获取锁的时候立即返回或者等待一段时间4.可以在不同的范围，一不同的顺序获取和释放锁（lock）
Java并发开发：Lock框架详解
程序猿开发日志【学习永无止境】
02-15 544
我们已经知道，synchronized 是java的关键字，是Java的内置特性，在JVM层面实现了对临界资源的同步互斥访问，但 synchronized 粒度有些大，在处理实际问题时存在诸多局限性，比如响应中断等。Lock 提供了比 synchronized更广泛的锁操作，它能以更优雅的方式处理线程同步问题。本文以synchronized与Lock的对比为切入点，对Java中的Lock框架的枝干
lock和synchronized的区别以及优点缺点
qq_39275467的博客
06-17 1511
1.synchronized和lock 都有可重入性. 2.synchronized和lock 都可以知道线程是否持有了锁(看到很多文章说只有lock可以判断是否获取到锁,其实是错误的,synchronized也可以获取. synchronized 用Thread.holdsLock来判断). 3.synchronized在进入锁池后,会不停得等待直到获取锁对象,无法中断,是真爱.而lock可以设置等待时间停止锁竞争. public boolean tryLock(long timeout, TimeUni
在Java中Lock接口比synchronized块的优势是什么
guo_zifeng的专栏
12-18 2404
http://blog.csdn.net/fw0124/article/details/6672522 http://www.cnblogs.com/dolphin0520/p/3923167.html
java lock相对于synchronized的优势
creator123123的博客
10-22 442
java lock相对于synchronized的优势 https://www.cnblogs.com/dolphin0520/p/3923167.html   posted on 2018-10-22 11:30 CreatorKou 阅读(...) 评论(...) 编辑 收藏 ...
Lock 接口和synchronized
Flying_Fish_roe的博客
10-13 1054
Lock是 Java 5 引入的一个接口，位于包中，旨在替代关键字，为线程同步提供更高级别的控制。Lock接口的常用实现类是，它提供了可重入的互斥锁，并支持多种高级功能，例如公平锁、非公平锁、可中断锁、条件等待等。相比Lock更高的灵活性：提供了多种锁机制，如公平锁和非公平锁。支持可中断锁：在等待获取锁时，可以响应中断信号。支持定时锁：允许在尝试获取锁时设定超时时间。更丰富的 API：提供条件变量Condition支持，实现更复杂的线程间通信。更细粒度的锁获取和释放控制。
synchronized和Lock比较
weixin_45115654的博客
08-29 417
Synchronized和Lock都是可重入锁，但synchronized不是可中断锁，而Lock是可中断锁。 Synchronized底层：使用指令码方式来控制锁的，映射成字节码指令就是增加两个指令：monitorenter和monitorexit。当线程执行遇到monitorenter指令时会尝试获取内置锁，如果获取锁则锁计数器加1，如果获取锁则阻塞；当线程遇到monitorxit指令是则锁计数器-1，如果计数器为0则释放锁。 Lock的底层：是CAS乐观锁，依赖AbstractQueued..
Lock和synchronized比较
qq_37191690的博客
03-06 589
我们已经知道，synchronized 是Java的关键字，是Java的内置特性，在JVM层面实现了对临界资源的同步互斥访问，但 synchronized 粒度有些大，在处理实际问题时存在诸多局限性，比如响应中断等。Lock 提供了比 synchronized更广泛的锁操作，它能以更优雅的方式处理线程同步问题。本文以synchronized与Lock的对比为切入点，对Java中的Lock框架的枝干...
Lock与synchronized 的区别
djp567的博客
02-02 416
实现同步发的方法：有synchronized；jdk5之后有java.util.concurrent.locks的Lock Lock与synchronized 的区别: 概念： 如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况： 　　1）获取锁的线程执行
lock锁和synchronized锁
02-20
### Java并发编程中的Lock接口与synchronized关键字 #### 锁机制的基础概念 Java提供了多种方式来处理线程同步问题，`synchronized` 关键字自早期版本就已存在并支持线程同步操作[^1]。另一方面，`java.util.concurrent.locks.Lock` 接口是在较新的Java版本中引入的一种更灵活的锁定抽象。 #### synchronized的关键特性 `synchronized` 是一种内置的语言级功能，用于控制多个线程对共享资源的访问。当方法或代码块被声明为 `synchronized` 时，同一时刻只有一个线程可以执行该部分代码。这确保了即使有其他线程试图进入同一个对象上的另一个 `synchronized` 方法或代码段，也必须等待当前持有锁的线程完成其工作并释放锁之后才能继续。 此外，在任何线程进入由相同监视器保护的 `synchronized` 块之前，都会看到所有先前受此监视器保护修改的效果[^2]。 ```java public class Counter { private int count; public synchronized void increment() { this.count++; } } ``` #### Lock接口的优势 相比之下，`Lock` 接口提供了一种显式的加锁/解锁机制，并允许更加复杂的锁定协议。通过使用 `Lock` 实现类（如 ReentrantLock），可以获得比传统 `synchronized` 更强大的功能： - **可中断的获取锁**：尝试获得锁的过程中如果接收到中断信号，则立即返回失败而不是一直阻塞下去。 - **超时获取锁**：可以在指定时间内尝试获取锁；若未能成功则放弃而不至于无限期挂起。 - **公平性选项**：可以选择是否按照请求顺序授予锁给下一个等待者。 - **多条件变量的支持**：一个 `Lock` 可关联多个不同的条件实例，从而实现更为精细的通知逻辑。 下面是一个简单的例子展示了如何利用 `ReentrantLock` 来替代传统的 `synchronized` 方式： ```java import java.util.concurrent.locks.ReentrantLock; import java.util.concurrent.locks.Condition; class BoundedBuffer { final ReentrantLock lock = new ReentrantLock(); final Condition notFull = lock.newCondition(); final Condition notEmpty = lock.newCondition(); final Object[] items = new Object[100]; int putptr, takeptr, count; public void put(Object x) throws InterruptedException { lock.lock(); try { while (count == items.length) notFull.await(); items[putptr] = x; if (++putptr == items.length) putptr = 0; ++count; notEmpty.signal(); } finally { lock.unlock(); } } public Object take() throws InterruptedException { lock.lock(); try { while (count == 0) notEmpty.await(); Object x = items[takeptr]; if (++takeptr == items.length) takeptr = 0; --count; notFull.signal(); return x; } finally { lock.unlock(); } } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值