Java编程读写锁详解

Z时代
2024-01-10
分类：综合

ReadWriteLock也是一个接口，提供了readLock和writeLock两种锁的操作机制，一个资源可以被多个线程同时读，或者被一个线程写，但是不能同时存在读和写线程。

基本规则：读读不互斥读写互斥写写互斥

问题：既然读读不互斥，为何还要加读锁

答：如果只是读，是不需要加锁的，加锁本身就有性能上的损耗

如果读可以不是最新数据，也不需要加锁

如果读必须是最新数据，必须加读写锁

读写锁相较于互斥锁的优点仅仅是允许读读的并发，除此之外并无其他。

结论：读写锁能够保证读取数据的严格实时性，如果不需要这种严格实时性，那么不需要加读写锁。

简单实现：


package readandwrite;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class MyTest {
 private static ReentrantReadWriteLock rwl=new ReentrantReadWriteLock();
 private static double data=0;
 static class readClass implements Runnable{
  @Override
  public void run() {
   rwl.readLock().lock();
   System.out.println("读数据："+data);
   rwl.readLock().unlock();
  }
 }
 static class writeClass implements Runnable{
  private double i;
  public writeClass(double i) {
   this.i = i;
  }
  @Override
  public void run() {
   rwl.writeLock().lock();
   data=i;
   System.out.println("写数据： "+data);
   rwl.writeLock().unlock();
  }
 }
 public static void main(String[] args) throws InterruptedException {
  ExecutorService pool=Executors.newCachedThreadPool();
  for(int i=0;i<10;i++){
   pool.submit(new readClass());
   pool.submit(new writeClass((double)new Random().nextDouble()));
   pool.submit(new writeClass((double)new Random().nextDouble()));
   Thread.sleep(1000);
  }
  pool.shutdown();
 }
}

之前我们提到的锁都是排它锁（同一时刻只允许一个线程进行访问），而读写锁维护了一对锁，一个读锁，一个写锁。读写锁在同一时刻允许多个线程进行读操作，但是写线程访问过程中，所有的读线程和其他写线程均被阻塞。如此，并发性有了很大的提升。这样，在某些读远远大于写的场景中，读写锁能够提供比排它锁更好的并发量和吞吐量。

一个关于读写锁的Demo：

分析：设计一个模拟队列，拥有一个data成员变量用于存储数据和存取两种操作。


import java.util.Random;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadWriteLockDemo
{
  public static void main(String[] args)
  {
    DefQueue queue = new DefQueue();
    for (int i = 1; i < 10; i++)
    {
      //启动线程进行读操作
      new Thread(new Runnable()
      {
        @Override
        public void run()
        {
          while (true)
          {
            queue.get();
          }
        }
      }).start();
      //启动线程进行写操作
      new Thread(new Runnable()
      {
        @Override
        public void run()
        {
          while(true)
          {
            queue.put(new Random().nextInt(10000));
          }
        }
      }).start();
    }
  }
}
class DefQueue
{
  private int data;
  ReadWriteLock rwLock = new ReentrantReadWriteLock();
  public void get()
  {
    rwLock.readLock().lock();//加读锁
    try
    {
      System.out.println(Thread.currentThread().getName() + "be ready to get data");
      Thread.sleep((long) (Math.random() * 1000));
      System.out.println(Thread.currentThread().getName() + "get the data:  " + data);
    } catch (InterruptedException e)
    {
      e.printStackTrace();
    } finally
    {
      rwLock.readLock().unlock();//释放读锁
    }
  }
  public void put(int data)
  {
    rwLock.writeLock().lock();//加写锁
    try
    {
      System.out.println(Thread.currentThread().getName() + " be ready to write data");
      Thread.sleep((long) (Math.random() * 1000));
      this.data = data;
      System.out.println(Thread.currentThread().getName() + " has wrote the data: "+data);
    } catch (InterruptedException e)
    {
      e.printStackTrace();
    } finally
    {
      rwLock.writeLock().unlock();//释放写锁
    }
  }
}

程序部分运行结果：

Thread-0be ready to get data

Thread-0get the data: 0

Thread-1 be ready to write data

Thread-1 has wrote the data: 1156

Thread-2be ready to get data

Thread-2get the data: 1156

Thread-3 be ready to write data

Thread-3 has wrote the data: 9784

Thread-3 be ready to write data

Thread-3 has wrote the data: 4370

Thread-3 be ready to write data

Thread-3 has wrote the data: 1533

Thread-4be ready to get data

Thread-4get the data: 1533

Thread-5 be ready to write data

Thread-5 has wrote the data: 2345

Thread-6be ready to get data

Thread-6get the data: 2345