ReentrantReadWriteLock锁Demo及注解

 读写各代表共享锁和独占锁

独占锁：一个锁只能被一个线程使用

共享锁：一个锁可被多个线程使用；读锁的共享锁保证并发读是非常高效的

 

package com.reentralock;

import java.util.HashMap;

class myCache{
	private volatile HashMap<String, Object> map = new HashMap<>();//多线程保证map的可见性
	
	public void put(String key,Object val){//模仿写
		System.out.println(Thread.currentThread().getName()+"\t writing...."+key);
		map.put(key, val);
		System.out.println(Thread.currentThread().getName()+"\t writed."+key);
	}
	
	public void get(String key){//模仿读
		System.out.println(Thread.currentThread().getName()+"\t reading...."+key);
		map.get(key);
		System.out.println(Thread.currentThread().getName()+"\t read over."+key);
	}
	
}

/**
 * 缓存机制：写的时候保证开始写和写完之间不允许其他线程来写，这就叫独占错；但是读的时候可以很多人来读，这叫共享锁；
 * 如果对于redis缓存，你在写的时候不允许别人来读，redis你算什么正经缓存！
 * 也就是说在高并发场景下，我需要读写分离，而不是对于redis这块内存空间来说，我在写的时候我用ReentraLock锁上，我没写完
 * 其他线程b来读我也不行，ReentrantReadWriteLock可以满足只要我写我的a，你读你的b，是没问题的
 * @author 英俊
 *
 */
public class ReentrantReadWriteLock {
	
	
	public static void main(String[] args) {
		
		myCache cache = new myCache();
		
		for (int i = 0; i < 5; i++) {
			final int ti = i;//lambda表达式中put必须是final级别的
			new Thread(()->{
				cache.put(ti+"", ti+"");
			},"aa").start();
		}
		
		for (int i = 0; i < 5; i++) {
			final int ti = i;
			new Thread(()->{
				cache.get(ti+"");
			},"bb").start();
		}
	}
	
	
}

结果：写的过程中，不允许其他操作进来，我在写！不可以不原子。

我要使用读（共享锁）写（独占锁）锁机制，提高的并发处理能力。

package com.reentralock;

import java.util.HashMap;

class myCache{
	private volatile HashMap<String, Object> map = new HashMap<>();//多线程保证map的可见性
	//读写锁，用哪个找哪个
	private java.util.concurrent.locks.ReentrantReadWriteLock lock = new java.util.concurrent.locks.ReentrantReadWriteLock();
	
	public void put(String key,Object val){//模仿写
		//写就独占锁
		lock.writeLock().lock();
		try {
			System.out.println(Thread.currentThread().getName()+"\t writing...."+key);
			map.put(key, val);
			System.out.println(Thread.currentThread().getName()+"\t writed."+key);
		} finally {
			lock.writeLock().unlock();
		}
	}
	
	public void get(String key){//模仿读
		//读就共享锁
		lock.readLock().lock();
		try {
			System.out.println(Thread.currentThread().getName()+"\t reading...."+key);
			map.get(key);
			System.out.println(Thread.currentThread().getName()+"\t read over."+key);
		} finally {
			lock.readLock().unlock();
		}
	}
	
}

/**
 * 缓存机制：写的时候保证开始写和写完之间不允许其他线程来写，这就叫独占错；但是读的时候可以很多人来读，这叫共享锁；
 * 如果对于redis缓存，你在写的时候不允许别人来读，redis你算什么正经缓存！
 * 也就是说在高并发场景下，我需要读写分离，而不是对于redis这块内存空间来说，我在写的时候我用ReentraLock锁上，我没写完
 * 其他线程b来读我也不行，ReentrantReadWriteLock可以满足只要我写我的a，你读你的b，是没问题的
 * 目的：提高一致性和并发性。
 * @author 英俊
 *
 */
public class ReentrantReadWriteLock {
	
	
	public static void main(String[] args) {
		
		myCache cache = new myCache();
		
		for (int i = 0; i < 5; i++) {
			final int ti = i;//lambda表达式中put必须是final级别的
			new Thread(()->{
				cache.put(ti+"", ti+"");
			},"aa").start();
		}
		
		for (int i = 0; i < 5; i++) {
			final int ti = i;
			new Thread(()->{
				cache.get(ti+"");
			},"bb").start();
		}
	}
	
	
}

结果：