多个线程同时读一个资源类没有任何问题,但是为了满足并发量,读取共享资源应该可以同时进行。 如果有一个线程想去共享资源类,就不应该再有其他线程可以对该资源进行读或写。
即:读读共存 读写不共存 写写不共存
案例:
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
class MyCache{
private volatile Map<String, Object> map = new HashMap<>();
private ReadWriteLock lock = new ReentrantReadWriteLock();
public void put(String key, Object value) throws Exception{
lock.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName()+"\t==========写入数据");
Thread.sleep(2000);
map.put(key, value);
System.out.println(Thread.currentThread().getName()+"\t==========写入完成");
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.writeLock().unlock();
}
}
public void get(String key) throws Exception{
lock.readLock().lock();
try {
System.out.println(Thread.currentThread().getName()+"\t==========读取数据");
Thread.sleep(2000);
map.get(key);
System.out.println(Thread.currentThread().getName()+"\t==========读取完成");
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.readLock().unlock();
}
}
}
public class Test {
public static void main(String[] args) {
MyCache myCache = new MyCache();
for (int i = 0; i < 5; i++) {
final int tempi = i;
new Thread(() -> {
try {
myCache.put(tempi+"",tempi+"");
} catch (Exception e) {
e.printStackTrace();
}
}, String.valueOf(i)).start();
}
for (int i = 0; i < 5; i++) {
final int tempi = i;
new Thread(() -> {
try {
myCache.get(tempi+"");
} catch (Exception e) {
e.printStackTrace();
}
}, String.valueOf(i)).start();
}
}
}
效果: