最近发现公司有份笔试试卷中有道多线程的[b]题目[/b]：[color=blue][b]有三个线程分别打印A、B、C,请用多线程编程实现，在屏幕上循环打印10次ABCABC…[/b][/color]

这个最早好像是迅雷的面试题目吧，看到了然后就想重温一下这个题目的解决方法。

在本文中，给出了五种这个题目的解决方法：

[list]
[*][b]使用sleep
[*]使用synchronized, wait和notifyAll
[*]使用Lock 和 Condition
[*]使用Semaphore
[*]使用AtomicInteger[/b]
[/list]

下面依次给出每种解决方案的代码：

[color=blue][u][b]使用sleep[/b][/u][/color]

package my.thread.test;

/**
* @author Eric
*/
public class SleepExample extends Thread {

private static int currentCount = 0;

public SleepExample(String name) {
this.setName(name);
}

@Override
public void run() {
while (currentCount < 30) {
switch (currentCount % 3) {
case 0:
if ("A".equals(getName())) {
printAndIncrease();
}
break;
case 1:
if ("B".equals(getName())) {
printAndIncrease();
}
break;
case 2:
if ("C".equals(getName())) {
printAndIncrease();
}
break;
}
}

}

private void printAndIncrease() {
print();
increase();
}

private void print() {
System.out.println(getName());
if ("C".equals(getName())) {
System.out.println();
}
}

private void increase() {
currentCount++;
}

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

}

[color=blue][u][b]使用synchronized, wait和notifyAll[/b][/u][/color]

