有三个线程名字分别是A、B、C,每个线程只能打印自己的名字,在屏幕上顺序打印 ABC，打印10次。不准使用线程的sleep()

最新推荐文章于 2022-05-13 13:06:37 发布
最新推荐文章于 2022-05-13 13:06:37 发布
阅读量3.6k 收藏 1
点赞数 1
分类专栏： Java笔试面试题 文章标签： 有三个线程名字分别是ABC 每个线程只能打印自己的名字 在屏幕上顺序打印 ABC 打印10次不准使用线程的sleep

 

package com.demo.learn;

import java.util.concurrent.Semaphore;

public class ThreadDemo {

	static class ThreadA extends Thread {
		private Semaphore semaphoreCurrent;
		private Semaphore semaphoreNext;

		public ThreadA(String name, Semaphore semaphoreCurrent,
				Semaphore semaphoreNext) {
			super(name);
			this.semaphoreCurrent = semaphoreCurrent;
			this.semaphoreNext = semaphoreNext;
		}

		public void run() {
			for (int i = 0; i < 10; i++) {
				try {
					semaphoreCurrent.acquire();
					System.out.println(this.getName());
				} catch (InterruptedException e) {
					e.printStackTrace();
				} finally {
					semaphoreNext.release();
				}
			}
		}
	}

	public static void main(String[] args) throws InterruptedException {
		Semaphore semaphoreA = new Semaphore(1);
		Semaphore semaphoreB = new Semaphore(0);
		Semaphore semaphoreC = new Semaphore(0);
		ThreadA threadA = new ThreadA("A", semaphoreA, semaphoreB);
		ThreadA threadB = new ThreadA("B", semaphoreB, semaphoreC);
		ThreadA threadC = new ThreadA("C", semaphoreC, semaphoreA);
		threadA.start();
		threadB.start();
		threadC.start();
	}
}





public class ABC1 extends Thread {
	private static Object o = new Object();
	private static int count = 0;
	private char ID;
	private int id;
	private int num = 0;

	public ABC1(int id, char ID) {
		this.id = id;
		this.ID = ID;
	}

