java 之读写锁线程间互斥

最新推荐文章于 2023-06-18 14:54:46 发布

原创最新推荐文章于 2023-06-18 14:54:46 发布 · 1.9k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #object #exception #缓存系统 #string #thread

java Thread 专栏收录该内容

10 篇文章

订阅专栏

本文介绍了一个使用读写锁实现线程安全的队列和缓存系统的示例。通过ReentrantReadWriteLock确保多个读操作可以同时进行，而写操作则需要独占锁。这提高了并发性能，尤其是在读操作远多于写操作的场景中。

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

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

/**
 * 线程间互斥
 * @author ETHAN
 *
 */
public class ReadWriteLockTest {

	public static void main(String[] args) {
		final Queue3 q3 = new Queue3();
		for(int i=0;i<3;i++) {
			//三个读的线程
			new Thread() {
				public void run() {
					while(true) {
						q3.get();
					}
				}
			}.start();
			
			//三个写的线程
			new Thread() {
				public void run() {
					while(true) {
						q3.put(new Random().nextInt(100000));
					}
				}
			}.start();
		}
	}

}

/**
 * 读和写要互斥，放在一个类里
 * 读锁 不互斥，读和写锁互斥，写写锁互斥
 * @author ETHAN
 *
 */
class Queue3 {
	private Object data = null;//共享数据
	//不能用Lock,得用他的子类
	private ReadWriteLock rwl = new ReentrantReadWriteLock();
	
	public void get() {
		rwl.readLock().lock();
		try {
			System.out.println(Thread.currentThread().getName()+ " be ready to read data!");
			Thread.sleep((long)(Math.random()*1000));
			System.out.println(Thread.currentThread().getName()+" have read data: "+data);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			rwl.readLock().unlock();
		}
	}
	
	public void put(Object data) {
		rwl.writeLock().lock();
		
		try {
			System.out.println(Thread.currentThread().getName()+ " be ready to write data!");
			Thread.sleep((long)(Math.random()*1000));
			this.data = data;
			System.out.println(Thread.currentThread().getName()+" have write data: "+data);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			rwl.writeLock().unlock();
		}
	}
}

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 缓存系统
 * @author ETHAN
 *
 */
public class CacheDemo {

	private Map<String,Object> cache = new HashMap<String, Object>();
	
	public static void main(String[] args) {
		
	}
	
	private ReadWriteLock rwl = new ReentrantReadWriteLock();
	
	public Object getData(String key) {
		rwl.readLock().lock();
		Object value = null;
		try {
			value = cache.get(key);
			if(value==null) {
				rwl.readLock().unlock();
				//挂上写锁，查数据
				rwl.writeLock().lock();
				try {
					//再检查一次，防止其他线程，因为都可读，不互斥
					if(value==null) {
						value = "xxx";//query db
					}
				} finally {
					rwl.readLock().lock();//downgrade by acquiring the readlock
					rwl.writeLock().unlock();//有一种更新锁
				}
				
			} 
		} finally {
			rwl.readLock().unlock();
		}
		
		return value;
	}
}