多线程读写锁

读写锁

代码示例:

package com.rw;


import sun.misc.REException;

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.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 独占锁（写锁） 一次只能被一个线程占有
 * 共享锁（读锁）  多个线程可以同时获取
 *
 * ReadWriteLock 的方法writeLock,readLock
 * 写是:同时只允许一个线程操作的,查看是允许多个线程同时操作的！
 *
 * 读-读 可以共存！
 * 读-写 不能共存！
 * 写-写 不能共存！  一个线程执行完毕才会释放锁
 *
 */
public class ReadWriteLockDemo {


    public static void main(String[] args) {
        //没有加读写锁的类，被其他线程插队了,没有保证单个线程的原子性。
        //  MyCache myCache = new MyCache();
        //用加锁过的类来处理,单个线程插入完毕后，其他线程才能进来，读取的时候多个线程都可以读取！
        MyCacheLock myCacheLock = new MyCacheLock();

        //只做一些写入的操作
        for (int i = 1; i <=5; i++) {
            final int temp =i;
            new Thread(()->{
                myCacheLock.put(temp+"",temp+"");

            },String.valueOf(i)).start();
        }

        //只做读取的操作
        for (int i = 1; i <=5; i++) {
            final int temp =i;
            new Thread(()->{
                myCacheLock.get(temp+"");

            },String.valueOf(i)).start();
        }
    }
}



/**
 * 自定义缓存，加锁的
 */
class MyCacheLock{

    //volatile 原子性，可见性，有序性
    private volatile Map<String,Object> map = new HashMap<>();

    //初始化读写锁:更加细粒度的控制
    private ReadWriteLock readWriteLock =new ReentrantReadWriteLock();


    //存,写,写入的时候，只希望同时只有一个线程写
    public  void put(String key,Object value){
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"写入"+key);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"写入OK");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }

    //取,读,所有人都可以读！
    public void get(String key){
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"读取"+key);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取OK");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}



/**
 * 
 * 自定义缓存，不加锁的
 */
 class MyCache{

     //volatile 原子性，可见性，有序性
     private volatile Map<String,Object> map = new HashMap<>();

     //存,写
     public  void put(String key,Object value){
         System.out.println(Thread.currentThread().getName()+"写入"+key);
         map.put(key,value);
         System.out.println(Thread.currentThread().getName()+"写入OK");
     }

     //取,读
     public void get(String key){
         System.out.println(Thread.currentThread().getName()+"读取"+key);
         Object o = map.get(key);
         System.out.println(Thread.currentThread().getName()+"读取OK");
     }
 }

加锁输出结果：1 写入，1 写入OK ，一个线程执行完了释放锁，下一个线程才执行！
1写入1
1写入OK
3写入3
3写入OK
2写入2
2写入OK
4写入4
4写入OK
5写入5
5写入OK
2读取2
2读取OK
3读取3
3读取OK
1读取1
4读取4
4读取OK
1读取OK
5读取5
5读取OK

未加锁输出结果：1 还未写入OK ，其他线程就进来了
1写入1
4写入4
5写入5
3写入3
2写入2
3写入OK
5写入OK
4写入OK
1写入OK
1读取1
1读取OK
2写入OK
2读取2
2读取OK
3读取3
3读取OK
4读取4
4读取OK
5读取5
5读取OK