`

java读写锁ReentrantReadWriteLock的初体验

 
阅读更多
1业务要求:
消息中间件kafka即时发送消息对象,storm即时处理,数据入库频率五分钟一次;
2:开发思路
在每个jvm中使用单例对象,添加读写锁(java.util.concurrent.locks.ReentrantReadWriteLock)对象的使用,线程安全队列(java.util.concurrent.LinkedBlockingQueue<String>)对象,利用锁的特性来控制队列读写操作,达到读数据的时候 写操作堵塞。
下面贴上测试代码实现:
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author liqiankun
 *
 */
public class BlockQueue {
	
	private LinkedBlockingQueue<String> blockingQueue = new LinkedBlockingQueue<String>();
	
	private ReadWriteLock rwl = new ReentrantReadWriteLock();
	
	private static final BlockQueue QUEUE = new BlockQueue();
	private BlockQueue() {
	}
	public static BlockQueue getQueue(){
		return QUEUE;
	}
	 
	public void putData(String s){
		rwl.writeLock().lock();//取到写锁 
		try {  
            blockingQueue.offer(s);
            System.out.println(Thread.currentThread().getName() + "写入数据:" + s);  
        }catch (Exception e) {
		}
		finally {  
            rwl.writeLock().unlock();// 释放写锁  
        }
	}
	
	public void execute(){
		new Thread(){

			@Override
			public void run() {
				while(true){
					try {
						Thread.sleep(5000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					rwl.readLock().lock();
					try {
						//启动一个线程去处理数据,保证不影响下一次数据的读取操作
						new Thread(){
							private LinkedBlockingQueue<String> tempBlockingQueue = new LinkedBlockingQueue<String>();
							{
							//将blockingQueue的数据引用赋值给tempBlockingQueue
							tempBlockingQueue = blockingQueue;
							//将blockingQueue重新new出一个对象。
							blockingQueue = new LinkedBlockingQueue<String>();
							}
							@Override
							public void run() {
								while(!tempBlockingQueue.isEmpty()){
									String s = tempBlockingQueue.poll();//
									System.out.println(Thread.currentThread().getName()+"读取数据:"+s);
								}
							}
						}.start();
						
					} catch (Exception e) {
						e.printStackTrace();
					}finally{
						rwl.readLock().unlock();
					}
				}
			}
			
			
		}.start();
		
		
	}
	
}


测试类
import java.util.Random;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * @author liqiankun
 *
 */
public class TestLock {
	private  LinkedBlockingQueue<String> tempBlockingQueue = new LinkedBlockingQueue<String>();
	private  LinkedBlockingQueue<String> blockingQueue = new LinkedBlockingQueue<String>();
	private static String[] str= {"1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17","18","19","20"};
	public static void main(String[] args) {
		BlockQueue blockQueue = BlockQueue.getQueue();
		blockQueue.execute();
		
		//while(true){
			for(int i=0;i<3;i++){
				new Thread(){
					@Override
					public void run() {
						for(int j=0;j<20;j++){
							BlockQueue.getQueue().putData(Thread.currentThread().getName()+"-["+str[j]+"]");
							try {
								Thread.sleep(new Random().nextInt(100));
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						}
					}
				}.start();
				
			}
			try {
				Thread.sleep(new Random().nextInt(2000));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		//}
		/*TestLock t = new TestLock();
		t.blockingQueue.offer("1");
		t.blockingQueue.offer("2");
		t.blockingQueue.offer("3");
		t.tempBlockingQueue = t.blockingQueue;
		t.blockingQueue =  new LinkedBlockingQueue<String>();
		System.out.println("--new 对象之后--------");
		while(!t.blockingQueue.isEmpty()){
			System.out.println(t.blockingQueue.poll());
		}
		System.out.println("-----------");
		while(!t.tempBlockingQueue.isEmpty()){
			System.out.println("tempBlockingQueue"+t.tempBlockingQueue.poll());
		}
		System.out.println("-----------");
		
		 */
		
	}
}

运行结果:
Thread-1写入数据:Thread-1-[1]
Thread-2写入数据:Thread-2-[1]
Thread-3写入数据:Thread-3-[1]
Thread-1写入数据:Thread-1-[2]
Thread-2写入数据:Thread-2-[2]
Thread-3写入数据:Thread-3-[2]
Thread-1写入数据:Thread-1-[3]
Thread-2写入数据:Thread-2-[3]
Thread-3写入数据:Thread-3-[3]
Thread-3写入数据:Thread-3-[4]
Thread-1写入数据:Thread-1-[4]
Thread-2写入数据:Thread-2-[4]
Thread-3写入数据:Thread-3-[5]
Thread-3写入数据:Thread-3-[6]
Thread-2写入数据:Thread-2-[5]
Thread-3写入数据:Thread-3-[7]
Thread-1写入数据:Thread-1-[5]
Thread-2写入数据:Thread-2-[6]
Thread-3写入数据:Thread-3-[8]
Thread-2写入数据:Thread-2-[7]
Thread-1写入数据:Thread-1-[6]
Thread-3写入数据:Thread-3-[9]
Thread-3写入数据:Thread-3-[10]
Thread-1写入数据:Thread-1-[7]
Thread-2写入数据:Thread-2-[8]
Thread-3写入数据:Thread-3-[11]
Thread-2写入数据:Thread-2-[9]
Thread-2写入数据:Thread-2-[10]
Thread-1写入数据:Thread-1-[8]
Thread-3写入数据:Thread-3-[12]
Thread-2写入数据:Thread-2-[11]
Thread-3写入数据:Thread-3-[13]
Thread-1写入数据:Thread-1-[9]
Thread-1写入数据:Thread-1-[10]
Thread-1写入数据:Thread-1-[11]
Thread-2写入数据:Thread-2-[12]
Thread-3写入数据:Thread-3-[14]
Thread-1写入数据:Thread-1-[12]
Thread-1写入数据:Thread-1-[13]
Thread-1写入数据:Thread-1-[14]
Thread-2写入数据:Thread-2-[13]
Thread-3写入数据:Thread-3-[15]
Thread-1写入数据:Thread-1-[15]
Thread-2写入数据:Thread-2-[14]
Thread-3写入数据:Thread-3-[16]
Thread-1写入数据:Thread-1-[16]
Thread-3写入数据:Thread-3-[17]
Thread-3写入数据:Thread-3-[18]
Thread-2写入数据:Thread-2-[15]
Thread-2写入数据:Thread-2-[16]
Thread-2写入数据:Thread-2-[17]
Thread-1写入数据:Thread-1-[17]
Thread-1写入数据:Thread-1-[18]
Thread-3写入数据:Thread-3-[19]
Thread-2写入数据:Thread-2-[18]
Thread-1写入数据:Thread-1-[19]
Thread-3写入数据:Thread-3-[20]
Thread-2写入数据:Thread-2-[19]
Thread-1写入数据:Thread-1-[20]
Thread-2写入数据:Thread-2-[20]
Thread-4读取数据:Thread-1-[1]
Thread-4读取数据:Thread-2-[1]
Thread-4读取数据:Thread-3-[1]
Thread-4读取数据:Thread-1-[2]
Thread-4读取数据:Thread-2-[2]
Thread-4读取数据:Thread-3-[2]
Thread-4读取数据:Thread-1-[3]
Thread-4读取数据:Thread-2-[3]
Thread-4读取数据:Thread-3-[3]
Thread-4读取数据:Thread-3-[4]
Thread-4读取数据:Thread-1-[4]
Thread-4读取数据:Thread-2-[4]
Thread-4读取数据:Thread-3-[5]
Thread-4读取数据:Thread-3-[6]
Thread-4读取数据:Thread-2-[5]
Thread-4读取数据:Thread-3-[7]
Thread-4读取数据:Thread-1-[5]
Thread-4读取数据:Thread-2-[6]
Thread-4读取数据:Thread-3-[8]
Thread-4读取数据:Thread-2-[7]
Thread-4读取数据:Thread-1-[6]
Thread-4读取数据:Thread-3-[9]
Thread-4读取数据:Thread-3-[10]
Thread-4读取数据:Thread-1-[7]
Thread-4读取数据:Thread-2-[8]
Thread-4读取数据:Thread-3-[11]
Thread-4读取数据:Thread-2-[9]
Thread-4读取数据:Thread-2-[10]
Thread-4读取数据:Thread-1-[8]
Thread-4读取数据:Thread-3-[12]
Thread-4读取数据:Thread-2-[11]
Thread-4读取数据:Thread-3-[13]
Thread-4读取数据:Thread-1-[9]
Thread-4读取数据:Thread-1-[10]
Thread-4读取数据:Thread-1-[11]
Thread-4读取数据:Thread-2-[12]
Thread-4读取数据:Thread-3-[14]
Thread-4读取数据:Thread-1-[12]
Thread-4读取数据:Thread-1-[13]
Thread-4读取数据:Thread-1-[14]
Thread-4读取数据:Thread-2-[13]
Thread-4读取数据:Thread-3-[15]
Thread-4读取数据:Thread-1-[15]
Thread-4读取数据:Thread-2-[14]
Thread-4读取数据:Thread-3-[16]
Thread-4读取数据:Thread-1-[16]
Thread-4读取数据:Thread-3-[17]
Thread-4读取数据:Thread-3-[18]
Thread-4读取数据:Thread-2-[15]
Thread-4读取数据:Thread-2-[16]
Thread-4读取数据:Thread-2-[17]
Thread-4读取数据:Thread-1-[17]
Thread-4读取数据:Thread-1-[18]
Thread-4读取数据:Thread-3-[19]
Thread-4读取数据:Thread-2-[18]
Thread-4读取数据:Thread-1-[19]
Thread-4读取数据:Thread-3-[20]
Thread-4读取数据:Thread-2-[19]
Thread-4读取数据:Thread-1-[20]
Thread-4读取数据:Thread-2-[20]
把写入数据和读取数据对比之后发现,写入的顺序和读取的顺序是一致的,所以测试通过
分享到:
评论

相关推荐

    08、读写锁ReentrantReadWriteLock&StampLock详解-ev

    读写锁ReentrantReadWriteLock&StampLock详解_e读写锁ReentrantReadWriteLock&StampLock详解_e读写锁ReentrantReadWriteLock&StampLock详解_e读写锁ReentrantReadWriteLock&StampLock详解_e读写锁...

    8、读写锁ReentrantReadWriteLock&StampLock详解.pdf

    6.JUC并发工具类在大厂的应用场景详解 (1).pdf ...8、读写锁ReentrantReadWriteLock&StampLock详解.pdf 9、并发容器 (Map、List、Set) 实战及其原理.pdf 10、阻塞队列BlockingQueue 实战及其原理分析.pdf

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

    主要介绍了举例说明Java多线程编程中读写锁的使用,文中的例子很好地说明了Java的自带读写锁ReentrantReadWriteLock的使用,需要的朋友可以参考下

    Java多线程 ReentrantReadWriteLock原理及实例详解

    主要介绍了Java多线程 ReentrantReadWriteLock原理及实例详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

    Java 多线程与并发(12-26)-JUC锁- ReentrantReadWriteLock详解.pdf

    Java 多线程与并发(12_26)-JUC锁_ ReentrantReadWriteLock详解

    ReentrantReadWriteLock 源码解析

     针对这种场景,JAVA的并发包提供了读写锁ReentrantReadWriteLock,它表示两个锁,一个是读操作相关的锁,称为共享锁;一个是写相关的锁,称为排他锁 类图如下: 说明:如上图所示Sync为ReentrantReadWriteLock...

    读写锁.txt

    ReentrantLock//互斥锁 class CachedData { Object data; volatile boolean cacheValid; ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    Java concurrency之共享锁和ReentrantReadWriteLock_动力节点Java学院整理

    本篇文章主要介绍了Java concurrency之共享锁和ReentrantReadWriteLock,非常具有实用价值,需要的朋友可以参考下

    7、深入理解AQS独占锁之ReentrantLock源码分析(1).pdf

    6.JUC并发工具类在大厂的应用场景详解 (1).pdf ...8、读写锁ReentrantReadWriteLock&StampLock详解.pdf 9、并发容器 (Map、List、Set) 实战及其原理.pdf 10、阻塞队列BlockingQueue 实战及其原理分析.pdf

    【2018最新最详细】并发多线程教程

    11.深入理解读写锁ReentrantReadWriteLock 12.详解Condition的await和signal等待通知机制 13.LockSupport工具 14.并发容器之ConcurrentHashMap(JDK 1.8版本) 15.并发容器之ConcurrentLinkedQueue 16.并发容器之...

    ReentrantReadWriteLock.xmind

    ReentrantReadWriteLock 读写锁除了保证写操作对读操作可见性以及并发行提升外,简化了读写交互场景开发

    10、阻塞队列BlockingQueue实战及其原理分析.pdf

    6.JUC并发工具类在大厂的应用场景详解 (1).pdf ...8、读写锁ReentrantReadWriteLock&StampLock详解.pdf 9、并发容器 (Map、List、Set) 实战及其原理.pdf 10、阻塞队列BlockingQueue 实战及其原理分析.pdf

    9、并发容器(Map、List、Set)实战及其原理.pdf

    6.JUC并发工具类在大厂的应用场景详解 (1).pdf ...8、读写锁ReentrantReadWriteLock&StampLock详解.pdf 9、并发容器 (Map、List、Set) 实战及其原理.pdf 10、阻塞队列BlockingQueue 实战及其原理分析.pdf

    6、JUC并发工具类在大厂的应用场景详解(1).pdf

    6.JUC并发工具类在大厂的应用场景详解 (1).pdf ...8、读写锁ReentrantReadWriteLock&StampLock详解.pdf 9、并发容器 (Map、List、Set) 实战及其原理.pdf 10、阻塞队列BlockingQueue 实战及其原理分析.pdf

    Java并发编程原理与实战

    读写锁认识与原理.mp4 细读ReentrantReadWriteLock源码.mp4 ReentrantReadWriteLock锁降级详解.mp4 线程安全性问题简单总结.mp4 线程之间的通信之wait notify.mp4 通过生产者消费者模型理解等待唤醒机制.mp4 ...

    java多线程安全性基础介绍.pptx

    java多线程安全性基础介绍 线程安全 正确性 什么是线程安全性 原子性 竞态条件 i++ 读i ++ 值写回i 可见性 JMM 由于cpu和内存加载速度的差距,在两者之间增加了多级缓存导致,内存并不能直接对cpu可见。 ...

    60.Lock-ReentranLock-ReentrantReadWriteLock.mp4

    在学习Java过程中,自己收集了很多的Java的学习资料,分享给大家,有需要的欢迎下载,希望对大家有用,一起学习,一起进步。

    深入浅出ReentrantReadWriteLock源码解析.docx

    读写锁是将被锁保护的临界资源的读操作和写操作分开,允许同时有多个线程同时对临界资源进行读操作,任意时刻只允许一个线程对资源进行写操作。简单的说,对与读操作采用的是 共享锁 ,对于写操作采用的是 排他锁...

    龙果java并发编程完整视频

    第25节读写锁认识与原理00:18:04分钟 | 第26节细读ReentrantReadWriteLock源码00:30:38分钟 | 第27节ReentrantReadWriteLock锁降级详解00:13:32分钟 | 第28节线程安全性问题简单总结00:15:34分钟 | 第29节线程...

Global site tag (gtag.js) - Google Analytics