锁机制最大的改进之一就是ReadWriteLock接口和它的唯一实现类ReentrantReadWriteLock。这个类有两个锁,一个是读操作锁,另一个是写操作锁。使用读操作锁时可以允许多个线程同时访问,但是使用写操作锁时只允许一个线程进行。在一个线程执行写操作时,其他线程不能够执行读操作。

  下面我们将通过范例学习如何使用ReadWriteLock接口编写程序。这个范例将使用ReadWriteLock接口控制对价格对象的访问,价格对象存储了两个产品的价格。

1. 创建一个价格信息类PricesInfo,并且存放两个产品的价格。

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock; public class PricesInfo {
//两个价格
private double price1;
private double price2;
//声明读写锁ReadWriteLock对象lock
private ReadWriteLock lock;
public PricesInfo(){
price1 = 1.0;
price2 = 2.0;
lock = new ReentrantReadWriteLock();
} public double getPrice1(){
lock.readLock().lock();
double value = price1;
lock.readLock().unlock();
return value;
} public double getPrice2()
{
lock.readLock().lock();
double value = price2;
lock.readLock().unlock();
return value;
} public void setPrices(double price1, double price2){
lock.writeLock().lock();
this.price1 = price1;
this.price2 = price2;
lock.writeLock().unlock();
} }

2. 创建读取类Reader,它实现了Runnable接口。

public class Reader implements Runnable {
private PricesInfo pricesInfo;
public Reader(PricesInfo pricesInfo){
this.pricesInfo = pricesInfo;
}
@Override
public void run() {
// 循环读取连个价格10次
for(int i=0;i<10;i++){
System.out.printf("%s: Price1: %f\n", Thread.currentThread().getName(), pricesInfo.getPrice1());
System.out.printf("%s: Price2: %f\n", Thread.currentThread().getName(), pricesInfo.getPrice2());
} } }

3. 创建写入类Writer,它实现了Runnable接口。

public class Writer implements Runnable {
private PricesInfo pricesInfo;
public Writer(PricesInfo pricesInfo){
this.pricesInfo = pricesInfo;
}
@Override
public void run() {
// 循环修改两个价格3次
try {
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.println("Writer: Prices have been modified.");
Thread.sleep(2);
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} } }

4. 创建范例的主类Main

public class Main {

    public static void main(String[] args) {
PricesInfo pricesInfo = new PricesInfo();
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]);
}
Writer writer = new Writer(pricesInfo);
Thread threadWriter = new Thread(writer);
for(int i=0;i<5;i++){
threadsReader[i].start();
}
threadWriter.start();
}
}

5. 程序运行结果如下

