java5线程框架Executor_读写锁的例子-优快云博客

本文通过四个Java类实现了一个简单的读写锁示例。在该示例中，多个读线程可以同时访问共享资源，但写线程访问时会阻止所有读线程的访问，确保数据一致性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

java5线程框架Executor 读写锁的例子

为了提高效率有些共享资源允许同时进行多个读的操作，但只允许一个写的操作，比如一个文件，只要其内容不变可以让多个线程同时读，不必做排他的锁定，排他的锁定只有在写的时候需要，以保证别的线程不会看到数据不完整的文件。 ReadWriteLock 可满足这种需要。 ReadWriteLock 内置两个 Lock ，一个是读的 Lock ，一个是写的 Lock 。多个线程可同时得到读的 Lock ，但只有一个线程能得到写的 Lock ，而且写的 Lock 被锁定后，任何线程都不能得到 Lock 。

这里模拟了这样一个场景: 在ReadWriteLockOperator对象里设置一个共享资源 shareResources 。
有3个读者(A, B, C)一直连续的从 shareResources 获取信息, 然后输出到

控制台 ;有一个作者每隔60秒往 shareResources 加入信息, 加信息的过程

相对耗时, 在这段时间, 任何读者都不能访问 shareResources。

写了4个类来验证这种情况，只在windows下做了测试。
1.1、 ReadTask.java       读任务
1.2、 WriteTask.java      写任务
1.3、 ReadWriteLockLogic.java     读写操作的逻辑
1.4、 ReadWriteLockTest.java      带有main方法的测试类

================= 1.1 ReadTask.java =====================
package Executor;
//可执行任务
public class ReadTask extends Thread {
//logic bean
private ReadWriteLockLogic readWriteLockOperator;

//读者
private String reader;

public ReadTask(ReadWriteLockLogic readWriteLockOperator, String reader) {
this.readWriteLockOperator = readWriteLockOperator;
this.reader = reader;
}

private ReadTask(){}

// 执行任务
public void run() {
    if(this.readWriteLockOperator != null){
      try {
        while(!isInterrupted()){
          Thread.sleep(200);
          System.out.println(reader + " read:" + Thread.currentThread().toString() + " : " + this.readWriteLockOperator.read());
        }
      } catch (Exception e) {
        // TODO: handle exception
      }
    }
}
}
========================= 1.1 end ========================

================= 1.2 WriteTask.java =====================
package Executor;
//可执行任务
public class WriteTask extends Thread{
//logic bean
private ReadWriteLockLogic readWriteLockOperator;

//作者
private String writer;

public WriteTask(ReadWriteLockLogic readWriteLockOperator, String writer) {
this.readWriteLockOperator = readWriteLockOperator;
this.writer = writer;
}

private WriteTask(){}

// 一个很耗时的写任务
public void run() {
    try {
      while(!isInterrupted()){
        Thread.sleep(100);
        this.readWriteLockOperator.write(this.writer, "hehehhe");
      }
    } catch (Exception e) {
      // TODO: handle exception
    }
}
}
========================= 1.2 end ==========================

================= 1.3 ReadWriteLockLogic.java ==============
package Executor;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

//读写操作的逻辑
public class ReadWriteLockLogic {
// 初始化一个 ReadWriteLock
private ReadWriteLock lock = new ReentrantReadWriteLock();

//共享资源
private List<String> shareResources = new ArrayList<String>(0);

//读
public String read() {

// 得到 readLock 并锁定
Lock readLock = lock.readLock();

readLock.lock();

    try {
      // 读相对省时，做空循环大约0.5second
      for(int i=0 ;i<2500000; i++){
        System.out.print("");
      }

      // 做读的工作
      StringBuffer buffer = new StringBuffer();
      for (String shareResource : shareResources) {
        buffer.append(shareResource);
        buffer.append("/t");
      }

return buffer.toString();

    } finally {
      readLock.unlock();//一定要保证锁的释放
    }
}

//写
public void write(String writer, String content) {

// 得到 writeLock 并锁定
Lock writeLock = lock.writeLock();

writeLock.lock();

    try {
      System.out.println(writer + " write ===" + Thread.currentThread().toString());
      // 写比较费时，所以做空循环大约13second
      for(int i=0 ;i<50000000; i++){
        System.out.print("");
        System.out.print("");
      }

      // 做写的工作
      int count = shareResources.size();
      for (int i=count; i < count + 1; i++) {
        shareResources.add(content + "_" + i);
      }

    } finally {
      writeLock.unlock();//一定要保证锁的释放
    }
}
}
========================= 1.3 end ==========================

================= 1.4 ReadWriteLockTest.java ===============
package Executor;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ReadWriteLockTest {
public static void main(String[] args) throws InterruptedException, ExecutionException {

//1 创建一个具有排程功能的线程池
ScheduledExecutorService service = Executors.newScheduledThreadPool(5);

//2 读写锁的logic bean
ReadWriteLockLogic lockOperator = new ReadWriteLockLogic();

//3 生成一个可执行任务(该任务执行完毕可以返回结果或者抛出异常；而Runnable接口的run方法则不行)
Runnable writeTask1 = new WriteTask(lockOperator, "作者A");

//4 延时0秒后每2秒重复执行writeTask1;
service.scheduleAtFixedRate(writeTask1, 0, 60, TimeUnit.SECONDS);

    //5 创建3个读任务
    Runnable readTask1 = new ReadTask(lockOperator, "读者A");
    Runnable readTask2 = new ReadTask(lockOperator, "读者B");
    Runnable readTask3 = new ReadTask(lockOperator, "读者C");

    //6 延时0秒后每秒执行一次task1;
    service.scheduleAtFixedRate(readTask1, 1, 1, TimeUnit.SECONDS);
    service.scheduleAtFixedRate(readTask2, 2, 1, TimeUnit.SECONDS);
    service.scheduleAtFixedRate(readTask3, 3, 1, TimeUnit.SECONDS);

}
}
========================= 1.4 end ==========================

输出示例：
作者A write ===Thread[pool-1-thread-1,5,main]
读者C read:Thread[pool-1-thread-3,5,main] : hehehhe_0
读者B read:Thread[pool-1-thread-4,5,main] : hehehhe_0
读者A read:Thread[pool-1-thread-2,5,main] : hehehhe_0
读者C read:Thread[pool-1-thread-3,5,main] : hehehhe_0
读者B read:Thread[pool-1-thread-4,5,main] : hehehhe_0
读者B read:Thread[pool-1-thread-4,5,main] : hehehhe_0
读者C read:Thread[pool-1-thread-3,5,main] : hehehhe_0
读者A read:Thread[pool-1-thread-2,5,main] : hehehhe_0
作者A write ===Thread[pool-1-thread-1,5,main]
读者B read:Thread[pool-1-thread-4,5,main] : hehehhe_0 hehehhe_1
读者C read:Thread[pool-1-thread-3,5,main] : hehehhe_0 hehehhe_1

一旦有 "作者A write === ..." 在后台输出,表明开始了写操作, 在写过程中读者处于等待中, 后台无输出, 直到写任务执行完毕。