`
knight_black_bob
  • 浏览: 851099 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

ReentrantLock,Condition

阅读更多

 

 

 

public class ReentrantLockAndConditionTest {

    public static void main(String[] args) {
    	ReentrantLockQueue queue =new  ReentrantLockQueue();
    	for (int i = 0; i < 100; i++) {
			queue.put("a");
			String string = queue.getString();
			System.out.println(string); 
		}
    	
	}


    public abstract class MessageQueue<T>{
    	private Queue<T> queue;
    	private List<FailedMessageWrap> resendList;
    	protected int resendSleepInterval = 1000 * 60 ;
    	protected int maxFailedCount = 10;
    	private Lock sendLock = new ReentrantLock();
    	private Condition sendCondition = sendLock.newCondition();
    	private Lock resendLock = new ReentrantLock();
    	private volatile boolean stopRequired ;
    	 
    	public MessageQueue(){ 
    		queue = new LinkedList<T>(); 
    		resendList = new LinkedList<FailedMessageWrap>(); 
    		stopRequired = false;
    		 
    		ExecutorService sendService = Executors.newFixedThreadPool(1);
    		for (int i = 0; i < 1; i++) {
    			sendService.execute(new SendTask());
    		} 
    		Executors.newSingleThreadExecutor().execute(new ResendTask());
    	}
    	 
    	public void send(T message){
    		if(message == null){
    			return;
    		}
    		
    		try {
    			sendLock.lock(); 
    			queue.add(message); 
    			sendCondition.signalAll();
    		}finally{
    			sendLock.unlock();
    		}
    		
    	}
    	 
    	public void stop(){
    		stopRequired = true;
    	}
    	 
    	protected abstract boolean doSend(T message);
    	 
    	class FailedMessageWrap{
    		private T message;
    		private int failedCount;
    		
    		FailedMessageWrap(T message){
    			this.message = message;
    			failedCount = 0;
    		}

    		public int getFailedCount() {
    			return failedCount;
    		}
     
    		public void increaseFailedCount() {
    			this.failedCount += 1;
    		}

    		public T getMessage() {
    			return message;
    		}
    		
    	}
     
    	class SendTask implements Runnable{
    		@Override
    		public void run() {
    			while(!stopRequired){
    				T message;
    				
    				try {
    					sendLock.lock(); 
    					message = queue.poll();
    					if(message == null){
    						try {
    							sendCondition.await();
    						} catch (Exception e) {
    							e.printStackTrace();
    						}
    						continue;
    					}
    				}finally{
    					sendLock.unlock();
    				}
    					
    				if(!doSend(message)){
    					try {
    						resendLock.lock(); 
    						resendList.add(new FailedMessageWrap(message));
    					} finally{
    						resendLock.unlock();
    					}
    				}
    			
    			}
    			
    		}
    	}
    	 
    	class ResendTask implements Runnable{
    		@Override
    		public void run() { 
    			while(!stopRequired){
    				
    				try {
    					Thread.sleep(resendSleepInterval);
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				} 
    				List<FailedMessageWrap> removeList = new ArrayList<FailedMessageWrap>();
    				
    				try {
    					resendLock.lock();
    					 
    					for(FailedMessageWrap messageWrap : resendList){
    						if(messageWrap.getFailedCount() > maxFailedCount){
    							removeList.add(messageWrap);
    							continue;
    						}
    						
    						T message =  messageWrap.getMessage(); 
    						if(!doSend(message)){
    							messageWrap.increaseFailedCount();
    						}else{
    							removeList.add(messageWrap);
    						}
    					}
    				 
    					for (FailedMessageWrap messageWrap : removeList) {
    						resendList.remove(messageWrap);
    					}
    				} finally{
    					resendLock.unlock();
    				}
    			
    			}
    		}
    	}
    	

    }
    
    
	
    public static class ReentrantLockQueue{
    	private ReentrantLock  lock = new ReentrantLock();
    	private Queue<String> queue = new LinkedList<String>(); 
    	public  void put(String s){
    		try{
	    		lock.lock();
	    		queue.add(s);
    		}catch(Exception e){
    			
    		}finally{
    			lock.unlock();
    		}
    	}
    	
    	public String getString(){
    		try{
    			lock.lock();
        		String poll = queue.poll();
        		return poll;
    		}catch(Exception e){
    			
    		}finally{
    			lock.unlock();
    		}
			return null;
    	}
    	
    }
	
    
    
	
	

}

 

 

 

 

 

 

 

 

 

 

 

 

 

捐助开发者 

在兴趣的驱动下,写一个免费的东西,有欣喜,也还有汗水,希望你喜欢我的作品,同时也能支持一下。 当然,有钱捧个钱场(支持支付宝和微信 以及扣扣群),没钱捧个人场,谢谢各位。

 

个人主页http://knight-black-bob.iteye.com/



 
 
 谢谢您的赞助,我会做的更好!

分享到:
评论

相关推荐

    Java多线程之ReentrantLock与Condition - 平凡希 - 博客园1

    - **Condition**:`ReentrantLock`支持多个条件变量,每个`Condition`对象都有自己的等待队列,可以实现更细粒度的同步控制。与`synchronized`的`wait()`和`notifyAll()`不同,`Condition`提供了`await()`和`signal...

    CyclicBarrier,reentrantlock,condition模拟抢票

    用CyclicBarrier,reentrantlock,condition来完成同时购买,同步购买的功能 JUC系列之模拟抢票(N人同时抢票,票不足系统补仓,N-M人继续抢票) http://blog.csdn.net/crazyzxljing0621/article/details/77891620

    java ReentrantLock详解.docx

    通过`Condition`接口,可以实现更复杂的同步控制,比如精确的等待/唤醒机制。 7. **用法示例**: - 在`ServiceIsFair`示例中,我们创建了`ReentrantLock`实例,并在`serviceMethod`中使用`lock.isFair()`检查锁的...

    Java多线程高并发篇(一)--重入锁

    `ReentrantLockCondition.java`应包含条件对象的使用示例。 5. **锁释放**:`unlock()`方法用于释放锁,必须确保在不再需要锁的时候调用,以避免死锁和其他并发问题。 6. **锁的状态检查**:`isLocked()`和`...

    Java多线程中ReentrantLock与Condition详解

    Java多线程中ReentrantLock与Condition详解 ReentrantLock是Java多线程中一种高级的锁机制,它实现了Lock接口,提供了与synchronized相同的并发性和内存语义,但添加了一些特性,如锁投票、定时锁等候和可中断锁...

    ReentrantLock与synchronized

    - 分离锁和条件:`ReentrantLock`有`Condition`接口,可以创建多个条件,每个条件对应一个等待队列,提高了线程间的协作能力。 4. **灵活性**: - 更好的控制粒度,可以只锁定需要的部分代码,提高并发效率。 - ...

    Java中ReentrantLock的使用.docx

    - Condition是ReentrantLock的重要补充,可以创建多个Condition对象,每个Condition对应一个等待队列。线程调用`await()`方法会释放锁并进入对应的等待队列,等待被`signal()`或`signalAll()`唤醒。Condition的等待...

    java多线程系列(四)ReentrantLock的使用.docx

    4. **Condition对象**:`ReentrantLock`的一个重大优势是它可以创建多个`Condition`对象,每个`Condition`对象对应一个等待队列。这样可以实现更精细化的线程通信。`condition.await()`会将线程放入对应的等待队列,...

    JavaLock与Condition的理解Reentran

    本文将深入探讨JavaLock中的ReentrantLock(可重入锁)以及与其紧密相关的Condition接口,帮助你理解它们的工作原理和应用场景。 **一、ReentrantLock可重入锁** ReentrantLock是Java.util.concurrent.locks包下的...

    locks框架_ReentrantLock.pdf

    此外,ReentrantLock还支持更高级的功能,如条件变量(Condition),这允许开发者创建独立于锁本身的等待队列,实现更复杂的同步逻辑。例如,可以使用`newCondition()`创建一个条件,然后通过`await()`和`signal()`...

    ReentrantLock源码详解--条件锁

    在上面的代码中,我们创建了一个ReentrantLock和一个Condition,然后我们启动了一个线程,该线程会等待条件成立,而另一个线程则会通知条件已成立。 Condition的await()方法 ------------------------- Condition...

    简单聊聊Synchronized和ReentrantLock锁.docx

    此外,ReentrantLock还支持锁的条件条件(Condition),使得线程可以在满足特定条件时才被唤醒,增加了灵活性。在高并发竞争环境下,ReentrantLock的性能通常优于Synchronized,因为它减少了不必要的锁同步开销。 ...

    Java多线程ReentrantLock1

    - CONDITION (-2): 节点处于某个条件队列中,等待被唤醒。 - PROPAGATE (-3): 用于可传播的节点,确保在某些操作中不会阻塞其他操作。 总结来说,ReentrantLock在Java多线程编程中扮演着关键角色,提供了灵活的锁...

    Java中的ReentrantLock类最全讲义

    ReentrantLock的基本用法 2.1 创建ReentrantLock 2.2 获取锁和释放锁 公平性与非公平性 3.1 公平锁 3.2 非公平锁 中断响应 条件变量与Condition 5.1 创建Condition 5.2 await()和signal() 可重入性 ReentrantLock与...

    java中的Lock类和Condition类.docx

    Java中的Lock类与Condition类是Java并发编程的重要组成部分,它们为多线程环境下的同步提供了更为灵活和强大的控制。在JDK 1.5及之后的版本中,Lock类作为替代synchronized关键字的一种方式出现,提供了更精细的锁...

    Java多线程 ReentrantLock互斥锁详解

    ReentrantLock可以提供更好的灵活性和可控性,例如,可以使用Condition来实现线程之间的通信。 ReentrantLock的使用场景非常广泛,例如,可以用于解决多线程访问共享资源的问题、实现线程之间的同步访问资源、避免...

    详解Java多线程编程中互斥锁ReentrantLock类的用法

    7. **可中断的等待**:与synchronized不同,使用ReentrantLock的线程可以在等待锁时被中断,通过调用Condition的await()方法进入等待状态,当其他线程调用signal()方法或线程被中断时,等待的线程会被唤醒。...

    Java concurrency之Condition条件_动力节点Java学院整理

    1. **同步锁**:`Condition`必须与一个`Lock`实例关联,如`ReentrantLock`。与`synchronized`不同,`synchronized`是基于 JVM 的内置锁,而`Condition`是基于用户层面的锁,提供更高级别的控制。 2. **等待/通知...

    深入java并发编程,使用ReentrantLock和 Synchronized加锁

    6. **锁的条件条件**:`Condition`接口提供了与`synchronized`中`wait()`和`notify()`类似的功能,但更灵活,可以创建多个条件,每个条件对应一组等待线程。 在实际开发中,选择`synchronized`还是`ReentrantLock`...

Global site tag (gtag.js) - Google Analytics