认识多线程：线程交序执行/Condition

最新推荐文章于 2022-03-26 07:50:31 发布

斩天拔剑书

最新推荐文章于 2022-03-26 07:50:31 发布

阅读量156

点赞数

分类专栏： java编程思想

本文链接：https://blog.csdn.net/woailuo23/article/details/97612770

版权

java编程思想专栏收录该内容

18 篇文章 0 订阅

订阅专栏

本文介绍了一个使用Java实现的多线程程序，该程序通过3个线程A、B、C轮流打印ID，确保输出结果有序。利用ReentrantLock和Condition实现线程间的等待与唤醒，确保线程A打印5次后，线程B打印15次，最后线程C打印20次。

摘要由CSDN通过智能技术生成

编写一个程序，开启 3 个线程，这三个线程的 ID 分别为 A、B、C，每个线程将自己的 ID 在屏幕上打印 10 遍，要求输出的结果必须按顺序显示，以下代码供参考，它实现了线程的等待与唤醒，实现结果循环20次的执行3个线程，线程A打印5次，线程B打印15次，线程C打印20次

1 Condition能够支持不响应中断，而通过使用Object方式不支持；
2 Condition能够支持多个等待队列（new 多个Condition对象），而Object方式只能支持一个；
3 Condition能够支持超时时间的设置，而Object不支持

package com.pccc.pactera.juc01;

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

/**
 * 编写一个程序，开启 3 个线程，这三个线程的 ID 分别为 A、B、C，每个线程将自己的 ID 在屏幕上打印 10 遍，要 求输出的结果必须按顺序显示
 * 
 * @author zhao
 * 
 */
public class TestABCAlternate {

	public static void main(String[] args) {
		// 使用匿名内部类，隐式调用外部变量，外部变量需要final修饰。
		final AlternateDemo ad = new AlternateDemo();

		new Thread(new Runnable() {
			@Override
			public void run() {
				for (int i = 1; i <= 20; i++) {
					ad.loopA(i);
				}
			}
		}, "A").start();

		new Thread(new Runnable() {
			@Override
			public void run() {
				for (int i = 1; i <= 20; i++) {
					ad.loopB(i);
				}
			}
		}, "B").start();

		new Thread(new Runnable() {
			@Override
			public void run() {
				for (int i = 1; i <= 20; i++) {
					ad.loopC(i);
					System.out.println("-------------");
				}
			}
		}, "C").start();

	}
}

class AlternateDemo {
	private int number = 1;// 当前正在执行线程的标记
	private Lock lock = new ReentrantLock();
	private Condition condition1 = lock.newCondition();
	private Condition condition2 = lock.newCondition();
	private Condition condition3 = lock.newCondition();

	public void loopA(int totalLoop) {// totalLoop循环次数
		lock.lock();
		try {
			// 1 判断
			if (number != 1) {
				condition1.await();//等待
			}
			// 2 打印
			for (int i = 1; i <= 5; i++) {
				System.out.println(Thread.currentThread().getName() + "\t" + i
						+ "\t" + totalLoop);
			}
			// 3 唤醒
			number = 2;
			condition2.signal();//唤醒
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}

	public void loopB(int totalLoop) {// totalLoop循环轮次
		lock.lock();
		try {
			// 1 判断
			if (number != 2) {
				condition2.await();//等待
			}
			// 2 打印
			for (int i = 1; i <= 15; i++) {
				System.out.println(Thread.currentThread().getName() + "\t" + i
						+ "\t" + totalLoop);
			}
			// 3 唤醒
			number = 3;
			condition3.signal();//唤醒
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}

	public void loopC(int totalLoop) {// totalLoop循环次数
		lock.lock();
		try {
			// 1 判断
			if (number != 3) {
				condition3.await();//等待
			}
			// 2 打印
			for (int i = 1; i <= 20; i++) {
				System.out.println(Thread.currentThread().getName() + "\t" + i
						+ "\t" + totalLoop);
			}
			// 3 唤醒
			number = 1;
			condition1.signal();//唤醒
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}

}

熟悉理解Lock与Condition的使用。

注意点：使用匿名内部类，隐式调用外部变量，外部变量需要final修饰。所以在main方法中创建对象需要用final修饰