举例说明Java多线程编程中读写锁的使用

2024-09-28 04:36:53

以下示例为 java api并发库中 ReentrantReadWriteLock自带的实例，下面进行解读

 class CachedData {
  Object data;
  volatile boolean cacheValid;
  ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

  void processCachedData() {
   rwl.readLock().lock();//@1
   if (!cacheValid) {
    // Must release read lock before acquiring write lock
    rwl.readLock().unlock();//@4
    rwl.writeLock().lock();//@2
    // Recheck state because another thread might have acquired
    //  write lock and changed state before we did.
    if (!cacheValid) {//@3
     data = ...
     cacheValid = true;
    }
    // Downgrade by acquiring read lock before releasing write lock
    rwl.readLock().lock();
    rwl.writeLock().unlock(); // Unlock write, still hold read
   }

   use(data);
   rwl.readLock().unlock();
  }
 }

当有n多线程使用同一CachedData 实例对象调用processCachedData方法时，就会产生线程的并发问题.
@1行，当有线程正在对数据进行写操作的时候，运行到@1行的线程要等待写操作的完成，因为第一个运行到@2的线程会加上锁，然后对数据进行需该，期间不允许任何线程进行读或者是写的操作，

当写完后，在该线程上加上读锁操作，以防止解写锁后，别的线程对数据再次进行写时出错.在第一个运行到@2的线程之后的很多线程，

可能已经运行到了@4,当对数据修改好之后，解除掉写锁，别的线程就会执行到@2，这时第一个线程已经经数据修改好了，所以有了@3的判断。

在编写多线程程序的时候,要置于并发线程的环境下考虑，巧妙的运用ReentrantReadWriteLock，在运用时，注意锁的降级，写入锁可以获得读锁，读锁不可以获得写入锁，所以在上写入锁时，必须先将读锁进行解除，然后上读锁。

使用时注意的几个方面：
　　读锁是排写锁操作的，读锁不排读锁操作，多个读锁可以并发不阻塞。即在读锁获取后和读锁释放之前，写锁并不能被任何线程获得，
　　　　　　多个读锁同时作用期间，试图获取写锁的线程都处于等待状态，当最后一个读锁释放后,试图获取写锁的线程才有机会获取写锁。
　　写锁是排写锁、排读锁操作的。当一个线程获取到写锁之后，其他试图获取写锁和试图获取读锁的线程都处于等待状态，直到写锁被释放。
写锁是可以获得读锁的，即:

　　　　　　rwl.writeLock().lock();
　　　　　　//在写锁状态中，可以获取读锁
　　　　　　rwl.readLock().lock();
　　　　　　rwl.writeLock().unlock();

　　读锁是不能够获得写锁的，如果要加写锁，本线程必须释放所持有的读锁，即:

　　　　  rwl.readLock().lock();
　　　　　　//......
　　　　　　//必须释放掉读锁，才能够加写锁
　　　　　　rwl.readLock().unlock();
　　　　　　rwl.writeLock().lock();

读写锁是线程读写同一文件所需要用到的，读写锁是什么东西在这里不做过多的解释，可以自己去百度或谷歌去搜一下。

谨在此附上我自己写的缓存系统的简单实现，你从中也能悟出缓存实现的基本思想

缓存里面有数据就从缓存中取，没有就给你从其他地方得到。

package cn.com.scl.cache 

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
 * 缓存的实现，每个线程只能获得他自己的缓存，也应该是单例的
 * 本类没有去实现单例，如果需要的话可以自行去实现
 * @author scl
 *
 */
public class CacheSystem {
  private Map<String, Object> cache = new HashMap<String,Object>();
  private ReadWriteLock rwl = new ReentrantReadWriteLock();
  public Object getData(String key){
    //先从缓存中去取数据,先加上读锁
    rwl.readLock().lock();
    Object obj = null;
    try{
      obj = cache.get(key);
      if(obj == null){
        //先解除读锁，在上写锁(必须先解除读锁才能成功上写锁)
        rwl.readLock().unlock();
        rwl.writeLock().lock();
        //去数据库取数据,再判断一次是否为null，因为有可能多个线程获得写锁
        try{
        if(obj == null){
          obj = new String("obj is get from db");
        }
        }finally{
          //先上读锁，然后再解除写锁（这样可以成功完成，在解除写锁前获得读锁，写锁被降级--这翻译的api上的）
          rwl.readLock().lock();
          rwl.writeLock().unlock();//解除写锁，读锁仍然持有
        }
      }
    }finally{
      rwl.readLock().unlock();
    }
    return obj;
  } 

}

