读写各代表共享锁和独占锁
独占锁:一个锁只能被一个线程使用
共享锁:一个锁可被多个线程使用;读锁的共享锁保证并发读是非常高效的
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();
}
}
}
结果: