黑马程序员-java5的线程锁技术Lock,Condition

最新推荐文章于 2023-12-25 09:23:30 发布

原创最新推荐文章于 2023-12-25 09:23:30 发布 · 1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #Lock #Condition

java高新技术专栏收录该内容

21 篇文章

订阅专栏

本文介绍了Java中利用ReentrantReadWriteLock实现读写锁的方法，通过具体实例展示了如何使用读锁和写锁来控制线程间的互斥访问，并提供了一个简单的缓存系统案例。

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

---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流！ ----------------------

java.util.concurrent.locks.Lock

格式：Lock lock=new ReentrantLock();

lock.lock();
		try {
		} finally {
			lock.unlock();
		}

读写锁：分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，写锁与写锁互斥，这是由jvm自己控制的。

小结：读锁控制读线程与写线程的互斥，就是说多个线程可以同时读，但写线程就不能进来，如果不加读锁，写线程就会进来，这就是读锁的作用。

写锁：控制写线程与写线程的互斥。

格式：

ReadWriteLock rwl = new ReentrantReadWriteLock();
		try {
			rwl.readLock().lock();
		} finally {
			rwl.readLock().unlock();
		}
		try {
			rwl.writeLock().lock();
		} finally {
			rwl.writeLock().unlock();
		}

小结：读锁中的lock方法

写锁中的lock方法

DataDemo类

public class DataDemo {

	private String data;

	public void put(String data) {
		System.out.println(Thread.currentThread().getName() + "be ready write");
		try {
			Thread.sleep(200);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName() + "have write data"
				+ data);
		this.data = data;
	}

	public String get() {
		System.out.println(Thread.currentThread().getName() + "be ready read");
		try {
			Thread.sleep(20);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName() + "have read data"
				+ data);
		return data;
	}
}

ReadWriteLockTest类

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

public class ReadWriteLockTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		final ReadWriteLock rwl = new ReentrantReadWriteLock();
		final DataDemo dataDemo = new DataDemo();
		for (int i = 0; i < 3; i++) {
			new Thread(new Runnable() {

				@Override
				public void run() {
					// TODO Auto-generated method stub
					while (true) {
						// rwl.readLock().lock();
						dataDemo.get();
						// rwl.readLock().unlock();
						try {
							Thread.currentThread().sleep(20);
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}
				}
			}).start();
		}
		for (int j = 0; j < 3; j++) {
			new Thread(new Runnable() {

				@Override
				public void run() {
					// TODO Auto-generated method stub
					Random random = new Random();
					while (true) {
						rwl.writeLock().lock();
						String str = random.nextInt() + "abc";
						dataDemo.put(str);

						rwl.writeLock().unlock();
						try {
							Thread.currentThread().sleep(20);
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}
				}
			}).start();
		}

	}

}

输出结果：

注意我注释掉了读锁

所以出现这个结果很正常，因为读线程么有加读锁，如果加了的话，如果写线程没有释放锁，读线程rwl.readLock().lock();就会阻塞，如果不加读锁，读线程就不会阻塞。

自己写个缓存系统：

CacheDemo类

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

public class CacheDemo {

	static Map<String, Object> map = new HashMap<String, Object>();
	static Object obj;
	static ReadWriteLock lock = new ReentrantReadWriteLock();

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

	}

	public static Object get(String str) {
		try {
			lock.readLock().lock();
			if (map.get(str) == null) {
				try {
					lock.readLock().unlock();
					lock.writeLock().lock();
					if (map.get(str) == null) {
						obj = "";// 查询数据库
					}
				} finally {
					lock.writeLock().unlock();
					lock.readLock().lock();
				}
			}
		} finally {
			lock.readLock().unlock();
		}
		return obj;
	}

}