	public void run() {
		synchronized (o) {
			while (num < 10) {
				if (count % 3 == id) {
					System.out.print(ID);
					++count;
					++num;
					o.notifyAll();
				} else {
					try {
						o.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}
	}

	public static void main(String[] args) {
		(new ABC1(0, 'A')).start();
		(new ABC1(1, 'B')).start();
		(new ABC1(2, 'C')).start();
	}
}


 

public class ABC2 extends Thread {
	private static String currentThread = "A";
	private static byte[] lock = new byte[0];
	private String name = "";
	private int count = 10;

	public ABC2(String name) {
		this.name = name;
	}

	public void run() {
		while (count > 0) {
			synchronized (lock) {
				if (currentThread.equals(this.name)) {
					System.out.print(name);
					count--;
					if (currentThread.equals("A")) {
						currentThread = "B";
					} else if (currentThread.equals("B")) {
						currentThread = "C";
					} else if (currentThread.equals("C")) {
						currentThread = "A";
						System.out.println();
					}
				}
			}
		}
	}

	public static void main(String[] args) {
		(new ABC2("A")).start();
		(new ABC2("B")).start();
		(new ABC2("C")).start();
	}
}


 


最近在网上看到有一道考察多线程的题目，题目有两个版本，一个简单，一个要求多一点，分别如下。

  1. 编程实现三个线程 ABC，并让它们顺次打印ABC。
  2. 有三个线程分别打印A、B、C，请用多线程编程实现，在屏幕上循环打印 10 次 ABCABC…

只打印一次的做法

1. 使用 join 是最简单的，关于 join 可以参考我的另一篇博文。具体代码如下：

/**
 * 编程实现三个线程ABC，并让它们顺次打印ABC
 * created by ke zhenxu on 3/25/16.
 */
private static void printOnce () {
    final Thread threadA = new Thread () {
        @Override
        public void run () {
            System.out.print ("A");
        }
    };
    final Thread threadB = new Thread () {
        @Override
        public void run () {
            try {
                threadA.join (); // 等待 A 运行完
                System.out.print ("B");
            } catch (Exception e) {
                e.printStackTrace ();
            }
        }
    };
    final Thread threadC = new Thread () {
        @Override
        public void run () {
            try {
                threadB.join (); // 等待 B 运行完
                System.out.print ("C");
            } catch (Exception e) {
                e.printStackTrace ();
            }
        }
    };
    threadA.start ();
    threadB.start ();
    threadC.start ();
}

2. 甚至可以将上面带有注释的 join 方法移到下面的 start 那里去，代码可以更简化成下面这样：

static class MyThread extends Thread {
    public MyThread (final String name) {
        super (name);
    }

    @Override
    public void run () {
        System.out.print (currentThread ().getName ());
    }
}

private static void printOnceV2 () throws InterruptedException {
    final MyThread threadA = new MyThread ("A");
    final MyThread threadB = new MyThread ("B");
    final MyThread threadC = new MyThread ("C");
    threadA.start ();
    threadA.join ();        // 等待 A 运行完，再开始 B
    threadB.start ();
    threadB.join ();        // 等待 B 运行完，再开始 C
    threadC.start ();
}

不过这种方法和串行执行好像没什么两样，不过意思达到了。

3. 使用 JDK5 提供的新 java.util.concurrent （以下简称j.u.c）包中的 CountDownLatch 类，关于 CountDownLatch 的使用可以参考我的另一篇博文，具体代码如下：

private static void printOnceLatch () {
    final CountDownLatch countDownLatchForB = new CountDownLatch (1);   // 为 B 准备的闭锁，只有该闭锁倒数到 0 ，B 才可以运行
    final CountDownLatch countDownLatchForC = new CountDownLatch (1);   // 为 C 准备的闭锁，只有该闭锁倒数到 0 ，C 才可以运行
    final Thread threadA = new Thread () {
        @Override
        public void run () {
            System.out.print ("A");
            // B 要在 A 运行完才能运行，就由 A 来倒数
            countDownLatchForB.countDown ();
        }
    };
    final Thread threadB = new Thread () {
        @Override
        public void run () {
            try {
                // 等待 A （使用给 B 的闭锁）倒数
                countDownLatchForB.await ();
            } catch (Exception e) {
                e.printStackTrace ();
            } finally {
                System.out.print ("B");
                countDownLatchForC.countDown ();
            }
        }
    };
    final Thread threadC = new Thread () {
        @Override
        public void run () {
            try {
                countDownLatchForC.await ();
            } catch (Exception e) {
                e.printStackTrace ();
            } finally {
                System.out.print ("C");
            }
        }
    };
    threadA.start ();
    threadB.start ();
    threadC.start ();
}

打印 10 次的做法，由于可以打印十次的方法略作修改就可以用于只打印一次的方法，因此为了简化，直接给出打印十次的方法。当然，只打印一次的方法略作修改也可以用来打印十次，像下面这样，不过这样有意思吗。

public static void foo() {
    for (int i = 0; i < 10; i++) {
        printOnce();
    }
}

4. 使用信号量 Semaphore 类，三个线程每一个都有一个信号量，信号量等于 0 将被阻塞，等于 1 可以运行，因为每次只能有一个线程在运行，因此信号量总和应该为 1 ，相当于一个令牌在传递一样。代码如下：

private static void printTenTimesSemaphore () {
    final Semaphore semaphoreForA = new Semaphore (1);  // A 最开始执行, 所以是 1
    final Semaphore semaphoreForB = new Semaphore (0);
    final Semaphore semaphoreForC = new Semaphore (0);
    final Thread threadA = new Thread () {
        @Override
        public void run () {
            for (int i = 0; i < 10; i++) {
                try {
                    semaphoreForA.acquire ();
                } catch (Exception e) {
                    e.printStackTrace ();
                } finally {
                    System.out.print ("A");
                    semaphoreForB.release (); // 给 B 的信号加 1 ,让 B 可以获得信号去执行
                }
            }
        }
    };
    final Thread threadB = new Thread () {
        @Override
        public void run () {
            for (int i = 0; i < 10; i++) {
                try {
                    semaphoreForB.acquire ();   // 申请信号, 只有当信号量大于 0 时才不会被阻塞
                } catch (Exception e) {
                    e.printStackTrace ();
                } finally {
                    System.out.print ("B");
                    semaphoreForC.release ();   // 给 C 的信号加 1, 让 C 可以获得信号执行
                }
            }
        }
    };
    final Thread threadC = new Thread () {
        @Override
        public void run () {
            for (int i = 0; i < 10; i++) {
                try {
                    semaphoreForC.acquire ();
                } catch (Exception e) {
                    e.printStackTrace ();
                } finally {
                    System.out.print ("C");
                    semaphoreForA.release ();
                }
            }
        }
    };
    threadA.start ();
    threadB.start ();
    threadC.start ();
}

5. 使用 j.u.c 包中的原子变量，该变量的效果实际和令牌一样，只是根据该变量的状态来判断当前线程是不是可以运行，代码用到了 yield 方法，该方法可以让当前线程主动放弃执行权。代码如下：

/**
 * 编程实现三个线程ABC，并让它们顺次打印 ABC 十次
 */
private static void printTenTimes () {
    final AtomicInteger token = new AtomicInteger (0);
    final Thread threadA = new Thread () {
        @Override
        public void run () {
            for (int i = 0; i < 10; i++) {
                while (token.get () % 3 != 0) {
                    yield ();       // 不是 A 运行的时候, 让出执行权
                }
                System.out.print ("A");
                token.incrementAndGet ();  // 由于增加 1 后被 3 模余数 1, 而被 3 模余数 1 是 B 可以运行的, 此步相当于把令牌传递给 B 
            }
        }
    };
    final Thread threadB = new Thread () {
        @Override
        public void run () {
            for (int i = 0; i < 10; i++) {
                while (token.get () % 3 != 1) {
                    yield ();
                }
                System.out.print ("B");
                token.incrementAndGet ();
            }
        }
    };
    final Thread threadC = new Thread () {
        @Override
        public void run () {
            for (int i = 0; i < 10; i++) {
                while (token.get () % 3 != 2) {
                    yield ();
                }
                System.out.print ("C");
                token.incrementAndGet ();
            }
        }
    };
    threadA.start ();
    threadB.start ();
    threadC.start ();
}

6. 使用 wait 和 notify 方法实现，关于 wait 和 notify 的用法可以参考我的另一篇博文。使用到了 BitSet 类，其中的 mutex 变量作为三个线程的互斥锁，代码如下：

private static void printTenTimesWaitNotif () {
    final BitSet mutex = new BitSet (3);
    final Thread threadA = new Thread () {
        @Override
        public void run () {
            for (int i = 0; i < 10; i++) {
                try {
                    synchronized (mutex) {
                        while (!mutex.get (0)) {
                            mutex.wait ();
                        }
                        System.out.print ("A");
                        mutex.clear (0);
                        mutex.set (1);
                        mutex.notify ();
                    }
                } catch (Exception e) {
                    e.printStackTrace ();
                }
            }
        }
    };
    final Thread threadB = new Thread () {
        @Override
        public void run () {
            for (int i = 0; i < 10; i++) {
                try {
                    synchronized (mutex) {
                        while (!mutex.get (1)) {
                            mutex.wait ();
                        }
                        System.out.print ("B");
                        mutex.clear (1);
                        mutex.set (2);
                        mutex.notify ();
                    }
                } catch (Exception e) {
                    e.printStackTrace ();
                }
            }
        }
    };
    final Thread threadC = new Thread () {
        @Override
        public void run () {
            for (int i = 0; i < 10; i++) {
                try {
                    synchronized (mutex) {
                        while (!mutex.get (2)) {
                            mutex.wait ();
                        }
                        System.out.print ("C");
                        mutex.clear (2);
                        mutex.set (0);
                        mutex.notify ();
                    }
                } catch (Exception e) {
                    e.printStackTrace ();
                }
            }
        }
    };
    threadA.start ();
    threadB.start ();
    threadC.start ();
    synchronized (mutex) {
        mutex.set (0);
        mutex.notify ();
    }
}

总结

关于 Java 多线程编程，还有很多要学，等学到的时候如果发现还有解法再来完善，如果您发现我漏掉了某种重要的解法，欢迎联系我，^_^。


 

onyas
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java多线程每个线程挨着打印ABC的4种实现方式
08-23
java多线程每个线程挨着打印ABC的4种实现方式，有4个线程t1、t2、t3、t4，t1打印A后t2打印A再t3打印A再t4打印A，然后从新回到t1打印B再t2打印B...t4打印B... 4个线程轮流打印abc... 一个线程可以理解为一个人，打印...
编写一个程序，开启3个线程，这3个线程名分别为A、B、C，每个线程将自己名称在屏幕上打印10遍
weixin_42080367的博客
05-11 1270
public class threadPractice { public static void main(String[] args) { Print print = new Print(); MyThread myThread = new MyThread(print);//创建线程业务类（打印功能） Thread thread1 = new Thread(myThread,"A"); Thread thread2 = new T.
编写一个程序，启动三个线程，三个线程的名称分别是 A，B，C； 每个线程将自己的名称在屏幕上打印5遍，打印顺序是ABCABC...
_Unique_
11-18 1725
设置标志位flag 当flag==1时，打印A 当flag==2时，打印B 当flag==3时，打印C 用count控制打印的次数，题目要求打印5遍，即15个字符 这里的用notifyAll()的原因：是要把其余两个全都唤醒，因为如果用notify(),它是二选一唤醒，不确定它是否会唤醒我们所需要的 run()方法里的代码是判断确定打印某个字符，即：当与线程名称一样时，则打印 clas...
多线程
zhangsan212的专栏
02-23 346
------- android培训 ,java培训、期待与您交流！ ---------- 多线程: 一．线程:线程是一个并发执行的顺序流,一个进程包括多个顺序执行流程,这执行流程称为线程。     线程是一个操作系统创建并维护的一个资源,对操作系统来说JVM就是一个进程。     对于单个CPU系统来说，某一个时刻只可能由一个线程在运行。        一个Thread对象就表示
编写一个程序，开启3个线程，这3个线程的ID分别为A、B、C，每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；如：ABCABC….依次递推。
qq_44836035的博客
03-10 996
#include<stdio.h> #include<pthread.h> #include<stdlib.h> #include<unistd.h> .
java---创建三个线程
qy_xm的博客
05-13 1037
创建3个线程，zhangsan，lisi，teacher。线程zhangsan和lisi准备休眠10秒后在输出“早上好!"teacher线程在输出三句“上课”以后，吵醒休眠的线程zhangsan，zhangsan被吵醒后再吵醒lisi package Sj2; public class Xiancheng { public static void main(String[] args) { // TODO Auto-generated method stub ClassRoom cl
浅谈Python3多线程之间的执行顺序问题
12-20
一个多线程的题：定义三个线程ID分别为ABC，每个线程打印10遍自己的线程ID，按ABCABC……的顺序进行打印输出。 我的解法： from threading import Thread, Lock # 由_acquire解锁执行后释放_release锁 def _print(_...
最新Java面试宝典pdf版
08-31
63、List、Map、Set三个接口，存取元素时，各有什么特点？ 45 64、说出ArrayList,Vector, LinkedList的存储性能和特性 46 65、去掉一个Vector集合中重复的元素 46 66、Collection 和 Collections的区别。 47 67、Set...
Java面试宝典-经典
03-28
63、List、Map、Set三个接口，存取元素时，各有什么特点？ 45 64、说出ArrayList,Vector, LinkedList的存储性能和特性 46 65、去掉一个Vector集合中重复的元素 46 66、Collection 和 Collections的区别。 47 67、Set...
Thread实现两个线程打印0-10
05-01
继承Thread类 1 实现Runable接口 2 继承Thread类： 3 必须重写run 方法：里面放置的实际的线程体 4 启动线程： 5 创建Thread对象 6 调用Thread对象的start 方法启动线程 7 在子类中定义static静态变量实现资源共享
操作系统PV操作题整理2
AnalogElectronic的博客
12-08 4095
1.某进程中有3个并发执行的线程thread1、thread2、thread3，其伪代码如下所示。请添加必要的信号量和P、V操作，要求确保互斥访问临界资源 //复数的结构类型定义 typedef struct { float a; float b; }cnum; cnum x,y,z; //全局变量 //计算两个复数之和 cnum add( cnum p,cnum q) { cnum s...
笔试题:编写一个程序，开启3个线程，这3个线程的ID分别为A、B、C，每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；如：ABCABC….依次递推。
qq_29863725的博客
03-21 2581
这是最近笔试遇到一个多线程题，当时没有做出来，后来经过查找后，找到两种写法。 方法一:利用Lock和Condition来实现，代码如下 public class PrintABC { private String printFlag = "A"; private Lock lock = new ReentrantLock(); private Condition c1 = loc
编写一个程序，开启3个线程，这3个线程的ID分别为A、B、C，每个线程将自己的ID在屏幕上打印10遍 .
软件开发工程师----王腾
12-26 5887
#include     #include    #include    #include    #include    //#define DEBUG 1   #define NUM 3     int n=0;  pthread_mutex_t mylock=PTHREAD_MUTEX_INITIALIZER;//互斥量  pthread_cond_t qready=PTHREA
创建3个线程为Thread1Thread2Thread3 需要对一个数字进行递减操作 当数字递减到0的时候，输出“数字为0，结束递减”
王文强的博客
09-05 5221
多线程，对run方法内部进行一个同步运算。 以下是代码： package 一般测试题; public class 依次打印递增数字 { /** * 创建三个线程进行分段叠加 * 每个线程叠加四次 * */ public static void main(String[] args) { new Thread(new A...
如何实现有三个线程a，b，c，这三个线程都有一个方法分别打印A、B、C，问怎么能实现依次打印ABC的功能
小猛同学的博客
04-10 8177
今天有家电面（具体哪家就不提了）问了这样的问题：如何实现有三个线程a，b，c，这三个线程都有一个方法分别打印A、B、C，问怎么能实现依次打印ABC的功能。当时想着使用优先级或者join方法（肯定不行，因为你定的优先级不太听话不会按照你定的去依次执行，join方法去抢占时间片也不好使），其实就是利用线程池去解决这个问题：思路：其实就是让三个线程依次运行，运用的是线程池来完成的，创建一个只有一个线程的...
大学物理册答案上下都有
最新发布
04-26
大学物理册答案上下都有
UWB超宽带信道研究及源码.zip
04-26
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
有三个线程，分别只能打印A，B和C 要求按顺序打印ABC，打印10次
05-25
可以使用信号量来实现三个线程按顺序打印ABC的需求，每个线程持有一个信号量，控制打印的顺序。 具体实现如下： ```python import threading class PrintABC: def __init__(self): self.count = 10 self.sem_a...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值