package my.thread.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class PrintThreadExample {

public static void main(String[] args) {
PrintThreadExample example = new PrintThreadExample();

LetterPrinter letterPrinter = example.new LetterPrinter();

ExecutorService service = Executors.newFixedThreadPool(3);

service.execute(example.new PrintRunnable(letterPrinter, 'A'));
service.execute(example.new PrintRunnable(letterPrinter, 'B'));
service.execute(example.new PrintRunnable(letterPrinter, 'C'));

service.shutdown();
}

private class LetterPrinter {
private char letter = 'A';

public void print() {
System.out.println(letter);
if ('C' == letter) {
System.out.println();
}
}

public void nextLetter() {
switch (letter) {
case 'A':
letter = 'B';
break;
case 'B':
letter = 'C';
break;
case 'C':
letter = 'A';
break;
}
}

/**
* @return the letter
*/
public char getLetter() {
return letter;
}

}

private class PrintRunnable implements Runnable {

private LetterPrinter letterPrinter = null;

private char letter = ' ';

/**
* @param letterPrinter
* @param letter
*/
public PrintRunnable(LetterPrinter letterPrinter, char letter) {
super();
this.letterPrinter = letterPrinter;
this.letter = letter;
}

public void run() {
for (int i = 0; i < 10; i++) {
synchronized (letterPrinter) {
while (letter != letterPrinter.getLetter()) {
try {
letterPrinter.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

letterPrinter.print();
letterPrinter.nextLetter();
letterPrinter.notifyAll();

}
}

}

}

}

[color=blue]JDK 1.5 引入J.U.C包之后，也给我们提供了更多实现多线程程序的选择: [b]Condition[/b], 原子类[b]AtomicInteger[/b]以及[b]Semaphore[/b]等。[/color]

[color=blue][u][b]
使用Lock 和 Condition[/b][/u][/color]

package my.thread.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.logging.Logger;

/**
* 题目：有三个线程分别打印A、B、C,请用多线程编程实现，在屏幕上循环打印10次ABCABC…
*
* 本程序采用Lock和Condition来实现。
*
* @author Eric
*
*/
public class ConditionExample {

private Lock lock = new ReentrantLock();

private Condition conditionA = lock.newCondition();
private Condition conditionB = lock.newCondition();
private Condition conditionC = lock.newCondition();

/** 当前线程的名字 */
private char currentThreadName = 'A';

private static final Logger logger = Logger
.getLogger("my.thread.test.OrderPrintTest");

public static void main(String[] args) {

ConditionExample ce = new ConditionExample();

ExecutorService service = Executors.newFixedThreadPool(3);
service.execute(ce.new ThreadA());
service.execute(ce.new ThreadB());
service.execute(ce.new ThreadC());

service.shutdown();
}

private class ThreadA implements Runnable {
public void run() {

for (int i = 0; i < 10; i++) {
lock.lock();
try {
while (currentThreadName != 'A') {
try {
/*
* 如果当前线程名字不是A，那么ThreadA就处理等待状态
*/
conditionA.await();
} catch (InterruptedException e) {
logger.severe(e.getLocalizedMessage());
}
}

/*
* 打印出第几遍以及A信息
*/
System.out.println(String.format("第%d遍", i + 1));
System.out.println("A");

/*
* 将当前线程名置为B， 然后通知ThreadB执行
*/
currentThreadName = 'B';
conditionB.signal();

} finally {
lock.unlock();
}
}
}

}

private class ThreadB implements Runnable {
public void run() {
for (int i = 0; i < 10; i++) {
lock.lock();
try {
while (currentThreadName != 'B') {
try {
/*
* 如果当前线程名字不是B，那么ThreadB就处理等待状态
*/
conditionB.await();
} catch (InterruptedException e) {
logger.severe(e.getLocalizedMessage());
}
}

/*
* 打印信息B
*/
System.out.println("B");

/*
* 将当前线程值置为C 并通过ThreadC来执行
*/
currentThreadName = 'C';
conditionC.signal();

} finally {
lock.unlock();
}
}

}

}

private class ThreadC implements Runnable {

public void run() {
for (int i = 0; i < 10; i++) {
lock.lock();
try {
while (currentThreadName != 'C') {
try {
/*
* 如果当前线程名字不是C，那么ThreadC就处理等待状态
*/
conditionC.await();
} catch (InterruptedException e) {
logger.severe(e.getLocalizedMessage());
}
}

/*
* 打印信息C
*/
System.out.println("C");
System.out.println();

/*
* 将当前线程值置为A 并通过ThreadA来执行
*/
currentThreadName = 'A';
conditionA.signal();

} finally {
lock.unlock();
}

}
}
}
}

[color=blue][u][b]使用Semaphore[/b][/u][/color]

package my.thread.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class SemaphoresExample {

private Semaphore semaphoresA = new Semaphore(1);
private Semaphore semaphoresB = new Semaphore(0);
private Semaphore semaphoresC = new Semaphore(0);

public static void main(String[] args) {
SemaphoresExample example = new SemaphoresExample();
ExecutorService service = Executors.newFixedThreadPool(3);

service.execute(example.new RunnableA());
service.execute(example.new RunnableB());
service.execute(example.new RunnableC());

service.shutdown();
}

private class RunnableA implements Runnable {

public void run() {

for (int i = 0; i < 10; i++) {
try {
semaphoresA.acquire();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(String.format("第%d遍", i + 1));
System.out.println("A");
semaphoresB.release();

}
}
}

private class RunnableB implements Runnable {

public void run() {

for (int i = 0; i < 10; i++) {
try {
semaphoresB.acquire();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("B");
semaphoresC.release();
}

}
}

private class RunnableC implements Runnable {

public void run() {

for (int i = 0; i < 10; i++) {
try {
semaphoresC.acquire();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("C");
System.out.println();

semaphoresA.release();
}
}
}
}

[color=blue]
[u][b]使用AtomicInteger[/b][/u][/color]

package my.thread.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerExample {

private AtomicInteger sycValue = https://www.it610.com/article/new AtomicInteger(0);

private static final int MAX_SYC_VALUE = https://www.it610.com/article/3 * 10;

public static void main(String[] args) {
AtomicIntegerExample example = new AtomicIntegerExample();
ExecutorService service = Executors.newFixedThreadPool(3);

service.execute(example.new RunnableA());
service.execute(example.new RunnableB());
service.execute(example.new RunnableC());

service.shutdown();
}

private class RunnableA implements Runnable {

public void run() {

while (sycValue.get() < MAX_SYC_VALUE) {
if (sycValue.get() % 3 == 0) {
System.out.println(String.format("第%d遍",
sycValue.get() / 3 + 1));
System.out.println("A");
sycValue.getAndIncrement();
}
}

}
}

private class RunnableB implements Runnable {

public void run() {

while (sycValue.get() < MAX_SYC_VALUE) {
if (sycValue.get() % 3 == 1) {
System.out.println("B");
sycValue.getAndIncrement();
}
}

}
}

private class RunnableC implements Runnable {

public void run() {

while (sycValue.get() < MAX_SYC_VALUE) {
if (sycValue.get() % 3 == 2) {
System.out.println("C");
System.out.println();
sycValue.getAndIncrement();
}
}

}
}
}

转载请注明出处[url]http://mouselearnjava.iteye.com/blog/1949228[/url]

推荐阅读

• 

  女性提前进入更年期的危害 女白领应警惕更年期提前来扰
• 

  干煸杏鲍菇
• 

  如何使用手机上的云服务器？ 手机的云服务器怎么用
• 

  粉饼和散粉的区别和作用
• 

  商标自助查询系统官网 注册商标如何收费，商标注册证查询网中国商标网
• 

  大闸蟹怎么保存才不死
• 

  怪物猎人世界特殊装备解锁条件大全 怪物猎人世界特殊装备解锁条件大全
• 

  mysql允许局域网连接 mysql允许外网登陆
• 

  阳光玫瑰亩产量一般多少斤，适合哪些地区种植
• 

  一文搞懂什么叫做唯心主义？ 唯心主义通俗解释
• 

  桂林手撕白切鸡做法 一招解决你不会切白切鸡的烦恼
• 

  全面战争三国诸葛亮怎么招募
• 

  手动挡倒车入库视频教程 如何倒车入位视频教程，倒车入库视频技巧
• 

  标准的java三层代码，java三层架构代码规范
• 

  简单的安卓阅读软件,阅读浏览器可离线使用阅读小说更清楚
• 

  黑米搭配什么煮粥最好
• 

  农村拆迁土地纠纷怎么办手续 农村拆迁土地纠纷怎么办？
• 

  关于色彩诊断的觉察
• 

  农村户口的残疾赔偿金标准是什么？
• 

  抑郁症|2021年将有9200万独居者：警惕孤独成为抑郁的温床

• Java|Java基础——数组
• 人工智能|干货！人体姿态估计与运动预测
• java简介|Java是什么（Java能用来干什么？）
• Java|规范的打印日志
• Linux|109 个实用 shell 脚本
• 程序员|【高级Java架构师系统学习】毕业一年萌新的Java大厂面经，最新整理
• Spring注解驱动第十讲--@Autowired使用
• SqlServer|sql server的UPDLOCK、HOLDLOCK试验
• jvm|【JVM】JVM08(java内存模型解析[JMM])
• 技术|为参加2021年蓝桥杯Java软件开发大学B组细心整理常见基础知识、搜索和常用算法解析例题（持续更新...)