Java多线程编程之读写锁ReadWriteLock用法实例

读写锁:分为读锁和写锁,多个读锁不互斥,读锁与写锁互斥,这是由jvm自己控制的,你只要上好相应的锁即可.如果你的代码只读数据,可以很多人同时读,但不能同时写,那就上读锁:如果你的代码修改数据,只能有一个人在写,且不能同时读取,那就上写锁.总之,读的时候上读锁,写的时候上写锁! 三个线程读数据,三个线程写数据示例: 可以同时读,读的时候不能写,不能同时写,写的时候不能读. 读的时候上读锁,读完解锁:写的时候上写锁,写完解锁. 注意finally解锁. package com.ljq.test.th
Java多线程编程中线程锁与读写锁的使用示例

线程锁Lock Lock 相当于当前对象的 Synchronized import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /* * Lock lock = new ReentrantLock(); * lock.lock(); lock.unLock(); * 类似于 synchronized,但不能与synchronized 混用 */ public class L
Java多线程编程中使用Condition类操作锁的方法详解

Condition的作用是对锁进行更精确的控制.Condition中的await()方法相当于Object的wait()方法,Condition中的signal()方法相当于Object的notify()方法,Condition中的signalAll()相当于Object的notifyAll()方法.不同的是,Object中的wait(),notify(),notifyAll()方法是和"同步锁"(synchronized关键字)捆绑使用的:而Condition是需要与"互斥
java多线程并发中使用Lockers类将多线程共享资源锁定

复制代码代码如下: package com.yao; import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReadWriteLock;import java.util.c
Java 多线程同步锁机制与synchronized深入解析

打个比方:一个object就像一个大房子,大门永远打开.房子里有很多房间(也就是方法).这些房间有上锁的(synchronized方法), 和不上锁之分(普通方法).房门口放着一把钥匙(key),这把钥匙可以打开所有上锁的房间.另外我把所有想调用该对象方法的线程比喻成想进入这房子某个房间的人.所有的东西就这么多了,下面我们看看这些东西之间如何作用的. 在此我们先来明确一下我们的前提条件.该对象至少有一个synchronized方法,否则这个key还有啥意义.当然也就不会有我们的这个主题了. 一
详解Java多线程编程中互斥锁ReentrantLock类的用法

0.关于互斥锁所谓互斥锁, 指的是一次最多只能有一个线程持有的锁. 在jdk1.5之前, 我们通常使用synchronized机制控制多个线程对共享资源的访问. 而现在, Lock提供了比synchronized机制更广泛的锁定操作, Lock和synchronized机制的主要区别: synchronized机制提供了对与每个对象相关的隐式监视器锁的访问, 并强制所有锁获取和释放均要出现在一个块结构中, 当获取了多个锁时, 它们必须以相反的顺序释放. synchronized机制对锁的释放是
java 多线程-锁详解及示例代码

