【Java多线程与并发库】10.java5的线程锁(读写锁)技术

最新推荐文章于 2022-09-18 17:55:58 发布
最新推荐文章于 2022-09-18 17:55:58 发布
阅读量1.8k 收藏
点赞数
分类专栏： Java线程与并发 Java多线程与并发库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/acmman/article/details/52902128
版权
Lock&Condition实现线程同步通信

(1)Lock概念
Lock比传统线程模型中的synchronized方式更加面向对象，与生活中的锁类似，
锁本身也是一个对象。两个线程执行的代码片段要实现同步互斥的效果，它们
必须用同一个Lock对象。锁是加在代表要操作的资源的类的内部方法中，而不是
线程代码中！

例子: 
package cn.edu.hpu.test;

public class LockTest {
	public static void main(String[] args) {
		new TraditionalThreadSynchronized().init();
	}
	
	public void init(){


		final Outputer outputer=new Outputer();
		
		new Thread(new Runnable(){
			public void run() {
				while(true){
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("ABCDEFGHIJKLNOPQRST");
				}
			}
		}	
		).start();
		
		new Thread(new Runnable(){
			public void run() {
				while(true){
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("abcdefghijklmnopqrst");
				}
			}
		}	
		).start();
	}
	
	class Outputer{
		public void output(String name){
			int len=name.length();
			for (int i = 0; i < len; i++) {
				System.out.print(name.charAt(i));
			}
			System.out.println();
		}
	}
}
这段代码是没有加锁的，所以会发生在打印某个线程的数据的时候，内存会突然让给其它线程
去打印数据，导致数据只打印一半:



加锁: 
package cn.edu.hpu.test;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockTest {
	public static void main(String[] args) {
		new TraditionalThreadSynchronized().init();
	}
	
	public void init(){


		final Outputer outputer=new Outputer();
		
		new Thread(new Runnable(){
			public void run() {
				while(true){
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("ABCDEFGHIJKLNOPQRST");
				}
			}
		}	
		).start();
		
		new Thread(new Runnable(){
			public void run() {
				while(true){
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("abcdefghijklmnopqrst");
				}
			}
		}	
		).start();
	}
	
	class Outputer{
		Lock lock = new ReentrantLock();//创建一个锁
		public void output(String name){
			int len=name.length();
			lock.lock();//上锁
			try {
				for (int i = 0; i < len; i++) {
					System.out.print(name.charAt(i));
				}
				System.out.println();
			}finally{
				//这么做是防止线程死掉大家都进不去
				lock.unlock();//开锁
			}
		}
	}
}

加锁之后所有的线程都不会被打断:


(2)读写锁
读写锁:分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，写锁与写锁互斥，
这是由JVM自己控制的，你只要加好相应的锁即可。如果代码只读数据，可以很
多人同时读，但是不能同时写，那就加读锁；如果代码修改数据，只能有一个人
在写，且不能同时读取，那就加写锁。总之，读的时候加读锁，写的时候加写锁。

读写锁例子:
产生三个线程，用来读数据，然后产生另外三个线程，用来写数据。如果不加线程锁，
我们就会看到读和写的线程交替运行，也即是“读中有写，写中有读”。 
package cn.edu.hpu.test;

import java.util.Random;
import java.util.concurrent.locks.ReentrantReadWriteLock;


public class ReadWriteLockTest {
	public static void main(String[] args) {
		final Queue q = new Queue();
		for (int i = 0; i < 3; i++) {
			new Thread(){
				public void run(){
					while(true){
						q.get();
					}
				}
			}.start();
			
			new Thread(){
				public void run(){
					while(true){
						q.put(new Random().nextInt(10000));
					}
				}
			}.start();
		}
	}
}


