`

用Lock和Condition,实现主线程执行5次,子线程再执行10次,孙线程执行15次,如此反复5次

 
阅读更多
package test1;

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



/**
 * 用Lock和Condition,实现主线程执行5次,子线程再执行10次,孙线程执行15次,如此反复5次
 * 
 * 设计思想:
 * 业务类Business中,设计3个方法,每个方法代表主、子、孙
 * 主方法中执行5次
 * 子方法中执行10次
 * 孙方法中执行15次
 * 
 * 用lock锁住各自方法,然后用runFlag来判断是否自己执行,如果不是,则await,如果走完,则把runFlag设为下一个要执行的对象
 * 然后用condition来唤醒下一线程
 *
 */
public class CommunicationTest3 {
	
	
	public static void main(String[] args) {
		
		final Business2 business = new Business2();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				for (int i = 0; i < 5; i++) {
					business.sub2(i);
				}
			}
		}){}.start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				for (int i = 0; i < 5; i++) {
					business.sub3(i);
				}
			}
		}){}.start();
		
		for (int i = 0; i < 5; i++) {
			business.sub(i);
		}
	}
}

class Business2 {
	private int runFlag = 1;
	private Lock lock = new ReentrantLock();
	Condition c1 = lock.newCondition();
	Condition c2 = lock.newCondition();
	Condition c3 = lock.newCondition();
	
	public void sub(int i) {
		lock.lock();
		try {
			if (runFlag != 1) {
				try {
					c1.await(); // 如果不是sub1执行时,让出CPU
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
			for (int j = 0; j < 5; j++) {
				System.out.println("sub1-" + i + "下的" + j + "次");
			}
			runFlag = 2; // 执行完后,让sub执行
			c2.signal();
		} finally {
			lock.unlock();
		}
	}
	
	public void sub2(int i) {
		lock.lock();
		try {
			if (runFlag != 2) {
				try {
					c2.await(); // 如果不是sub2该执行时,让出CPU
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
			for (int j = 0; j < 10; j++) {
				System.out.println("sub2-" + i + "下的" + j + "次");
			}
			runFlag = 3; // 执行完后,让sub执行
			c3.signal();
		} finally {
			lock.unlock();
		}
	}
	
	public void sub3(int i) {
		lock.lock();
		try {
			if (runFlag != 3) {
				try {
					c3.await(); // 如果不是sub3该执行时,让出CPU
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
			for (int j = 0; j < 15; j++) {
				System.out.println("sub3-" + i + "下的" + j + "次");
			}
			runFlag = 1; // 执行完后,让sub1执行
			c1.signal();
		} finally {
			lock.unlock();
		}
	}
}

 

分享到:
评论

相关推荐

    Python线程同步的实现代码

    本文介绍Python中的线程同步对象,主要涉及 thread 和 threading 模块。...如果join()线程,那么主线程会等待子线程执行完再执行。 import threading import time def get_thread_a(): print(get thread

    多线程&&多进程.pdf

    如果希望主线程等待所有子线程完成后再执行后续操作,可以通过调用子线程的`join()`方法实现。例如: ```python t1.join() t2.join() print("主线程结束") ``` 输出结果如下: ``` t1线程执行 t2线程执行 ...

    多线程应用实例

    1. **线程异常处理**:每个线程都有自己的异常处理机制,主线程可以捕获子线程抛出的异常。 通过这个多线程应用实例,你可以实践并理解上述理论知识,比如创建和管理线程,实现线程同步,以及处理线程安全等问题。...

    c++多线程源码

    - 条件变量(`std::condition_variable`):配合`std::unique_lock&lt;std::mutex&gt;`使用,用于线程间的通信,等待特定条件满足后再继续执行。 - 读写锁(`std::shared_mutex`):在多读少写的场景下更有效,允许多个...

    iphone多线程编程

    - **条件变量(Condition Variables):**允许一个或多个线程等待某些条件发生后再继续执行。 - **信号量(Semaphores):**控制对资源的访问次数。 示例代码(使用互斥锁): ```objective-c pthread_mutex_t ...

    C_C++ 多线程编程精髓_专栏.pdf.zip

    `join()`使得主线程等待子线程结束,而`detach()`则允许子线程独立运行,主线程无需等待。 3. **线程ID与标识**:每个线程都有唯一的线程ID,用于区分系统中的不同线程。在C++中,`std::this_thread::get_id()`可以...

    Python之多线程共10页.pdf.zip

    Python之多线程是Python编程中的一个重要主题,它涉及到如何在单个进程中同时执行多个任务,从而提升程序的效率和响应速度。在Python中,多线程主要用于处理I/O密集型任务,例如网络请求、文件读写等。下面将详细...

    C++多线程demo

    - **detach()**:将线程与调用线程分离,允许主线程继续执行,而无需等待子线程。子线程将在后台运行,直到完成。 4. **线程局部存储(TLS)**: 使用`std::thread_local`关键字,可以为每个线程创建一份独立的...

    python多线程开发

    - **条件变量(Condition)**:允许线程等待特定条件满足后再继续执行,如生产者-消费者模型。 - **信号量(Semaphore)**:控制同时访问特定资源的线程数量,一般用于限制资源的并发访问。 - **事件(Event)**...

    Java并发之条件阻塞Condition的应用代码示例

    其中,子线程执行10次,然后主线程执行5次,然后再切换到子线程执行10次,如此往返执行50次。 Condition的使用时和Lock一起的,没有Lock就没法使用Condition。 在上面的代码中,我们使用ReentrantLock作为Lock对象...

    Java多线程-多线程知识点总结和企业真题

    - 使用`ReentrantLock`的`newCondition()`方法创建`Condition`对象,然后使用`await()`和`signal()`方法实现线程间的等待和通知。 5. **死锁** - **题1**:什么是死锁? - 死锁发生在两个或多个线程互相等待对方...

    专家级多线程技术

    每个进程至少包含一个主线程,可以创建多个子线程共享同一内存空间,提高资源利用率。 2. 线程生命周期:线程有新建、就绪、运行、阻塞和终止五个状态。了解这些状态以及状态之间的转换对理解和控制线程行为至关重要...

    多核程序设计Linux多线程编程.ppt

    Linux多线程编程是利用操作系统提供的接口来创建和管理多个执行流,以便在一个进程中并行执行不同的任务。在Linux中,线程被视为“轻量级进程”,与传统的进程相比,它们共享同一地址空间,因此创建和切换线程的开销...

    C++多线程编程

    C++多线程编程是现代软件开发中的一个重要领域,它允许程序同时执行多个任务,从而提高了计算效率和响应性。C++11及其后续标准引入了内置的多线程支持,使得开发者可以直接在C++中编写多线程程序。本文将深入探讨C++...

    C++:C++多线程编程

    - **注意事项**:必须确保主线程等待所有子线程执行完毕后退出,否则可能会导致子线程被异常终止。 #### 三、线程的创建与销毁 - **创建线程**: - 使用 `std::thread` 的构造函数创建新线程,并传入函数或函数...

    java多线程编程总结.pdf

    主线程是应用程序的入口点,可以通过创建Thread对象或实现Runnable接口来启动新的线程。 2. **线程的创建与启动**: - **扩展Thread类**:直接继承Thread类并重写run()方法,然后通过new Thread实例化并调用start...

    POSIX线程程序设计(中文版)[参照].pdf

    连接和分离线程决定了线程结束后资源的释放方式,连接意味着主线程等待子线程结束,而分离则允许子线程结束后立即释放资源。 互斥量(Mutex Variables)是Pthreads中用于线程同步的关键机制,确保同一时间只有一个...

    C++线程实例_C++_线程_

    使用`join()`方法可以让主线程等待子线程结束,而`detach()`则允许子线程独立运行,主线程不再关心其何时结束。未`join()`的线程会在其运行结束时自动释放资源。 7. **线程安全的函数和对象**: 有些C++库函数和...

    Python多线程机制初探.zip

    - **线程结束**:线程执行完毕或主动退出(`thread.exit()`),或主线程结束,子线程也会被强制结束。 7. **线程优先级** - Python的`threading`模块不直接支持线程优先级,但在某些平台上,可以通过`Thread....

    Java多线程编程中使用Condition类操作锁的方法详解

    子线程修改`bool`值后,调用`condition.signal()`唤醒主线程,此时主线程能够重新获得锁并继续执行。 这样的设计提高了代码的可读性和灵活性,避免了使用`synchronized`和`wait/notify`组合时可能出现的死锁、竞争...

Global site tag (gtag.js) - Google Analytics