Java-两个线程轮流打印数字的问题

实现两个线程,轮流打印出数字,如下:

bThread --> 10
aThread --> 9
bThread --> 8
aThread --> 7
bThread --> 6
aThread --> 5
bThread --> 4
aThread --> 3
bThread --> 2
aThread --> 1

用java中的Lock类实现:

package com.yjq.thread_demo;

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

public class TwoThreadPrinter {

	private Lock threadLock = new ReentrantLock();

	private boolean flag = false;

	int count =10;

	Thread aThread = new Thread(new Runnable() {
		public void run() {
			while (true) {
					// 锁定
					threadLock.lock();
					try {
						if ( count < 1) {
							return;
						}
						if (flag) {
							// aThread的任务
							System.out.println("aThread --> " + (count--));
							flag = !flag;
						}
					} catch (Exception e) {
						// TODO: handle exception
					} finally {
						// 释放锁
						threadLock.unlock();
					}
				}
		}
	});

	Thread bThread = new Thread(new Runnable() {
		public void run() {
			while (true) {
					// 锁定
					threadLock.lock();
					try {
						if ( count < 1) {
							return;
						}
						if (!flag) {
							// aThread的任务
							System.out.println("bThread --> " + (count--));
							flag = !flag;
						}
					} catch (Exception e) {
						// TODO: handle exception
					} finally {
						// 释放锁
						threadLock.unlock();
				}
			}
		}
	});

	public void startTwoThread() {
		aThread.start();
		bThread.start();
	}

	public static void main(String[] args) {
		TwoThreadPrinter twoThreadPrinter = new TwoThreadPrinter();
		twoThreadPrinter.startTwoThread();
	}

}

用synchronized实现:

package com.yjq.thread_demo;

public class TwoThreadPrinter2 {

private Object threadLock = new Object();

	int count =10;

	Thread aThread = new Thread(new Runnable() {
		public void run() {
			while (true) {
					// 锁定
					synchronized (threadLock) {
						if ( count < 1) {
							return;
						}

//							// aThread的任务
							System.out.println("aThread --> " + (count--));

						threadLock.notify();
						try {
							threadLock.wait();
						} catch (Exception e) {
							// TODO: handle exception
						}
					}
				}
		}
	});

	Thread bThread = new Thread(new Runnable() {
		public void run() {
			while (true) {
					// 锁定
					synchronized (threadLock) {
						if ( count < 1) {
							return;
						}

//							// aThread的任务
							System.out.println("bThread --> " + (count--));

						threadLock.notify();
						try {
							threadLock.wait();
						} catch (Exception e) {
							// TODO: handle exception
						}
					}
				}
		}
	});

	public void startTwoThread() {
		aThread.start();
		bThread.start();
	}

	public static void main(String[] args) {
		TwoThreadPrinter twoThreadPrinter = new TwoThreadPrinter();
		twoThreadPrinter.startTwoThread();
	}

}

用Lock类的方法比较容易理解, lock() 和 unlock()之前的块是被锁定的

用synchronize的方法少用了个flag来标志轮到哪个线程来打印,这是因为线程锁的notifity( )方法会释放锁并唤醒其他线程 ,线程锁的wait( )方法则是释放锁并休眠当前线程

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-10-07 04:05:24

Java-两个线程轮流打印数字的问题的相关文章

Java n个线程轮流打印数字的问题

一. 实现两个线程.轮流打印出数字.例如以下: bThread --> 10 aThread --> 9 bThread --> 8 aThread --> 7 bThread --> 6 aThread --> 5 bThread --> 4 aThread --> 3 bThread --> 2 aThread --> 1 用java中的Lock类实现: package com.yjq.thread_demo; import java.uti

头条面试题之实现两个线程轮流打印字符串

在面试头条的时候,有一个很有意思的题目,利用两个线程交替打印一个字符串,这里主要就是对多线程中wait/notify的应用,特此记录. 对于wait()和notify()的理解,还是要从jdk官方文档中开始,在Object类方法中有: void notify() Wakes up a single thread that is waiting on this object’s monitor. 译:唤醒在此对象监视器上等待的单个线程 void notifyAll() Wakes up all t

Java多个线程顺序打印数字

要求 启动N个线程, 这N个线程要不间断按顺序打印数字1-N. 将问题简化为3个线程无限循环打印1到3 方法一: 使用synchronized 三个线程无序竞争同步锁, 如果遇上的是自己的数字, 就打印. 这种方式会浪费大量的循环 public class TestSequential1 { private volatile int pos = 1; private volatile int count = 0; public void one(int i) { synchronized (th

java多线程轮流打印数字字母案例代码

本案例演示3个线程轮流打印输出数字字母:代码如下 package thread; public class ThreadTest { public static void main(String[] args) { Print print = new Print(); new Thread(()->{ print.printNum(); }).start(); new Thread(()->{ print.printZimu(); }).start(); new Thread(()->{

经典面试题——两个线程交替打印奇数和偶数

前提 今天下班时候和同事聊天偶然听到面试题“两个线程交替打印奇数和偶数”的实现,这里做一个复盘. 复盘 场景一:线程A打印奇数,线程B打印偶数,线程A和线程B交替打印,使用对象监视器实现. 场景二:线程A打印奇数,线程B打印偶数,线程A和线程B交替打印,使用JDK提供的并发类库实现. 这两个场景中,场景一是一种比较古老的同步方式,本质由JVM实现:场景二是JDK1.5引入JUC包之后简化了并发编程的前提下的更简便的实现.下面针对两个场景做对应的实现. 场景一 场景一中,线程A和线程B交替打印奇数

两个线程交替打印信息

看见一个关于两个线程交替打印信息的题目,题目大概是 子线程循环 10 次,接着主线程循环 100 次,接着又回到子线程循环 10 次,接着再回到主线程又循环 100 次,如此循环50次,试写出代码. 写了两个版本,一个是用了mutex,不用条件变量:另外一个是用条件变量. 第一个,不用条件变量 1 #include <stdio.h> 2 #include <string.h> 3 #include <pthread.h> 4 5 6 7 const int LOOP_

Java多线程通信之两个线程分别打印AB各10次

一道经典的面试题目:两个线程,分别打印AB,其中线程A打印A,线程B打印B,各打印10次,使之出现ABABABABA.. 的效果 1 package com.shangshe.path; 2 3 public class ThreadAB { 4 5 /** 6 * @param args 7 */ 8 public static void main(String[] args) { 9 10 final Print business = new Print(); 11 12 new Threa

采用java信号量(semaphore)让线程轮流打印

semaphore是java.util.concurrent包下的并发工具类. A counting semaphore. Conceptually, a semaphore maintains a set of permits. Each acquire() blocks if necessary until a permit is available, and then takes it. Each release() adds a permit, potentially releasing

Java并发:三个线程轮流打印十次abc

方法1:用synchronized.wait.notifyAll实现 public class Main { static boolean t1Running = true; static boolean t2Running = false; static boolean t3Running = false; public static void main(String[] args) throws InterruptedException { final Object lock = new O