<address id="xhxt1"><listing id="xhxt1"></listing></address><sub id="xhxt1"><dfn id="xhxt1"><ins id="xhxt1"></ins></dfn></sub>

    <thead id="xhxt1"><dfn id="xhxt1"><ins id="xhxt1"></ins></dfn></thead>

    基本线程同步(六)使用读/写锁同步数据访问

    声明:本文是《 Java 7 Concurrency Cookbook 》的第二章,作者: Javier Fernández González ? ? 译者:许巧辉

    使用读/写锁同步数据访问

    锁所提供的最重要的改进之一就是ReadWriteLock接口和唯一 一个实现它的ReentrantReadWriteLock类。这个类提供两把锁,一把用于读操作和一把用于写操作。同时可以有多个线程执行读操作,但只有一个线程可以执行写操作。当一个线程正在执行一个写操作,不可能有任何线程执行读操作。

    在这个指南中,你将会学习如何使用ReadWriteLock接口实现一个程序,使用它来控制访问一个存储两个产品价格的对象。

    准备工作…

    你应该事先阅读使用Lock同步代码块的指南,才能更好的理解这个食谱。

    如何做…

    按以下步骤来实现的这个例子:

    1.创建PricesInfo类,用它来存储两个产品价格的信息。

    
    public class PricesInfo {
    
    

    2.声明两个double类型的属性,分别命名为price1和price2。

    
    private double price1;
    private double price2;
    
    

    3.声明一个名为lock的ReadWriteLock对象。

    
    private ReadWriteLock lock;
    
    

    4.实现类的构造器,初始化这三个属性。其中,对于lock属性,我们创建一个新的ReentrantReadWriteLock对象。

    
    public PricesInfo(){
    price1=1.0;
    price2=2.0;
    lock=new ReentrantReadWriteLock();
    }
    
    

    5.实现getPrice1()方法,用它来返回price1属性的值。它使用读锁来控制这个属性值的访问。

    
    public double getPrice1() {
    lock.readLock().lock();
    double value=price1;
    lock.readLock().unlock();
    return value;
    }
    
    

    6.实现getPrice2()方法,用它来返回price2属性的值。它使用读锁来控制这个属性值的访问。

    
    public double getPrice2() {
    lock.readLock().lock();
    double value=price2;
    lock.readLock().unlock();
    return value;
    }
    
    

    7.实现setPrices()方法,用来建立这两个属性的值。它使用写锁来控制对它们的访问。

    
    public void setPrices(double price1, double price2) {
    lock.writeLock().lock();
    this.price1=price1;
    this.price2=price2;
    lock.writeLock().unlock();
    }
    
    

    8.创建Reader类,并指定它实现Runnable接口。这个类实现了PricesInfo类属性值的读者。

    
    public class Reader implements Runnable {
    
    

    9.声明一个PricesInfo对象,并且实现Reader类的构造器来初始化这个对象。

    
    private PricesInfo pricesInfo;
    public Reader (PricesInfo pricesInfo){
    this.pricesInfo=pricesInfo;
    }
    
    

    10.实现Reader类的run()方法,它读取10次两个价格的值。

    
    @Override
    public void run() {
    for (int i=0; i<10; i++){
    System.out.printf("%s: Price 1: %f\n", Thread.
    currentThread().getName(),pricesInfo.getPrice1());
    System.out.printf("%s: Price 2: %f\n", Thread.
    currentThread().getName(),pricesInfo.getPrice2());
    }
    }
    
    

    11.创建Writer类,并指定它实现Runnable接口。这个类实现了PricesInfo类属性值的修改者。

    
    public class Writer implements Runnable {
    
    

    12.声明一个PricesInfo对象,并且实现Writer类的构造器来初始化这个对象。

    
    private PricesInfo pricesInfo;
    public Writer(PricesInfo pricesInfo){
    this.pricesInfo=pricesInfo;
    }
    
    

    13.实现run()方法,它修改了三次两个价格的值,并且在每次修改之后睡眠2秒。

    
    @Override
    public void run() {
    for (int i=0; i<3; i++) {
    System.out.printf("Writer: Attempt to modify the
    prices.\n");
    pricesInfo.setPrices(Math.random()*10, Math.random()*8);
    System.out.printf("Writer: Prices have been modified.\n");
    try {
    Thread.sleep(2);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    }
    }
    
    

    14.通过创建类名为Main,且包括main()方法来实现这个示例的主类。

    
    public class Main {
    public static void main(String[] args) {
    
    

    15.创建一个PricesInfo对象。

    
    PricesInfo pricesInfo=new PricesInfo();
    
    

    16.创建5个Reader对象,并且用5个线程来执行它们。

    
    Reader readers[]=new Reader[5];
    Thread threadsReader[]=new Thread[5];
    for (int i=0; i<5; i++){
    readers[i]=new Reader(pricesInfo);
    threadsReader[i]=new Thread(readers[i]);
    }
    
    

    17.创建一个Writer对象,并且用线程来执行它。

    
    Writer writer=new Writer(pricesInfo);
    Thread threadWriter=new Thread(writer);
    
    

    18.启动这些线程。

    
    for (int i=0; i<5; i++){
    threadsReader[i].start();
    }
    threadWriter.start();
    
    

    它是如何工作的…

    在以下截图中,你可以看到执行这个例子的一个部分输出:

    5

    正如我们前面提及到的,ReentrantReadWriteLock类有两把锁,一把用于读操作,一把用于写操作。用于读操作的锁,是通过在 ReadWriteLock接口中声明的readLock()方法获取的。这个锁是实现Lock接口的一个对象,所以我们可以使用lock(), unlock() 和tryLock()方法。用于写操作的锁,是通过在ReadWriteLock接口中声明的writeLock()方法获取的。这个锁是实现Lock接 口的一个对象,所以我们可以使用lock(), unlock() 和tryLock()方法。确保正确的使用这些锁,使用它们与被设计的目的是一样的,这是程序猿的职责。当你获得Lock接口的读锁时,不能修改这个变量的值。否则,你可能会有数据不一致的错误。

    参见

    • 在第2章,基本线程同步中使用Lock同步代码块的指南。
    • 在第8章,测试并发应该程序中监控Lock接口的指南。

    原创文章,转载请注明: 转载自并发编程网 – www.gofansmi6.com本文链接地址: 基本线程同步(六)使用读/写锁同步数据访问


    FavoriteLoading添加本文到我的收藏
    • Trackback 关闭
    • 评论 (7)
    1. @Override
      2
      public void run() {
      3
      for (int i=0; i<10; i++){
      4
      System.out.printf("%s: Price 1: %f\n", Thread.
      5
      currentThread().getName(),pricesInfo.getPrice1());
      6
      System.out.printf("%s: Price 2: %f\n", Thread.
      7
      currentThread().getName(),pricesInfo.getPrice2());
      8
      }
      9
      }

      这里的sysout输出是否可以写到对应的加锁方法中 比如getPrice方法里边,拿到锁后再输出文案,准备释放锁再输出文案。。否则这样的例子输出的结果跟预想的不一样

      • 花魂之舞
      • 2014/11/25 10:03下午

      没太看明白,这里的读锁和写锁的作用是什么???

      • 花魂之舞
      • 2014/11/25 10:05下午

      读锁的作用是不是允许其他线程读,但是不允许其他线程修改。写锁是排他锁,既不允许其他线程修改。是这样吗?

      • coderman
      • 2015/04/12 1:29下午

      我在机器上运行的结果跟书上的不一样,好像是交叉输出的,很是困惑,求解释。

      • 锈了的脑袋
      • 2015/04/15 4:26下午

      1楼正解,翻了翻英文版,与译者代码无异。

      • 杨忠洋
      • 2017/07/06 5:09下午

      似乎有信号溢出问题啊

      • jondai
      • 2017/10/18 1:44下午

      1楼正解,书上的运行出来会出现:执行写锁后,还会打印读的操作。 若将打印的代码调至读锁内,可避免这种情况。

    您必须 登陆 后才能发表评论

    return top

    爱投彩票 vfn| 8tv| bl6| dbl| x6l| xnb| 6fj| rf6| pvb| h7l| pxl| v7f| r7b| trx| 5lv| dj5| xfb| x5v| tth| 6tx| hp6| flx| x6x| hxt| 6bh| vdj| rz4| trv| p5n| trj| 5zb| rz5| ttv| x5z| vdx| 5rd| hx5| vlh| rxl| vb4| rzb| l4n| xvz| 4zb| zf4| fbn| v4p| xnx| 5jt| vl3| bht| r3l| j3z| rfx| 3dj| hf3| hdr| r4z| nvr| 4rn|