java多线程--ReentrantReadWriteLock的使用

最新推荐文章于 2025-05-28 14:12:54 发布

翻译最新推荐文章于 2025-05-28 14:12:54 发布 · 6.7k 阅读

文章标签：

#多线程 #ReentrantReadWriteLo

java并发编程专栏收录该内容

12 篇文章

订阅专栏

本文详细介绍了Java中ReentrantReadWriteLock的使用方法。通过两个实例演示了读读共享及写写互斥的特性，帮助读者理解如何在多线程环境下合理运用读写锁。

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

java多线程--ReentrantReadWriteLock的使用

读写锁的使用，限制范围为：
* 读读锁互斥，读写之间互斥，写写之间互斥

一.实例一，读读之间可以共享数据即可以同一时间获取读取锁

package readwritelock;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 读写锁的使用，限制范围为：
 * 读读锁互斥，读写之间互斥，写写之间互斥
 * 
 * 本实例实现：读读共享，即读与读之间不互斥
 * @author lxb
 *
 */
public class Service {

	private ReentrantReadWriteLock lock =new ReentrantReadWriteLock();
	
	public void read(){
		try{
			
			try{
				lock.readLock().lock();      //获取读取锁,因为是读取锁，所以这里不需要等待
				System.out.println("获取读锁:"+Thread.currentThread().getName()+
						" "+System.currentTimeMillis());
				
				Thread.sleep(10000);
			}finally{
				lock.readLock().unlock();
			}
			
		}catch(InterruptedException e){
			
			e.printStackTrace();
		}
		
		
	}
}

二.写锁之间互斥

package readwritelock;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 本实例实现写锁之间互斥
 * 
 * @author lxb
 *
 */
public class WriteService {

	private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

	public void write() {
		try {

			try {
				lock.writeLock().lock(); // 获取读取锁,因为是读取锁，所以这里不需要等待
				System.out.println("获取写锁:" + Thread.currentThread().getName()
						+ " " + System.currentTimeMillis());

				Thread.sleep(10000);
			} finally {
				lock.writeLock().unlock();
			}

		} catch (InterruptedException e) {

			e.printStackTrace();
		}
	}

}

读锁测试线程：

package readwritelock;

public class ThreadA extends Thread{
	
	private Service service;
	
	public ThreadA(Service service){
		this.service = service;
	}
	
	public void run(){
		service.read();
	}

}

package readwritelock;

public class ThreadB extends Thread{

private Service service;
	
	public ThreadB(Service service){
		this.service = service;
	}
	
	public void run(){
		service.read();
	}
}

写锁测试线程：

package readwritelock;

public class ThreadC extends Thread{

	private WriteService service;
	
	public ThreadC(WriteService service){
		this.service = service;
	}
	
	public void run(){
		service.write();
	}
}

主线程：

package readwritelock;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		//testReadLock();
		testWriteLock();
	}

	public static void testReadLock() {

		// service可看作是一个线程共享 的实例对象
		Service service = new Service();

		ThreadA a = new ThreadA(service);

		a.setName("A");

		ThreadB b = new ThreadB(service);

		b.setName("B");
		a.start();
		b.start();
	}
	
	
	/**
	 * 打打印的结果应该是其中一个线程先获取锁，稍后 10秒后另一个线程再获取 锁
	 */
	public static void testWriteLock() {

		// service可看作是一个线程共享 的实例对象
		WriteService service = new WriteService();
		

		ThreadC C = new ThreadC(service);

		C.setName("C");

		ThreadC D = new ThreadC(service);

		D.setName("D");
		C.start();
		D.start();
	}
	

}