java求读写性能 java高性能读写文件 java 读写锁实现原理

Java读写锁理论和代码验证

1、Java读写锁理论

写锁（独占锁）：是指该锁一次只能被一个线程锁持有。对ReentrantLock和Sychronized而言都是独占锁。

读锁（共享锁）：是指该锁可被多个线程持有。对ReentrantReadWriteLock而言，其读锁是共享锁，其写锁是独占锁。读锁的共享性可保证并发读是非常高效的，读写、写读、写写的过程都是互斥的。

2、Java读写锁代码验证

Demo One：代码没有加读写锁的情况

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;
 
/**
 * 多个线程同时读一个资源类的时候是没有任何问题，所以为了满足并发量，读取共享资源应该同时进行。
 * 但是，如果有一个线程想去写共享资源，就不应该有其他线程去读或者写
 * <p>
 * 总结：
 * 读-读共存
 * 读-写不共存
 * 写-读不共存
 * 写-写不共存
 *
 * 写操作：原子+独占，整个过程必须是一个完整体，中间不能有任何中断
 */
public class ReentrantReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            new Thread(() -> {
                myCache.put(finalI + "", finalI + "");
            }, i + "").start();
        }
 
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            new Thread(() -> {
                myCache.get(finalI + "");
            }, i + "").start();
        }
 
    }
}
 
class MyCache {
    private volatile Map<String, String> map = new HashMap<>();
 
    //private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
 
    public void put(String key, String value) {
        System.out.println(Thread.currentThread().getName() + "正在写......");
        try {
            TimeUnit.MILLISECONDS.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        map.put(key, value);
        System.out.println(Thread.currentThread().getName() + "写已经完成");
    }
 
    public String get(String key) {
        System.out.println(Thread.currentThread().getName() + "正在读......");
        try {
            TimeUnit.MILLISECONDS.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        String value = map.get(key);
        System.out.println(Thread.currentThread().getName() + "读已经完成");
        return value;
    }
}

程序执行结果如下：0号线程还没有写完就4号线程写操作、3号线程写操作、2号线程写操作等等打断，所以没有加读写锁的并发操作并不安全。

Demo Two：代码加了读写锁的情况下

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;
 
/**
 * 多个线程同时读一个资源类的时候是没有任何问题，所以为了满足并发量，读取共享资源应该同时进行。
 * 但是，如果有一个线程想去写共享资源，就不应该有其他线程去读或者写
 * <p>
 * 总结：
 * 读-读共存
 * 读-写不共存
 * 写-读不共存
 * 写-写不共存
 *
 * 写操作：原子+独占，整个过程必须是一个完整体，中间不能有任何中断
 */
public class ReentrantReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            new Thread(() -> {
                myCache.put(finalI + "", finalI + "");
            }, i + "").start();
        }
 
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            new Thread(() -> {
                myCache.get(finalI + "");
            }, i + "").start();
        }
 
    }
}
 
class MyCache {
    private volatile Map<String, String> map = new HashMap<>();
 
    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
 
    public void put(String key, String value) {
        rwLock.writeLock().lock();
        System.out.println(Thread.currentThread().getName() + "正在写......");
        try {
            TimeUnit.MILLISECONDS.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        map.put(key, value);
        System.out.println(Thread.currentThread().getName() + "写已经完成");
        rwLock.writeLock().unlock();
    }
 
    public String get(String key) {
        rwLock.readLock().lock();
        System.out.println(Thread.currentThread().getName() + "正在读......");
        try {
            TimeUnit.MILLISECONDS.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        String value = map.get(key);
        System.out.println(Thread.currentThread().getName() + "读已经完成");
        rwLock.readLock().unlock();
        return value;
    }
}

程序执行结果如下：0号线程写操作完全执行完成之后才会去执行1、3、2、4号线程的写操作，读操作就不需要保证原子+独占，可以随机读取共享资源，保证读的并发性能。