Lock、synchronized和ReadWriteLock的区别和联系以及Condition

本文介绍了Java中synchronized、Lock及ReadWriteLock三种线程同步机制的特点与区别,包括各自的适用场景、优缺点以及实现方式。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

在java多线程编程中,可能我们经常会遇到线程同步的问题,可以使用synchronized或者Lock和ReadWriteLock去控制同步锁,他们都能实现线程的同步,下面来分析下这几种方式的区别:

  • 1.synchronized

它可以锁住一个方法或者一段代码块,伪代码如下:

//锁住方法
public synchronized void test(){
	doSomething...
} 

//锁住代码块
public synchronized void test(){
	doSomething...
	
	synchronized( any object ){
			锁住的代码块
	}

} 

有多个线程ThreadA、ThreadB…ThreadN等,它们同时去执行一段被synchronized修饰的代码块,如果这里ThreadB抢到了同步锁,那么其他的线程都必须等待,ThreadB只有两种情况下会释放锁:

1)ThreadB执行完了这段代码块,这个锁就会被释放;
2)当ThreadB执行这段代码块抛出异常的时候,jvm虚拟机也会释放这个锁。

如果ThreadB执行时间特别长,那么其他的线程就会一直等待,这样会照成很大的资源浪费,并且没有效率。

  • 2.Lock

它就规避了synchronized的缺点,它是一个接口,里面有如下四个锁方法和一个解锁方法

public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
}

Lock有一个实现类:ReentrantLock,它实现了Lock里面的方法,但是使用Lock的时候必须注意它不会像synchronized执行完成之后或者抛出异常之后自动释放锁,而是需要你主动释放锁,所以我们必须在使用Lock的时候加上try{}catch{}finally{}块,并且在finally中释放占用的锁资源。

Lock和synchronized最大的区别就是当使用synchronized,一个线程抢占到锁资源,其他线程必须像SB一样得等待;而使用Lock,一个线程抢占到锁资源,其他的线程可以不等待或者设置等待时间,实在抢不到可以去做其他的业务逻辑。

1)lock()这个方法用来获取锁,如果已经被其他线程抢占则等待,最后需要自己释放资源,伪代码如下:

Lock lock = new ReentrantLock();
//线程1
new Thread(){
	run(){
		dosomething...
		lock.lock();
		try{
			dosomething...
		}catch(Exception e){
			catch exception...
		}finally{
			lock.unlock();
		}
	}
}.start();

//线程2
new Thread(){
	run(){
		dosomething...
		lock.lock();
		try{
			dosomething...
		}catch(Exception e){
			catch exception...
		}finally{
			lock.unlock();
		}
	}
}.start();

2)tryLock()这个方法是当前线程去主动尝试获取锁资源,如果获取成功会有个返回值true,失败即返回false。这样的话拿到锁的线程会去执行锁住的资源,而没拿到资源的会马上返回false不会等待,伪代码如下:

Lock lock = new ReentrantLock();
//线程1
new Thread(){
	run(){
		dosomething...
		boolean flag = lock.tryLock();
		if(flag ){
			try{
				dosomething...
			}catch(Exception e){
				catch exception...
			}finally{
				lock.unlock();
			}
		}
	}
}.start();
//线程2
new Thread(){
	run(){
		dosomething...
		boolean flag = lock.tryLock();
		if(flag ){
			try{
				dosomething...
			}catch(Exception e){
				catch exception...
			}finally{
				lock.unlock();
			}
		}
	}
}.start();

3)tryLock(long time, TimeUnit unit)这个方法和上面2的很相似,不过这个会等待一定时间,如果在等待期间获取锁,及当前线程顺利执行资源,反之不等待,伪代码如下(5秒之内抢不到就中断):

Lock lock = new ReentrantLock();
//线程1
new Thread(){
	run(){
		dosomething...
		boolean flag = lock.tryLock(5, TimeUnit.SECONDS);
		if(flag ){
			try{
				dosomething...
			}catch(Exception e){
				catch exception...
			}finally{
				lock.unlock();
			}
		}
	}
}.start();
//线程2
new Thread(){
	run(){
		dosomething...
		boolean flag = lock.tryLock(5, TimeUnit.SECONDS);
		if(flag ){
			try{
				dosomething...
			}catch(Exception e){
				catch exception...
			}finally{
				lock.unlock();
			}
		}
	}
}.start();

4)lockInterruptibly()这个方法是表示多个线程去抢夺锁资源,ThreadA线程抢到资源并执行的时候,其他线程在等待状态中,但是我们可以通过interrupt()这个方法使指定没有抢到锁资源的线程中断等待。

Lock lock = new ReentrantLock();
ThreadA.start();
ThreadB.start();

dosomething....

ThreadB.interrupt();

run(){
	dosomething...
	boolean flag = lock.lockInterruptibly();
	try{
		dosomething...
	}catch(Exception e){
		catch exception...
	}finally{
		lock.unlock();
	}
}
  • 3.ReadWriteLock(读多写少的场景,读读共享,其他全互斥)

它可以实现读写锁,当读取的时候线程会获得read锁,其他线程也可以获得read锁同时并发的去读取,但是写程序运行获取到write锁的时候,其他线程是不能进行操作的,因为write是排它锁,而上面介绍的两种不管你是read还是write没有抢到锁的线程都会被阻塞或者中断,它也是个接口,里面定义了两种方法readLock()和readLock(),他的一个实现类是ReentrantReadWriteLock。

public interface ReadWriteLock {
    Lock readLock();
    Lock writeLock();
}

伪代码如下:

private ReentrantReadWriteLock rrwl = new ReentrantReadWriteLock();

ThreadA.do{
	read();
	write();
}

ThreadB.do{
	read();
	write();
}

//读操作
read(){
	rrwl.readLock().lock();
	try{
		read something...
	}catch(exception e){
		catch exception...
	}finally{
		rrwl.readLock().unlock();
	}
}

//写操作
write(){
	rrwl.writeLock().lock();
	try{
		write something...
	}catch(exception e){
		catch exception...
	}finally{
		rrwl.writeLock().unlock();
	}
}


使用ReentrantLock 也可以实现Object中的notify与wait功能(这两个方法需要配合synchronized关键字使用)。

那就是:Condition

	private Lock lock = new ReentrantLock();
	private Condition condition = lock.newCondition();

当使用如下的方法就相当于使用Object类的 wait

condition.await();

使用如下方法相当于使用Object类的 notify

