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

最新推荐文章于 2023-06-22 13:01:04 发布
最新推荐文章于 2023-06-22 13:01:04 发布
阅读量3.7k 收藏 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
关注
专栏目录
编写一个程序，开启3个线程，这3个线程名分别为A、B、C，每个线程将自己名称在屏幕上打印10遍
weixin_42080367的博客
05-11 1342
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.
有三个线程ID分别是A、B、C,请有多线编程实现，在屏幕上循环打印10次ABCABC
Just Do It!
04-25 2958
package com.thread; public class TestThread { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub PrintTask print
存在名称分别为ABC的三个线程，需要让线程打印自己名字，即三个线程按照ABC形式打印线程信息
YEEYang12的博客
03-29 220
思路分析： 线程执行顺序必须是A线程执行、B线程执行、C线程执行 A和B线程，在B线程中调用A.join()方法 B和C线程，在C线程中调用B.join() package Thread.Test; public class ABCDemo extends Thread { private String threadName; private Thread thread; public ABCDemo(String threadName,Thread thread){
java - 线程1打印1-10，当线程打印到5后，线程2打印“hello”,然后线程1继续打印...
weixin_33755649的博客
04-21 167
public class T { private static int a =1;//1代表线程1 2线程2 public static void main(String[] args) { final T t = new T(); new Thread(new Runnab...
3个线程每个线程只能打印自己的名字,在屏幕上顺序打印 ABC，打印10次
seapeak007的博客
12-02 1879
public class TeatPrintOrder { public static void main(String args[]){ AtomicInteger atomic = new AtomicInteger(); Print p = new Print(); ThreadTest a = new ThreadTest(p,"A",0,10,atomic);
C语言实现三个线程循环打印abc,如果让你用三个线程循环打印ABC，你有几种写法？...
weixin_29070861的博客
05-20 1336
题目描述：三个线程分别打印A，B，C，要求这三个线程一起运行，打印n次，输出形如“ABCABCABC....”的字符串。在看之前不妨先敲代码试试，看似很简单的问题可能代码写起来没那么顺利。使用Semaphore：public class PrintABC {private int times;private Semaphore semaphoreA =new Semaphore(1);privat...
编写一个程序，启动三个线程，三个线程的ID分别是A，B，C； 每个线程将自己的ID值在屏幕上打印5遍，打印顺序是ABCABC...
dingjiadashaoye的博客
08-08 1425
public class Test { // flag为0就打印A,为1就打印B,为2就打印C // 利用多线程的synchronized关键字,主要使用wait和notify private int flag = 0; public synchronized void printA() { try { for (int i = 1; i <= 5; i++) { while (flag != 0) { this.wait(); } System.out.println
c语言三个线程abc顺序执行,ABC三个线程顺序执行（简单实现）
weixin_39607474的博客
05-25 1764
需求：3个线程 输出ABC ------> ABCABCABC。。。。。此类型1、 使用线程池将所有线程放入一个队列 ，保证顺序输出public class ThreeThread {public static void main(String[] args) throws InterruptedException {//用线程池来实现 ，3个线程加入线程池ExecutorService ...
python两个线程交替打印_三线程按顺序交替打印ABC的四种方法
weixin_39667626的博客
12-11 1237
建立三个线程A、B、C，A线程打印10次字母A，B线程打印10次字母B,C线程打印10次字母C，但是要求三个线程同时运行，并且实现交替打印，即按照ABCABCABC的顺序打印。二、Synchronized同步法1、基本思路使用同步块和wait、notify的方法控制三个线程的执行次序。具体方法如下：从大的方向上来讲，该问题为三线程间的同步唤醒操作，主要的目的就是ThreadA->Thread...
有三个线程，分别只能打印A，B和C要求按顺序打印ABC，打印10次(多种方法,小白也懂)
最新发布
qq_62718027的博客
06-22 2587
就...相当于创建三十个线程了....如果实在想不起来其他方法就用这个吧....那么我们就可以让三个线程按顺序阻塞和解锁,就能完成打印。简单来说我们有一个名为LockSupport的方法。实际上就是把第一种方式换为用这种方式实现。我们要循环打印ABC三个线程的三个字母。unpark就是取消阻塞让其继续执行。同样还是控制加锁顺序和解锁顺序罢了。park就是阻塞当前进程。
java---创建三个线程
qy_xm的博客
05-13 1111
创建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
编写一个程序，开启3个线程，这3个线程的ID分别为A、B、C，每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；如：ABCABC….依次递推。
weixin_42849105的博客
03-10 439
/************************************************************ 编写一个程序，开启3个线程，这3个线程的ID分别为A、B、C， 每个线程将自己的ID在屏幕上打印10遍， 要求输出结果必须按ABC的顺序显示；如：ABCABC….依次递推。 ************************************************************/ #include <stdio.h> #include <stdli.
编写一个程序，启动三个线程，三个线程的名称分别是 A，B，C； 每个线程将自己的名称在屏幕上打印5遍，打印顺序是ABCABC...
_Unique_
11-18 1770
设置标志位flag 当flag==1时，打印A 当flag==2时，打印B 当flag==3时，打印C 用count控制打印的次数，题目要求打印5遍，即15个字符 这里的用notifyAll()的原因：是要把其余两个全都唤醒，因为如果用notify(),它是二选一唤醒，不确定它是否会唤醒我们所需要的 run()方法里的代码是判断确定打印某个字符，即：当与线程名称一样时，则打印 clas...
有三个线程分别打印A、B、C,请用多线程编程实现，在屏幕上循环打印10次ABCABC…
健康平安的活着的专栏
01-27 5595
题目：有三个线程分别打印A、B、C,请用多线程编程实现，在屏幕上循环打印10次ABCABC…  方法一：使用lock和condition来实现a执行完通知b执行，b执行完通知c执行，c执行完通知a执行的顺序，使用Executors的fixedthreadpool，将三个线程放到线程池里面，使用线程池控制程序的结束，调用shutdown（）方法。 package com.ljf.thread....
java多线程，三个线程轮流执行顺序打印ABC，循环5次。使用三个Condition实现。
javaZhong的博客
06-02 2113
package com.zhong.thread; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; /** * 三个线程依次输出A，B，C，循环5次。 * 输出结果： * ABC * ABC * ABC * ABC * ABC */ public class SequencePrintDemo { private static volat.
有三个线程ID分别是A、B、C,请有多线编程 实现 在屏幕上循环打印10次ABCABC......
hellorichen的专栏
11-13 4128
有三个线程ID分别是A、B、C,请有多线编程 实现 在屏幕上循环打印10次ABCABC...... 代码如下： package thread1; public class Main_thread1 implements Runnable{ private String name; private Object prev; private Objec
编写一个程序，启动三个线程，三个线程的ID分别是A,B,C * 每个线程将自己的ID值在屏幕上打印10遍，打印顺序是 * ABCAABC...
weixin_43200585的博客
09-18 1600
编写一个程序，启动三个线程，三个线程的ID分别是A,B,C * 每个线程将自己的ID值在屏幕上打印10遍，打印顺序是 * ABCAABC… 在一个类中定义三个方法，并在方法中加synchronzied关键字 class MyThread1{ int count = 1; public synchronized void printA() { //A线程 whil...
Java多线程交叉打印ABABAB，一个线程打印A，一个线程打印B
江湖人称小程的博客
10-26 5071
在Java中想要完成此功能有好几种方法都可以实现，这篇文章主要使用 wait 和 notifyAll 方法。 具体需求为： 要求先打印字符 A ，再打印字符 B ，完了再打印字符 A …如此循环下去，要求格式为：ABABABABABAB… 原理： 首先需要两个线程，一个打印字符 A ，另一个打印字符 B ，那么如何让他们互相协作呢？此时，我需要一个 boolean 类型的变量 flag ，这个变量...
有三个线程，分别只能打印A，B和C 要求按顺序打印ABC，打印10次
05-25
可以使用信号量来实现三个线程按顺序打印ABC的需求，每个线程持有一个信号量，控制打印的顺序。 具体实现如下： ```python import threading class PrintABC: def __init__(self): self.count = 10 self.sem_a = threading.Semaphore(1) # 线程A的信号量，初始值为1 self.sem_b = threading.Semaphore(0) # 线程B的信号量，初始值为0 self.sem_c = threading.Semaphore(0) # 线程C的信号量，初始值为0 def print_a(self): for i in range(self.count): self.sem_a.acquire() # 获取信号量 print('A', end='') self.sem_b.release() # 释放下一个信号量 def print_b(self): for i in range(self.count): self.sem_b.acquire() # 获取信号量 print('B', end='') self.sem_c.release() # 释放下一个信号量 def print_c(self): for i in range(self.count): self.sem_c.acquire() # 获取信号量 print('C', end='') self.sem_a.release() # 释放下一个信号量 if __name__ == '__main__': p = PrintABC() t1 = threading.Thread(target=p.print_a) t2 = threading.Thread(target=p.print_b) t3 = threading.Thread(target=p.print_c) t1.start() t2.start() t3.start() t1.join() t2.join() t3.join() ``` 这里定义了一个 `PrintABC` 类，其中包含三个方法 `print_a`、`print_b` 和 `print_c`，分别用来打印字母 A、B 和 C。每个方法中都使用了信号量来控制打印的顺序，其中线程 A 的信号量初始值为 1，而线程 B 和线程 C 的信号量初始值都为 0。 在 `print_a` 方法中，线程 A 先获取信号量，打印字母 A，然后释放线程 B 的信号量，以此类推。 最后，启动三个线程并等待它们结束，输出的结果为： ``` ABCABCABCABCABCABCABCABCABCABC ```
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值