Thread-1: Price1: 1.000000
Thread-4: Price1: 1.000000
Thread-2: Price1: 1.000000
Thread-2: Price2: 2.000000
Thread-2: Price1: 1.000000
Thread-2: Price2: 2.000000
Thread-0: Price1: 1.000000
Thread-0: Price2: 2.000000
Thread-0: Price1: 1.000000
Thread-0: Price2: 2.000000
Thread-0: Price1: 1.000000
Thread-0: Price2: 2.000000
Thread-0: Price1: 1.000000
Thread-0: Price2: 2.000000
Thread-0: Price1: 1.000000
Thread-0: Price2: 2.000000
Thread-0: Price1: 1.000000
Thread-0: Price2: 2.000000
Thread-0: Price1: 1.000000
Thread-0: Price2: 2.000000
Thread-0: Price1: 1.000000
Thread-0: Price2: 2.000000
Thread-0: Price1: 1.000000
Thread-0: Price2: 2.000000
Thread-0: Price1: 1.000000
Thread-0: Price2: 2.000000
Thread-2: Price1: 1.000000
Thread-2: Price2: 2.000000
Writer: Attempt to modify the prices.
Writer: Prices have been modified.
Thread-3: Price1: 1.000000
Thread-3: Price2: 4.840562
Thread-1: Price2: 2.000000
Thread-1: Price1: 6.220535
Thread-1: Price2: 4.840562
Thread-1: Price1: 6.220535
Thread-1: Price2: 4.840562
Thread-1: Price1: 6.220535
Thread-1: Price2: 4.840562
Thread-1: Price1: 6.220535
Thread-1: Price2: 4.840562
Thread-1: Price1: 6.220535
Thread-1: Price2: 4.840562
Thread-1: Price1: 6.220535
Thread-1: Price2: 4.840562
Thread-1: Price1: 6.220535
Thread-1: Price2: 4.840562
Thread-1: Price1: 6.220535
Thread-1: Price2: 4.840562
Thread-1: Price1: 6.220535
Thread-1: Price2: 4.840562
Writer: Attempt to modify the prices.
Writer: Prices have been modified.
Thread-4: Price2: 2.000000
Thread-4: Price1: 5.640719
Thread-4: Price2: 1.872038
Thread-4: Price1: 5.640719
Thread-4: Price2: 1.872038
Thread-2: Price1: 6.220535
Thread-2: Price2: 1.872038
Thread-2: Price1: 5.640719
Thread-2: Price2: 1.872038
Thread-2: Price1: 5.640719
Thread-2: Price2: 1.872038
Thread-2: Price1: 5.640719
Thread-2: Price2: 1.872038
Thread-2: Price1: 5.640719
Thread-2: Price2: 1.872038
Thread-2: Price1: 5.640719
Thread-2: Price2: 1.872038
Thread-2: Price1: 5.640719
Thread-2: Price2: 1.872038
Thread-3: Price1: 5.640719
Thread-3: Price2: 1.872038
Thread-3: Price1: 5.640719
Thread-3: Price2: 1.872038
Thread-3: Price1: 5.640719
Thread-3: Price2: 1.872038
Thread-3: Price1: 5.640719
Thread-3: Price2: 1.872038
Thread-3: Price1: 5.640719
Thread-3: Price2: 1.872038
Thread-3: Price1: 5.640719
Thread-3: Price2: 1.872038
Thread-3: Price1: 5.640719
Thread-3: Price2: 1.872038
Thread-3: Price1: 5.640719
Thread-3: Price2: 1.872038
Thread-3: Price1: 5.640719
Thread-3: Price2: 1.872038
Writer: Attempt to modify the prices.
Writer: Prices have been modified.
Thread-4: Price1: 5.491746
Thread-4: Price2: 2.729420
Thread-4: Price1: 5.491746
Thread-4: Price2: 2.729420
Thread-4: Price1: 5.491746
Thread-4: Price2: 2.729420
Thread-4: Price1: 5.491746
Thread-4: Price2: 2.729420
Thread-4: Price1: 5.491746
Thread-4: Price2: 2.729420
Thread-4: Price1: 5.491746
Thread-4: Price2: 2.729420
Thread-4: Price1: 5.491746
Thread-4: Price2: 2.729420

