读写锁

时间：2018-10-26 17:55:36 阅读：189 评论：0 收藏：0 [点我收藏+]

标签：code http get alt 多个 dwr 分享 sleep image

相比Java中的锁(Locks in Java)里Lock实现，读写锁更复杂一些。假设你的程序中涉及到对一些共享资源的读和写操作，且写操作没有读操作那么频繁。在没有写操作的时候，两个线程同时读一个资源没有任何问题，所以应该允许多个线程能在同时读取共享资源。但是如果有一个线程想去写这些共享资源，就不应该再有其它线程对该资源进行读或写（译者注：也就是说：读-读能共存，读-写不能共存，写-写不能共存）。这就需要一个读/写锁来解决这个问题。Java5在java.util.concurrent包中已经包含了读写锁。尽管如此，我们还是应该了解其实现背后的原理。

读写这种的可以用wait notify 之前已经实现过了读的时候不能写写的时候不能做保证共性的全局变量安全

下面，先来写个读写锁大家看看：

package com.toov5.readAndWriteLock;

import java.util.HashMap;
import java.util.Map;

//读写锁 类似jvm内置缓存（把值存到jvm中）
public class writeAndReadLock {
    private volatile Map<Object,Object> cache = new HashMap<>();  
    
    //写入元素
    public void put(String key,String value){
        try {
            Thread.sleep(500);
            System.out.println("写入"+key+value);
            cache.put(key, value);
            System.out.println("写入"+key+value+"结束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    //读取元素
    public String get(String key){
        try {
            Thread.sleep(500);
            System.out.println("读取"+key);
            String result = cache.get(key).toString();
            System.out.println("读取"+key+"结束");
            return result;
        } catch (Exception e) {
            return null;
        }
    }
    
     public static void main(String[] args) {
        writeAndReadLock lock = new writeAndReadLock();
        //写线程
          Thread t1 = new Thread(new Runnable() {    
            @Override
            public void run() {
                for(int i =0; i<10;i++){
                    lock.put("i", i+"");
                }
            }
        });
          
      //读线程      
          Thread t2 = new Thread(new Runnable() {
                
                @Override
                public void run() {
                    for(int i=0; i<10;i++){
                        lock.get(i+"");
                    }
                }
            }); 
      t1.start();
      t2.start();
          
    }
    
}

结果：

技术分享图片

如果两个方法都加上synchronize 那么读的时候不能写写的时候不能读

下面提供读写锁：

package com.toov5.readAndWriteLock;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;

//读写锁 类似jvm内置缓存（把值存到jvm中）
public class writeAndReadLock {
    private volatile Map<Object,Object> cache = new HashMap<>();  
    private ReentrantReadWriteLock wrl = new ReentrantReadWriteLock();  
    private WriteLock wirtelock=wrl.writeLock();//获取到写锁
    private ReadLock readLock =wrl.readLock(); //获取到读锁
    //写入元素
    public void put(String key,String value){
        try {    
            wirtelock.lock();
            Thread.sleep(500);
            System.out.println("写入"+key+value);
            cache.put(key, value);
            System.out.println("写入"+key+value+"结束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            wirtelock.unlock();
        }
    }
    
    //读取元素
    public String get(String key){
        try {
            readLock.lock();
            Thread.sleep(500);
            System.out.println("读取"+key);
            String result = cache.get(key).toString();
            System.out.println("读取"+key+"结束");
            return result;
        } catch (Exception e) {
            return null;
        }finally{
            readLock.unlock();
        }
    }
    
     public static void main(String[] args) {
        writeAndReadLock lock = new writeAndReadLock();
        //写线程
          Thread t1 = new Thread(new Runnable() {    
            @Override
            public void run() {
                for(int i =0; i<10;i++){
                    lock.put("i", i+"");
                }
            }
        });
          
      //读线程      
          Thread t2 = new Thread(new Runnable() {
                
                @Override
                public void run() {
                    for(int i=0; i<10;i++){
                        lock.get(i+"");
                    }
                }
            }); 
      t1.start();
      t2.start();
          
    }
    
}