自 Java 5 开始,java.util.concurrent.locks 包中包含了一些锁的实现,因此你不用去实现自己的锁了.但是你仍然需要去了解怎样使用这些锁. 一个简单的锁让我们从 java 中的一个同步块开始: public class Counter{ private int count = 0; public int inc(){ synchronized(this){ return ++count; } } } 可以看到在 inc()方法中有一个 synchronized(th
java多线程-读写锁原理

Java5 在 java.util.concurrent 包中已经包含了读写锁.尽管如此,我们还是应该了解其实现背后的原理. 读/写锁的 Java 实现(Read / Write Lock Java Implementation) 读/写锁的重入(Read / Write Lock Reentrance) 读锁重入(Read Reentrance) 写锁重入(Write Reentrance) 读锁升级到写锁(Read to Write Reentrance) 写锁降级到读锁(Write to
举例说明Java多线程编程中读写锁的使用

以下示例为 java api并发库中 ReentrantReadWriteLock自带的实例,下面进行解读 class CachedData { Object data; volatile boolean cacheValid; ReentrantReadWriteLock rwl = new ReentrantReadWriteLock(); void processCachedData() { rwl.readLock().lock();//@1 if (!cacheValid) { //
举例解析Java多线程编程中需要注意的一些关键点

1. 同步方法或同步代码块? 您可能偶尔会思考是否要同步化这个方法调用,还是只同步化该方法的线程安全子集.在这些情况下,知道 Java 编译器何时将源代码转化为字节代码会很有用,它处理同步方法和同步代码块的方式完全不同. 当 JVM 执行一个同步方法时,执行中的线程识别该方法的 method_info 结构是否有 ACC_SYNCHRONIZED 标记设置,然后它自动获取对象的锁,调用方法,最后释放锁.如果有异常发生,线程自动释放锁. 另一方面,同步化一个方法块会越过 JVM 对获取对象锁和异常
Java多线程编程中synchronized关键字的基础用法讲解

多线程编程中,最关键.最关心的问题应该就是同步问题,这是一个难点,也是核心. 从jdk最早的版本的synchronized.volatile,到jdk 1.5中提供的java.util.concurrent.locks包中的Lock接口(实现有ReadLock,WriteLock,ReentrantLock),多线程的实现也是一步步走向成熟化. 同步,它是通过什么机制来控制的呢?第一反应就是锁,这个在学习操作系统与数据库的时候,应该都已经接触到了.在Java的多线程程序中,当多个程序竞争同一
详解Java多线程编程中的线程同步方法

1.多线程的同步: 1.1.同步机制: 在多线程中,可能有多个线程试图访问一个有限的资源,必须预防这种情况的发生.所以引入了同步机制:在线程使用一个资源时为其加锁,这样其他的线程便不能访问那个资源了,直到解锁后才可以访问. 1.2.共享成员变量的例子: 成员变量与局部变量: 成员变量: 如果一个变量是成员变量,那么多个线程对同一个对象的成员变量进行操作,这多个线程是共享一个成员变量的. 局部变量: 如果一个变量是局部变量,那么多个线程对同一个对象进行操作,每个线程都会有一个该局部变量的拷贝.他们
Java多线程编程中synchronized线程同步的教程

0.关于线程同步 (1)为什么需要同步多线程? 线程的同步是指让多个运行的线程在一起良好地协作,达到让多线程按要求合理地占用释放资源.我们采用Java中的同步代码块和同步方法达到这样的目的.比如这样的解决多线程无固定序执行的问题: public class TwoThreadTest { public static void main(String[] args) { Thread th1= new MyThread1(); Thread th2= new MyThread2(); th1.st
Java多线程编程中ThreadLocal类的用法及深入

ThreadLocal,直译为"线程本地"或"本地线程",如果你真的这么认为,那就错了!其实,它就是一个容器,用于存放线程的局部变量,我认为应该叫做 ThreadLocalVariable(线程局部变量)才对,真不理解为什么当初 Sun 公司的工程师这样命名. 早在 JDK 1.2 的时代,java.lang.ThreadLocal 就诞生了,它是为了解决多线程并发问题而设计的,只不过设计得有些难用,所以至今没有得到广泛使用.其实它还是挺有用的,不相信的话,我们一起
Java多线程编程中的两种常用并发容器讲解

ConcurrentHashMap并发容器 ConcurrentHashMap可以做到读取数据不加锁,并且其内部的结构可以让其在进行写操作的时候能够将锁的粒度保持地尽量地小,不用对整个ConcurrentHashMap加锁. ConcurrentHashMap的内部结构 ConcurrentHashMap为了提高本身的并发能力,在内部采用了一个叫做Segment的结构,一个Segment其实就是一个类Hash Table的结构,Segment内部维护了一个链表数组,我们用下面这一幅图来看下Con

举例说明Java多线程编程中读写锁的使用

相关推荐

随机推荐