condition.signal();	
<think>嗯,用户要求我参考站内引用来介绍JavasynchronizedLock锁的区别及使用场景。用户在上次对话中已经详细询问过Java锁机制,这次聚焦在两种核心锁的对比上。 从引用内容看,用户提供的资料已经相当全面。引用[1][2][4][5]都直接对比了synchronizedLock的特性,尤其是引用[4]的对比表格非常清晰。我需要整合这些信息,同时结合自己掌握的Java并发知识来组织回答。 用户可能正在准备面试或设计并发程序,需要明确的决策依据。回答应该突出实际场景的选择建议,而不仅是理论差异。注意到引用[5]特别提到“synchronized适合低并发,ReentrantLock适合高并发”这个关键点,这应该是性能维度的核心结论。 在结构上,考虑先展示差异矩阵(参考引用[4]的表格形式),然后分别说明适用场景。对于使用示例,准备用代码片段展示两种锁的基本用法,特别是Lock必须配合try-finally释放锁这个易错点(引用[2][4]都强调过)。 用户可能还会关心锁升级机制(引用[2]提到synchronized的偏向锁优化)死锁处理(引用[4]提到Lock可中断),这些都需要包含在回答中。最后考虑用流程图形式展示锁选择策略,帮助用户快速决策。</think>以下是Java中`synchronized`与`Lock`锁的详细对比及使用场景分析,结合核心引用内容整理: --- ### 一、核心区别对比 | **特性** | **synchronized** | **Lock (ReentrantLock)** | |------------------------|------------------------------------------|-----------------------------------------| | **实现层级** | JVM层面关键字(内置) | Java API接口(`java.util.concurrent.locks`) | | **锁获取/释放** | 自动获取释放(代码块结束或异常时) | 必须手动调用`lock()``unlock()`[^4] | | **可中断性** | 等待中不可中断 | 支持`lockInterruptibly()`响应中断[^2][^5] | | **公平性** | 仅支持非公平锁 | 可通过构造参数指定公平/非公平锁[^2][^4] | | **锁状态检测** | 无法判断锁状态 | 可通过`tryLock()`检测锁是否被占用[^4][^5] | | **锁绑定条件** | 仅支持单一等待队列 | 支持绑定多个`Condition`实现精准唤醒[^1][^3] | | **性能倾向** | 低竞争场景效率高(JVM自动优化锁升级)[^5] | 高竞争场景更优(减少线程挂起开销)[^1][^5] | | **锁粒度** | 方法级或代码块级 | 可灵活控制锁范围(如跨方法加锁)[^2] | --- ### 二、使用场景分析 #### 1. **优先选择 `synchronized` 的场景** - **简单同步需求**:如单方法内的临界区保护 ```java public synchronized void add() { count++; // 自动加锁/释放锁 } ``` - **低线程竞争环境**:JVM的锁升级(偏向锁→轻量级锁)可减少开销[^5] - **避免死锁风险**:自动释放锁机制降低编码失误概率[^4] #### 2. **优先选择 `Lock` 的场景** - **需要高级功能**: - 尝试获取锁(避免死锁): ```java if (lock.tryLock(1, TimeUnit.SECONDS)) { // 超时等待 try { /* 操作共享资源 */ } finally { lock.unlock(); } } ``` - 公平性要求:`new ReentrantLock(true)`[^4] - 多条件唤醒: ```java Condition condition = lock.newCondition(); condition.await(); // 精准唤醒特定线程 condition.signal(); ``` - **高并发写场景**:通过减少线程阻塞提升吞吐量[^5] - **跨方法锁控制**: ```java void methodA() { lock.lock(); try { ... } finally { /* 不在A方法释放锁 */ } } void methodB() { try { ... } finally { lock.unlock(); } // 在B方法释放锁 } ``` --- ### 三、底层原理差异 | **维度** | **synchronized** | **ReentrantLock** | |-------------------|--------------------------------------------------|-------------------------------------------| | **实现机制** | 对象头Mark Word + Monitor锁(JVM底层实现)[^2] | 基于AQS(AbstractQueuedSynchronizer)[^3] | | **锁升级路径** | 无锁 → 偏向锁 → 轻量级锁 → 重量级锁[^2] | 无锁升级概念 | | **重入实现** | 通过计数器递归实现[^3] | 同步状态state计数实现[^3] | > ⚠️ **注意**: > - `synchronized`在JDK6后引入锁升级,但**重量级锁不可逆**; > - `Lock`需严格在`finally`中释放锁,否则会导致死锁[^4][^5] --- ### 四、典型代码示例 #### 1. `ReentrantReadWriteLock` 读写分离(引用[4]) ```java ReadWriteLock rwLock = new ReentrantReadWriteLock(); // 读操作(共享锁) rwLock.readLock().lock(); try { // 多线程并发读 } finally { rwLock.readLock().unlock(); } // 写操作(独占锁) rwLock.writeLock().lock(); try { // 单线程写 } finally { rwLock.writeLock().unlock(); } ``` #### 2. `Lock` 响应中断(引用[5]) ```java Lock lock = new ReentrantLock(); try { lock.lockInterruptibly(); // 可被其他线程中断 try { /* 临界区 */ } finally { lock.unlock(); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); // 恢复中断状态 } ``` --- ### 五、选型决策流程图 ```mermaid graph TD A[需要同步?] --> B{竞争强度} B -->|低竞争| C[synchronized] B -->|高竞争| D{需高级功能?} D -->|是| E[ReentrantLock] D -->|否| C E --> F[需要读写分离?] F -->|是| G[ReentrantReadWriteLock] F -->|否| E ``` > 📌 **总结原则**: > 1. **简单优先**:无特殊需求时首选`synchronized` > 2. **灵活控制**:需超时、可中断、公平锁时用`Lock` > 3. **读写分离**:读多写少场景用`ReentrantReadWriteLock`[^4] --- ### 参考资料 [^1]: Java锁:Locksynchronized的全面对比 [^2]: SynchronizedLock的实现原理及使用场景 [^3]: synchronizedLock深度对比及高级用法 [^4]: synchronizedLock区别使用示例 [^5]: synchronizedLock锁的面试题解析
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值