Lock&Condition

package com.ixhong.base.thread;

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

public class ThreeConditionCommunication {

   /**
    * @param args
*/
public static void main(String[] args) {

      final Business business = new Business();
      new Thread(
            new Runnable() {

               @Override
public void run() {

                  for(int i=1;i<=50;i++){
                     business.sub2(i);
                  }

               }
            }
      ).start();

      new Thread(
            new Runnable() {

               @Override
public void run() {

                  for(int i=1;i<=50;i++){
                     business.sub3(i);
                  }

               }
            }
      ).start();    

      for(int i=1;i<=50;i++){
         business.main(i);
      }

   }

   static class Business {
         Lock lock = new ReentrantLock();
         Condition condition1 = lock.newCondition();
         Condition condition2 = lock.newCondition();
         Condition condition3 = lock.newCondition();
        private int shouldSub = 1;
        public  void sub2(int i){
           lock.lock();
           try{
              while(shouldSub != 2){
                 try {
                  condition2.await();
               } catch (Exception e) {
                  // TODO Auto-generated catch block
e.printStackTrace();
               }
              }
               for(int j=1;j<=10;j++){
                  System.out.println("sub2 thread sequence of " + j + ",loop of " + i);
               }
              shouldSub = 3;
              condition3.signal();
           }finally{
              lock.unlock();
           }
        }

        public  void sub3(int i){
           lock.lock();
           try{
              while(shouldSub != 3){
                 try {
                  condition3.await();
               } catch (Exception e) {
                  // TODO Auto-generated catch block
e.printStackTrace();
               }
              }
               for(int j=1;j<=20;j++){
                  System.out.println("sub3 thread sequence of " + j + ",loop of " + i);
               }
              shouldSub = 1;
              condition1.signal();
           }finally{
              lock.unlock();
           }
        }         

        public  void main(int i){
           lock.lock();
           try{
             while(shouldSub != 1){
                  try {
                     condition1.await();
                  } catch (Exception e) {
                     // TODO Auto-generated catch block
e.printStackTrace();
                  }
               }
               for(int j=1;j<=100;j++){
                  System.out.println("main thread sequence of " + j + ",loop of " + i);
               }
               shouldSub = 2;
               condition2.signal();
        }finally{
           lock.unlock();
        }
     }

   }
}

原文链接:[http://wely.iteye.com/blog/2228624]

时间: 2024-10-21 11:26:36

Lock&Condition的相关文章

C++11中的mutex, lock,condition variable实现分析

本文分析的是llvm libc++的实现:http://libcxx.llvm.org/ C++11中的各种mutex, lock对象,实际上都是对posix的mutex,condition的封装.不过里面也有很多细节值得学习. std::mutex 先来看下std::mutex: 包增了一个pthread_mutex_t __m_,很简单,每个函数该干嘛就干嘛. class mutex { pthread_mutex_t __m_; public: mutex() _NOEXCEPT {__m

lock比较

本文做如下分析: IOS对于共享资源的各种处理 各种处理的性能比较 用法: 使用如下obj对象进行分析 @implementation TestClass - (void) testLog1 { NSLog(@"======Test Log1"); } - (void) testLog2 { NSLog(@"=======Test Log2"); } @end NSLock用法: 必须和解锁unLock方法成对出现,如 lock unlock,不能出现lock lo

Java并发控制机制详解

在一般性开发中,笔者经常看到很多同学在对待java并发开发模型中只会使用一些基础的方法.比如Volatile,synchronized.像Lock和atomic这类高级并发包很多人并不经常使用.我想大部分原因都是来之于对原理的不熟悉导致的.在繁忙的开发工作中,又有谁会很准确的把握和使用正确的并发模型呢? 所以最近基于这个思想,作者打算把并发控制机制这部分整理成一篇文章.既是对自己掌握知识的一个回忆,也是希望这篇讲到的内容能帮助到大部分开发者. 并行程序开发不可避免地要涉及多线程.多任务的协作和数

java开发中几种常见的线程池

线程池 java.util.concurrent:Class Executors 常用线程池 几种常用的的生成线程池的方法: newCachedThreadPool newFixedThreadPool newScheduledThreadPool newSingleThreadExecutor newSingleThreadScheduledExecutor 例子:newFixedThreadPool ExecutorService threadPool = Executors.newFixe

Python标准库08 多线程与同步 (threading包)

原文:Python标准库08 多线程与同步 (threading包) 作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明.谢谢!   Python主要通过标准库中的threading包来实现多线程.在当今网络时代,每个服务器都会接收到大量的请求.服务器可以利用多线程的方式来处理这些请求,以提高对网络端口的读写效率.Python是一种网络服务器的后台工作语言 (比如豆瓣网),所以多线程也就很自然被Python语言支持. (关于多线程的原理和

深入理解Java线程编程中的阻塞队列容器_基础知识

1. 什么是阻塞队列? 阻塞队列(BlockingQueue)是一个支持两个附加操作的队列.这两个附加的操作是:在队列为空时,获取元素的线程会等待队列变为非空.当队列满时,存储元素的线程会等待队列可用.阻塞队列常用于生产者和消费者的场景,生产者是往队列里添加元素的线程,消费者是从队列里拿元素的线程.阻塞队列就是生产者存放元素的容器,而消费者也只从容器里拿元素. 阻塞队列提供了四种处理方法: 抛出异常:是指当阻塞队列满时候,再往队列里插入元素,会抛出IllegalStateException("Q

Java并发控制机制详解_java

在一般性开发中,笔者经常看到很多同学在对待java并发开发模型中只会使用一些基础的方法.比如Volatile,synchronized.像Lock和atomic这类高级并发包很多人并不经常使用.我想大部分原因都是来之于对原理的不属性导致的.在繁忙的开发工作中,又有谁会很准确的把握和使用正确的并发模型呢? 所以最近基于这个思想,本人打算把并发控制机制这部分整理成一篇文章.既是对自己掌握知识的一个回忆,也是希望这篇讲到的类容能帮助到大部分开发者.  并行程序开发不可避免地要涉及多线程.多任务的协作和

Java并发控制机制学习笔记

在一般性开发中,笔者经常看到很多同学在对待java并发开发模型中只会使用一些基础的方法.比如volatile,synchronized.像Lock和atomic这类高级并发包很多人并不经常使用.我想大部分原因都是来之于对原理的不属性导致的.在繁忙的开发工作中,又有谁会很准确的把握和使用正确的并发模型呢? 所以最近基于这个思想,本人打算把并发控制机制这部分整理成一篇文章.既是对自己掌握知识的一个回忆,也是希望这篇讲到的类容能帮助到大部分开发者. 并行程序开发不可避免地要涉及多线程.多任务的协作和数

Java 高并发五:JDK并发包1详细介绍_java

在[高并发Java 二] 多线程基础中,我们已经初步提到了基本的线程同步操作.这次要提到的是在并发包中的同步控制工具. 1. 各种同步控制工具的使用 1.1 ReentrantLock ReentrantLock感觉上是synchronized的增强版,synchronized的特点是使用简单,一切交给JVM去处理,但是功能上是比较薄弱的.在JDK1.5之前,ReentrantLock的性能要好于synchronized,由于对JVM进行了优化,现在的JDK版本中,两者性能是不相上下的.如果是简