java读写锁实现数据同步访问的更多相关文章

  1. 线程同步——用户模式下线程同步——Slim读写锁实现线程同步

    //Slim读/写锁实现线程同步 SRWlock 的目的和关键段相同:对同一资源进行保护,不让其它线程访问. 但是,与关键段不同的是,SRWlock允许我们区分哪些想要读取资源的线程(读取者线程) 和 ...

  2. Java读写锁

    Java读写锁,ReadWriteLock.java接口, RentrantReadWriteLock.java实现.通过读写锁,可以实现读-读线程并发,读-写,写-读线程互斥进行.以前面试遇到一个问 ...

  3. Java并发指南10:Java 读写锁 ReentrantReadWriteLock 源码分析

    Java 读写锁 ReentrantReadWriteLock 源码分析 转自:https://www.javadoop.com/post/reentrant-read-write-lock#toc5 ...

  4. java 读写锁详解

    详见:http://blog.yemou.net/article/query/info/tytfjhfascvhzxcyt124 在java多线程中,为了提高效率有些共享资源允许同时进行多个读的操作, ...

  5. Java 读写锁的实现

    一.    synchronized和ReentrantLock的对比 到现在,看到多线程中,锁定的方式有2种:synchronized和ReentrantLock.两种锁定方式各有优劣,下面简单对比 ...

  6. Java读写锁(ReentrantReadWriteLock)学习

    什么是读写锁 平时,我们常见的synchronized和Reentrantlock基本上都是排他锁,这些锁在同一时刻只允许一个线程进行访问,哪怕是读操作.而读写锁是维护了一对锁(一个读锁和一个写锁), ...

  7. 从火车站车次公示栏来学Java读写锁

    Java多线程并发之读写锁 本文主要内容:读写锁的理论:通过生活中例子来理解读写锁:读写锁的代码演示:读写锁总结.通过理论(总结)-例子-代码-然后再次总结,这四个步骤来让大家对读写锁的深刻理解. 本 ...

  8. Java 读写锁 ReadWriteLock 原理与应用场景详解

    Java并发编程提供了读写锁,主要用于读多写少的场景,今天我就重点来讲解读写锁的底层实现原理@mikechen 什么是读写锁? 读写锁并不是JAVA所特有的读写锁(Readers-Writer Loc ...

  9. Java多线程学习笔记——从Java JVM对多线程数据同步的一些理解

       我们知道在多线程编程中,我们很大的一部分内容是为了解决线程间的资源同步问题和线程间共同协作解决问题.线程间的同步,通俗我们理解为僧多粥少,在粥有限情况下,我们怎么去防止大家有秩序的喝到粥,不至于 ...

随机推荐

  1. nio笔记

    http://blog.csdn.net/z69183787/article/category/2191483此人的博客 首先你要知道阻塞和非阻塞的概念,阻塞体现在这个线程不能干别的了,只能在这里等着 ...

  2. 响应式设计:根据不同设备引不同css样式

    <link rel="stylesheet" media="screen and (max-width:600px)" href="small. ...

  3. Python股票信息抓取~

    本来想把股票的涨跌抓取出来,用汇通网的股票为例,就找了国际外汇为例. 页面里有xhr请求,并且每个xhr的url请求的 http://api.q.fx678.com/history.php?symbo ...

  4. [转]Java中堆和栈创建对象的区别

    转载自http://blog.csdn.net/hbhhww/article/details/8152838 栈与堆都是Java用来在Ram中存放数据的地方.与C++不同,Java自动管理栈和堆,程序 ...

  5. SaltStack配置管理--状态间的关系(六)

    一.include的引用 需求场景:用于含有多个SLS的状态,使用include可以进行多个状态的组合,将安装apache,php,mysql集合在一个sls中 [root@7mini-node1 p ...

  6. tornado中的cookie

    1. cookie与session的区别: Session:通过在服务器端记录用户信息从而来确认用户身份,保存在服务器上,每个用户会话都有一个对应的session Cookie:通过在客户端记录信息确 ...

  7. XINCLUDE

    前言 导入外部xml文档,类似于php的include,将外部定义的dtd引入当前文件,因为引入外部实体具有局限性,所以使用xinclude来引入 语法 导入外部文档: <xi:include ...

  8. BZOJ3262陌上花开(三维偏序问题(CDQ分治+树状数组))+CDQ分治基本思想

    emmmm我能怎么说呢 CDQ分治显然我没法写一篇完整的优秀的博客,因为我自己还不是很明白... 因为这玩意的思想实在是太短了: fateice如是说道: 如果说对于一道题目的离线操作,假设有n个操作 ...

  9. java 读入文件 FileInputStream

    package com.mkyong.io; import java.io.File; import java.io.FileInputStream; import java.io.IOExcepti ...

  10. functools.wraps 带参数的装饰器 多个装饰器装饰同一个函数

    装饰器开发原则 : 开放封闭原则装饰器的作用 :在不改变原函数的调用方式的情况下,在函数的前后添加功能装饰器的本质 : 闭包函数 def wrapper(func): def inner(*args, ...