java线程面试题之--两个线程，子线程10次，主线程5次，子线程10次，主线程5次，如此往复50次

最新推荐文章于 2022-07-05 10:39:24 发布

转载最新推荐文章于 2022-07-05 10:39:24 发布 · 1k 阅读

文章标签：

#java

java 专栏收录该内容

53 篇文章

订阅专栏

本文提供了一个使用Java实现的线程间通信案例。通过两种方法实现：一是传统的wait和notify方式；二是利用ReentrantLock和Condition条件变量的方式。案例中主线程和子线程交替执行，实现了任务间的协调。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

package com.thread;

//两个线程，子线程10次，主线程5次，子线程10次，主线程5次，如此往复50次

//首先实现互斥，然后实现通信
public class TranditionalThreadCommunication {

	final Business business = new Business();

	public static void main(String[] args) {
		new TranditionalThreadCommunication().init();
	}

	private void init() {
		new Thread(new Runnable() {

			@Override
			public void run() {
				for(int i=0;i<50;i++)
				{
				  business.main();
				}
			}
		}).start();

		for(int i=0;i<50;i++)
		{
			business.sub();
		}
	}

	class Business {
		private Boolean isShouldSub = true;

		public synchronized void main() {
			if (!isShouldSub) {
				for (int i = 0; i < 5; i++) {
					System.out.println("主线程第" + i + "次");
				}
				isShouldSub = true;
				this.notify();
			} else {
				try {
					this.wait();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}

		public synchronized void sub() {
			if (isShouldSub) {
				for (int j = 0; j < 10; j++) {
					System.out.println("子线程第" + j + "次");
				}
				isShouldSub = false;
				this.notify();
			} else {
				try {
					this.wait();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}

利用condition和lock实现互斥和通信

package com.thread;

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

//利用condition和lock实现互斥和通信
//两个线程，子线程10次，主线程5次，子线程10次，主线程5次，如此往复50次

//首先实现互斥，然后实现通信
public class ConditionCommunication {

	final Business business = new Business();

	public static void main(String[] args) throws InterruptedException {
		new ConditionCommunication().init();
	}

	private void init() throws InterruptedException {
		new Thread(new Runnable() {

			@Override
			public void run() {
				for (int i = 0; i < 50; i++) {
					try {
						business.main();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		}).start();

		for (int i = 0; i < 50; i++) {
			business.sub();
		}
	}

	class Business {

		private Boolean isShouldSub = true;
		ReentrantLock lock = new ReentrantLock();
		Condition condition=lock.newCondition();

		public void main() throws InterruptedException {
			try {
				lock.lock();
				if (isShouldSub) {
					System.out.println("主线程等待");
					condition.await();
				} else {
					System.out.println("主线程锁上了！");
					for (int i = 0; i < 5; i++) {
						System.out.println("主线程第" + i + "次");
					}
					isShouldSub = true;
					condition.signal();
				}
			} finally {
				System.out.println("主线程解锁");
				lock.unlock();
			}

		}

		public void sub() throws InterruptedException {
			try {
				lock.lock();
				if (!isShouldSub) {
					System.out.println("子线程等待");
					condition.await();
				} else {
					System.out.println("子线程锁上了！");
					for (int j = 0; j < 10; j++) {
						System.out.println("子线程第" + j + "次");
					}
					isShouldSub = false;
					condition.signal();
				}
			} finally {
				System.out.println("子线程解锁");
				lock.unlock();
			}
		}
	}
}