class Queue{
	private Object data = null;//共享数据，只有一个线程能写该数据，但可以有多个线程同时读该数据
	public void get(){
		System.out.println(Thread.currentThread().getName().toString()+"准备读取数据");
		try {
			Thread.sleep((long)Math.random()*1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName().toString()+"读取数据："+data);
	}
	
	public void put(Object data){
		System.out.println(Thread.currentThread().getName().toString()+"准备改写数据");
		try {
			Thread.sleep((long)Math.random()*1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		this.data=data;
		System.out.println(Thread.currentThread().getName().toString()+"改写数据为："+data);
	}
}

效果:

可以看到，在线程5准备改写数据的时候，线程1去改写了数据，然后等线程1准备改写数据
的时候，线程5去改写了数据，此时对于变量data是线程不安全的。


如果我们上了读写锁，读的时候没有写，写的时候没有读和其它写，
即是“读中无写，写中无读写”。 
package cn.edu.hpu.test;

import java.util.Random;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockTest {
	public static void main(String[] args) {
		final Queue q = new Queue();
		for (int i = 0; i < 3; i++) {
			new Thread(){
				public void run(){
					while(true){
						q.get();
					}
				}
			}.start();
			
			new Thread(){
				public void run(){
					while(true){
						q.put(new Random().nextInt(10000));
					}
				}
			}.start();
		}
	}
}


class Queue{
	private Object data = null;//共享数据，只有一个线程能写该数据，但可以有多个线程同时读该数据
	private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
	public void get(){
		rwl.readLock().lock();
		try {
			System.out.println(Thread.currentThread().getName().toString()+"准备读取数据");
			Thread.sleep((long)Math.random()*1000);
			System.out.println(Thread.currentThread().getName().toString()+"读取数据："+data);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}finally{
			rwl.readLock().unlock();
		}
	}
	
	public void put(Object data){
		rwl.writeLock().lock();
		try {
			System.out.println(Thread.currentThread().getName().toString()+"准备改写数据");
			Thread.sleep((long)Math.random()*1000);
			this.data=data;
			System.out.println(Thread.currentThread().getName().toString()+"改写数据为："+data);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}finally{
			rwl.writeLock().unlock();
		}
	}
}
结果:

可以看到，当一个线程去写的时候，永远都不会被读取动作或者改写动作打断，而当一个线程
去读取的时候，永远都不会被改写动作打断，但是可以被另外的读取动作打断，这是合理的。


这里，大家看一下JavaAPI给我们的一个读写锁的例子: 
public class CacheData {
    Object data;
    volatile boolean cacheValid;
    ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    
    void processCacheData(){
    	rwl.readLock().lock();
    	if(!cacheValid){//是否有缓存可用
    		//在加写锁之前必须释放读锁
    		rwl.readLock().unlock();
    		rwl.writeLock().lock();
    		//再次检查一下校验状态，以防止有其他线程修改
    		if(!cacheValid){
    			data=... //去真实的库中取值
    			cacheValid=true;
    		}
    		//在释放写锁之前要加读锁
    		rwl.readLock().lock();
    		rwl.writeLock().unlock();
    	}
    	
    	use(data);//直接取缓存来使用
    	rwl.readLock().unlock();
    }
}

看起来像是一个多个线程操作缓存数据的代码。在hibernate的二级缓存中出现过类似思想，
例如:
User user = session.get(id,User.class);
User user = session.load(id,User.class);
上下的区别是:
上面的是直接从数据库中把相应id的user数据取出来封装到User对象中去，
如果没有这个数据，返回的值是null;
下面是，不管数据库中有没有这个记录，都会得到一个User对象代理，实际
就是User$Proxy，该代理大概长这个样子(伪代码): 
User$Proxy extends User{
    private Integer id = id;


    User realUser = null;
    getName(){
       if(realUser == null){
           realUser = session.get(id);
           if(realUser == null) throw exception;
       }    
       return realUser;
    }
}

即是，当真正的User不存在的时候，代理User从数据中去取数据，如果下次请求，
代理发现之前去过，就把缓存数据提供出去。

(3)缓存系统模拟
接下来我们通过使用读写锁，自己设计一个缓存系统。 
package cn.edu.hpu.test;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class CacheDemo {
	
	private Map<String,Object> cache=new HashMap<String,Object>();//缓存池
	private ReadWriteLock rwl=new ReentrantReadWriteLock();
	
	public static void main(String[] args) {
		CacheDemo cacheDemo=new CacheDemo();
		System.out.println("第一次取数据结果:"+cacheDemo.getData("1"));
		System.out.println("第二次取数据结果:"+cacheDemo.getData("1"));
	}
	
	public Object getData(String key){
		rwl.readLock().lock();
		Object value = null;
		try {
			value = cache.get(key);//先去缓存中去取
			if (value == null) {
				rwl.readLock().unlock();
				rwl.writeLock().lock();
				
				try {
					if(value == null){
						value = MySqlDB.getData(key);//实际去数据库取数据
						cache.put(key, value);
					}
				} catch (Exception e) {
					e.printStackTrace();
				}finally{
					rwl.writeLock().unlock();
				}
				rwl.readLock().lock();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			rwl.readLock().unlock();
		}
		return value;
	}
}


class MySqlDB{
	
	public static Object getData(String key) throws InterruptedException{


		Object data=null;
		
		System.out.println("获取数据库连接...");
		Thread.sleep(2000);
		System.out.println("开启事务...");
		Thread.sleep(2000);
		System.out.println("编译sql语句...");
		Thread.sleep(2000);
		System.out.println("查找数据...");
		Thread.sleep(5000);
		System.out.println("返回数据...");
		Thread.sleep(2000);
		if(key.equals("1")){
			data=new String("张三"); 
		}
		System.out.println("关闭事务...");
		Thread.sleep(2000);
		System.out.println("关闭数据库连接...");
		Thread.sleep(2000);
		
		return data;
	}
}
结果:


这样就是实现了，当第一次取数据的时候去数据库取，后面取数据从缓存中取，

而且其中的读写都是线程绝对安全的。

转载请注明出处：http://blog.csdn.net/acmman/article/details/52902128

光仔December
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
Java多线程编程中线程锁与读写锁的使用示例
09-02
主要介绍了Java多线程编程中线程锁与读写锁的使用示例,锁是控制程序多线程并发的重要手段,需要的朋友可以参考下
Java多线程之读写锁 ReadWriteLock 使用
龚小帅的博客
07-06 1108
简单说就是写操作加入锁，读操作也加入锁。写锁也可以称之为，读锁也可以称之为。这里我们先不过多描述，直接演示代码看效果，然后总结。先看下面这个例子：我们模拟了生活总写作者和读者之间的关系，写作者要写一本书(也就是共享资源)，然后读者可以读，这里想要模拟两个读者，两个写作者，并且还需要保证两个读者能够同时观看这本书，并且还要保证这本写的书是安全的(也就是读者和写作者不能同时发生，互斥行为) 运行结果如下： 分析上述运行结果：总结：从运行结果我们可以看出，使用传统的锁的时候，在我们读写操作中，每次只能允许一个线程
Java多线程和锁
can_chen的博客
10-07 771
文章目录1. 高并发和多线程2. synchronized 关键字3. synchronized锁和Lock锁的区别4. JMM（Java Memory Model）5. volatile关键字 1. 高并发和多线程 高并发指的是在同一时刻/短时间内接收到大量的请求，例如双十一，在12点整的时候，会有大量的用户同时进行商品下单操作，如果系统没有应对高并发的措施，那么会出现同一时刻若干请求同时落到服务器，造成服务器奔溃。 多线程是解决高并发的一种措施，但并不是一定得通过多线程去解决高并发，还可以通过消息队列，
Java多线程（5）----浅谈读写锁
cb的博客
06-24 285
是一个排他锁，这种锁在同一时刻只允许一个线程进行访问。在实际生产中，多个线程同时读一个资源是不会产生并发问题的读写锁在同一时刻可以允许多个线程访问，但是在写线程访问时，所有的读线程和其他写线程均会被阻塞。读写锁维护了一对锁，一个读锁和一个写锁，通过分离读锁和写锁来提高性能。读写锁是通过分离读锁与写锁，以实现共享读和独占写那么同步状态的设计是一个问题。读写锁使用整型变量来维护多个读线程和一个写线程的状态读写锁将变量切分成了两个部分，用高16为表示读，低16位表示写因为读写锁是一个可重入锁，所以这里的读状态统计
10-java5的线程锁技术
03-25 484
一、主要内容 jdk1.5提供的线程锁。 二、代码 import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class LockTest { public static void main(String[] args) { new Loc
Java多线程，锁(CAS,synchronized,AQS，ReentrantLock)
m0_49184077的博客
09-18 261
Java多线程，锁(CAS,synchronized,AQS，ReentrantLock)个人笔记详解。
Java并发编程之重入锁与读写锁
08-29
主要介绍了Java并发编程之重入锁与读写锁,文中相关实例代码详细，测试可用，具有一定参考价值，需要的朋友可以了解下。
举例说明Java多线程编程中读写锁的使用
12-26
以下示例为 java api并发库中 ReentrantReadWriteLock自带的实例，下面进行解读 class CachedData { Object data; volatile boolean cacheValid; ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();...
详解java多线程的同步控制
01-20
同步控制是并发程序必不可少的重要手段，本文我们将通过重入锁、读写锁、信号量、倒计数器和循环栅栏以及他们的实例来介绍Java并发程序中的同步控制。 目录线程安全 Thread Safety重入锁 ReentrantLock读写锁 ...
java多线程编程_java多线程_
09-29
1.讲解了Java多线程的基础， 包括Thread类的核心API的使用。2.讲解了在多线程中对并发访问的控制， 主要就是synchronized的使用， 由于此关键字在使用上非常灵活， 所以书中用了很多案例来介绍此关键字的使用， 为...
张孝祥老师讲解java的多线程的配套ppt
04-16
张孝祥老师讲解java的多线程的配套ppt，很实用的
多线程 10 java5的线程锁技术
qq_35524586的博客
12-12 148
public class ReadWriteLockTest {     public static void main(String[] args){        final Queue3 queue3 = new Queue3();        for(int i=0;i&lt;3;i++){            new Thread(new Runnable() {     ...
Java高并发编程：线程锁技术
JackChan
10-24 5272
这里介绍了java5中的线程锁技术：Lock和Condition，实现线程间的通信，其中的读锁和写锁的使用通过一个缓存系统进行了演示，对于Condition的应用通过 一个阻塞队列进行演示
java多线程之线程并发库读写锁技术的妙用
吹雪的专栏
11-19 3260
读写锁,分为读锁和写锁,多个读锁不互斥,读锁和写锁互斥,写锁与写锁互斥,这是JVM自己控制的,你只要上好相应的锁即可,如果你的代码只读数据,可以很多人同时读,但不能同时写,那就上读锁;如果你的代码修改数据,只能有一个人在写,且不能同时读取,那就上写锁.总之,读的时候上读锁,写的时候上写锁! 看如下程序: 新建6个线程,3个线程用来读,3个线程用来写,   package javaplay....
Java多线程中锁的理解与使用
热门推荐
洪伟的专栏
10-14 4万+
锁作为并发共享数据，保证一致性的工具，在JAVA平台有多种实现(如 synchronized 和 ReentrantLock等 )
【Java多线程与并发库】5.线程范围内共享变量的概念与作用
程序猿之洞
10-11 2895
我们可以使用ThreadLocal实现线程范围的共享变量。 ThreadLocal的作用和目的，用于实现线程内的数据共享，即对于相同的程序代码，多个模块在 同一个线程中运行时要共享一份数据，而在另外线程中运行又共享另外一份数据。 线程范围内共享数据的示意图: 每个线程调用全局ThreadLocal对象的set方法，对相当于往其内部的map中增加一条记录，key 分别是各自
【Java多线程与并发库】18.java线程面试题1
程序猿之洞
11-10 2233
现有的程序代码模拟产生了16个日志对象，并且需要运行16秒才能打印完这些日志，请在程序 中增加4个线程去调用parseLog()方法来分头打印这16个日志对象，程序只需要运行4秒即可打印 玩这些日志对象。原始代码如下: package cn.edu.hpu.test; public class ReadTest { public static void main(String[]
java多线程与高并发
最新发布
05-19
Java多线程和高并发是Java中非常重要的概念和技术，它们可以让Java程序更加高效地利用计算机多核CPU的性能，提升程序的并发能力，提高程序的性能和响应速度。 Java的多线程机制是基于线程对象的，它允许程序同时...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

光仔December

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值