`
Luob.
  • 浏览: 1589837 次
  • 来自: 上海
社区版块
存档分类
最新评论

jdk1.5 锁 Lock 和 Condition

    博客分类:
  • Java
阅读更多
// lock 练习
public class LockTest{


	public static void main(String[] args) {
		// TODO Auto-generated method stub
		new LockTest().init();
	}
	
	private void init(){
		final Outputer out=new Outputer();
		new Thread(
		new Runnable() {
			@Override
			public void run() {
				// TODO Auto-generated method stub
				while (true) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					out.output4("English");
				}
			}
		}
		).start();
		
		new Thread(
			new Runnable() {
				@Override
				public void run() {
					// TODO Auto-generated method stub
					while (true) {
						try {
							Thread.sleep(10);
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
						out.output4("Chinese");
					}
					
				}
			}
		).start();
		
	}
	
	//使用各种 同步锁对象   this,.class ,Object ,Lock 
	static class Outputer{
		Lock lock=new ReentrantLock();
		public void output4(String name){
			int len=name.length();
			lock.lock();   //使用 jdk 1.5 提供的锁
			try {
				for (int i = 0; i < len; i++) {
					System.out.print(name.charAt(i));
				}
				System.out.println();
			} catch (Exception e) {
				// TODO: handle exception
			}finally{
				lock.unlock();
			}
		} 
		
	}

}



//condition

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

/**
 *父子线程 交替打印10 次, 100次
 * @author Bin
 */
public class ConditionCommunication {
	static boolean isSubRun=true;
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		/*new Thread(
			 new Runnable() {
				
				@Override
				public void run() {
					int num=0;
					synchronized (TraditionalThreadCommunication.class) {
						while (num<=4) {
							if(!isSubRun){
								try {
									TraditionalThreadCommunication.class.wait();
								} catch (InterruptedException e) {
									// TODO Auto-generated catch block
									e.printStackTrace();
								}
							}
							for (int i = 0; i < 10; i++) {
								System.out.println(Thread.currentThread().getName()+" run "+i);
							}
							isSubRun=false;
							TraditionalThreadCommunication.class.notify();
							num++;
						}
					}
				}
			}
		).start();
		
		new Thread(
				new Runnable(){
					@Override
					public void run() {
						int num=0;
						while(num<=4){
							synchronized (TraditionalThreadCommunication.class) {
								if(isSubRun){
									try {
										TraditionalThreadCommunication.class.wait();
									} catch (InterruptedException e) {
										// TODO Auto-generated catch block
										e.printStackTrace();
									}
								}
								for (int i = 0; i < 100; i++) {
									System.out.println(Thread.currentThread().getName()+" run "+i);
								}
								
								isSubRun=true;
								TraditionalThreadCommunication.class.notify();
								num++;
							}
							
						}
					}
					
				}
				
		).start();*/
		
		final Business bus=new ConditionCommunication().new Business();
		new Thread(){
			@Override
			public void run() {
				for (int i = 1; i < 5; i++) {
					bus.sub(i);
				}
			}
		}.start();
		
		new Thread(new Runnable(){
			@Override
			public void run() {
				for (int i = 1; i < 5; i++) {
					bus.main(i);
				}
			}
		}).start();

	}
	
	class Business{
		Lock lock=new ReentrantLock();
		Condition condition=lock.newCondition();
		private boolean sShouldSub=true;
		public void sub(int i){  //synchronzied  有 lock 替代
			lock.lock();
			try {
				if(!sShouldSub){  //这里换成  while
					try {
						//this.wait();
						condition.await();
					} catch (Exception e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				for (int j = 1; j <= 10; j++) {
					System.out.println("Sub thread sequence of "+j+" loop of"+i);
				}
				sShouldSub=false;
				//this.notify();
				condition.signal();  
			} finally{
				lock.unlock();
			}
			
		}
		
		public void main(int i){
			lock.lock();
			try {
				while(sShouldSub){//这里换成while 比 if 更 安全 健壮 
					try {
						//this.wait();
						condition.await();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
					
				for (int j = 0; j < 100; j++) {
					System.out.println("Main thread sequence of "+j+" loop of"+i);
				}
				sShouldSub=true;
				//this.notify();
				condition.signal();
			} finally{
				lock.unlock();
			}
			
		}
		
	}

}
分享到:
评论

相关推荐

    Java JDK1.5 生产消费者模式解决方案

    在JDK 1.5及以后的版本中,Java引入了`java.util.concurrent`包,其中包含了一些强大的并发工具类,如`Lock`接口和`Condition`接口,这些工具大大提升了生产者消费者模式的实现效率和线程安全性。 生产者消费者模式...

    java中的Lock类和Condition类.docx

    在JDK 1.5及之后的版本中,Lock类作为替代synchronized关键字的一种方式出现,提供了更精细的锁管理机制。 1. **Lock类** - Lock是一个接口,其主要实现类有ReentrantLock(可重入锁)。ReentrantLock不仅具备了...

    backport-util-concurrent(2.2 /3.1)

    与synchronized不同,ReentrantLock支持公平锁和非公平锁策略,并且可以分离条件变量,这使得多路分支等待成为可能。 - Condition接口提供了等待/通知机制,允许更精确的线程同步。每个Lock实例可以有多个Condition...

    基于JDK源码解析Java领域中的并发锁之设计与实现.pdf

    本文将基于JDK源码解析Java领域中的并发锁,探讨AQS基础同步器、LockSupport、Condition接口、Lock接口、ReadWriteLock接口以及自定义API操作的设计与实现。 一、AQS(AbstractQueuedSynchronizer)基础同步器的...

    java 门锁终于被打开了(解决死锁)

    `ReentrantLock`则提供了更灵活的锁定机制,包括公平锁和非公平锁,以及尝试获取锁、定时获取锁和可中断获取锁等功能。 死锁的四个必要条件是:互斥条件、占有并等待、无剥夺和循环等待。当这四个条件都满足时,就...

    java JDK 实例开发宝典

    书中会介绍Thread类和Runnable接口,线程同步机制如synchronized关键字、wait/notify、Lock和Condition,以及线程池的使用。 6. **网络编程**:Java的Socket编程允许创建基于TCP/IP的客户端和服务端应用程序,书...

    ConditionVariablesJAVA多线程[定义].pdf

    在Java中,从JDK 1.5版本开始,引入了java.util.concurrent.locks.Condition接口,它与java.util.concurrent.locks.Lock接口一起使用,提供了一种灵活的条件变量实现。 首先,我们来理解Lock接口。Lock接口提供了一...

    深入理解java内置锁(synchronized)和显式锁(ReentrantLock)

    显式锁则是JDK 1.5引入的,提供了更加灵活和强大的同步机制。 内置锁的使用非常方便,不需要显式的获取和释放,任何一个对象都能作为一把内置锁。内置锁的使用可以解决大部分的同步场景。但是,内置锁也存在一些...

    Java并发编程解析 | 解析AQS基础同步器的设计与实现

    AQS是Java中解决同步和互斥问题的基础同步器,通过Lock和Condition两个接口来实现管程。Lock用于解决互斥问题,Condition用于解决同步问题。AQS的设计和实现是基于管程技术的,管程是解决同步和互斥问题的有效方法。...

    Java多种方式实现生产者消费者模式

    在Java8中,Lock和Condition可以实现线程同步,ReentrantLock可以实现可重入锁,Condition可以实现线程之间的通信。下面是一个示例代码: ```java class ShareData2 { private int number = 0; private Lock lock...

    【BAT必备】并发编程锁面试题

    以上示例展示了如何使用ReentrantLock和Condition实现生产者消费者模式,其中涉及了锁的基本使用方法以及Condition的信号传递机制。 #### 五、总结 并发编程是现代软件开发中不可或缺的一部分,正确理解和使用锁...

    Java JDK实例宝典

    全部代码出自电子工业出版社夏先波的《Java JDK实例宝典》一书,本书以J2SE 5.0为开发环境,选取Java应用的典型实例,循序渐进地介绍了Java语言的各种开发方法和技巧,实例代码注释详细规范,思路清晰。 第1章 ...

    Android多线程全新讲解[整理].pdf

    Java提供了多种机制来实现这一点,如`synchronized`关键字、`wait()`, `notify()`和`notifyAll()`方法,以及JDK 1.5之后引入的`Lock`和`Condition`接口。`ThreadLocal`类则允许在线程范围内创建独立的数据副本,实现...

    Java中ReentrantLock的使用.docx

    Java中的ReentrantLock是线程安全编程中的一种高级锁机制,它属于Lock接口的一个实现,提供了比synchronized更丰富的功能和更高的灵活性。ReentrantLock的名字来源于它的可重入性,这意味着一个线程可以多次获取同一...

    java_JDK_实例开发宝典

    通过实例,读者可以学习如何创建和管理线程,理解线程同步和通信的概念,如synchronized关键字、wait()和notify()方法,以及Lock接口和Condition类的使用。 5. **网络编程**:Java的Socket编程允许开发者创建网络...

    JDK_API_1_6_zh_CN.rar_API_JDK_API_1_6_zh_CN_java 6 api_java api_

    3. **多线程**:Java 6对多线程的支持非常完善,Thread类和Runnable接口是实现并发的基础,还包括Synchronized关键字、Lock接口和Condition等高级并发工具。 4. **网络编程**:Socket和ServerSocket类提供了TCP/IP...

    关于线程的例子

    3. `Lock`和`Condition`:从Java 5开始引入,提供了更细粒度的控制,比如可重入锁(`ReentrantLock`)和条件(`Condition`),可以实现更灵活的线程同步。 在Eclipse3.3和MyEclipse6这样的开发环境中,可以方便地调试和...

    多线程问题

    例如,在JDK 1.5中引入了新的并发API,并在后续版本中持续改进和优化了这些并发工具,使得Java并发编程变得更加简便和安全。 总之,Java多线程编程极大地增强了程序处理并发任务的能力,但是在享受多线程带来的好处...

Global site tag (gtag.js) - Google Analytics