阿里控股_爱橙科技_笔试

题目：利用多线程打印出1 2 3，请给出尽可能多的实现方案。

---

其中，悲观锁可以使用Synchronized、Reentrantlock实现，乐观锁可以使用AtomicInteger实现，底层是CAS实现乐观锁。Semaphore 是一种计数信号量，它用于控制同时访问特定资源或执行某个操作的线程数量。这里控制了一个许可来达到每个线程打印完再释放许可让下一个线程执行。Join方法循环要放在外面，每次都要创建三个线程来打印，每个线程通过等待前继线程执行完再执行来达到按顺序打印"123"的效果。

1、使用Join()实现

实现思路是：定义了一个内部类PrintTask实现自Runnable，每个线程负责打印一个特定的数字（1、2、或3）。在每个线程的run方法中，通过检查是否有前一个线程（preThread），如果有，则调用其join()方法等待前一个线程执行完毕，然后再打印自己的数字并循环。这样可以确保打印出的序列是按1、2、3的顺序进行。

package com.java.demo.Exam;public class AlibabaExam {public static void main(String[] args) throws InterruptedException {final int loopCount = 10; // 指定循环打印的次数for (int i = 0; i < loopCount; i++) {Thread thread1 = new Thread(new PrintTask(1, null));Thread thread2 = new Thread(new PrintTask(2, thread1));Thread thread3 = new Thread(new PrintTask(3, thread2));// 启动线程thread1.start();thread2.start();thread3.start();// 等待所有线程执行完毕thread1.join();thread2.join();thread3.join();}}static class PrintTask implements Runnable {private final int number;private final Thread prevThread;public PrintTask(int number, Thread prevThread) {this.number = number;this.prevThread = prevThread;}@Overridepublic void run() {if (prevThread != null) {try {// 等待前一个线程完成打印prevThread.join();} catch (InterruptedException e) {e.printStackTrace();}}System.out.print(number);}}
}

2、使用Synchronized实现

package com.java.demo.LeetCode;public class Print123BySynchronized {private static class PrintNumber {private int counter = 1; // 计数器，用于控制打印次数private final Object lock = new Object(); // 用于同步的锁对象public void print1() {for (int i = 0; i < 10; ) { // 控制总共打印10次synchronized (lock) {if (counter % 3 == 1) { // 当计数器模3等于1时，打印1System.out.print("1");counter++;i++; // 内部计数器加1，控制循环lock.notifyAll(); // 唤醒其他等待的线程} else {try {lock.wait(); // 不符合条件时，释放锁并等待} catch (InterruptedException e) {Thread.currentThread().interrupt();System.out.println("Thread interrupted.");}}}}}public void print2() {for (int i = 0; i < 10; ) {synchronized (lock) {if (counter % 3 == 2) {System.out.print("2");counter++;i++;lock.notifyAll();} else {try {lock.wait();} catch (InterruptedException e) {Thread.currentThread().interrupt();System.out.println("Thread interrupted.");}}}}}public void print3() {for (int i = 0; i < 10; ) {synchronized (lock) {if (counter % 3 == 0) {System.out.print("3");counter++;i++;lock.notifyAll();} else {try {lock.wait();} catch (InterruptedException e) {Thread.currentThread().interrupt();System.out.println("Thread interrupted.");}}}}}}public static void main(String[] args) {PrintNumber printNumber = new PrintNumber();Thread t1 = new Thread(printNumber::print1);Thread t2 = new Thread(printNumber::print2);Thread t3 = new Thread(printNumber::print3);t1.start();t2.start();t3.start();}
}

3、使用ReentrantLock的Condition来实现

package com.java.demo.LeetCode;import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;public class Print123ByReentrantLock {private static class PrintNumber {private int counter = 1; // 打印轮数计数器private final int totalPrints = 10; // 总共打印10次private final ReentrantLock lock = new ReentrantLock();private final Condition condition1 = lock.newCondition();private final Condition condition2 = lock.newCondition();private final Condition condition3 = lock.newCondition();public void print1() {for (int i = 0; i < totalPrints; i++) {lock.lock();try {while (counter % 3 != 1) {condition1.await(); // 等待直到应该打印1}System.out.print("1");counter++;condition2.signal(); // 通知打印2的线程} catch (InterruptedException e) {Thread.currentThread().interrupt();System.out.println("Thread interrupted.");} finally {lock.unlock();}}}public void print2() {for (int i = 0; i < totalPrints; i++) {lock.lock();try {while (counter % 3 != 2) {condition2.await(); // 等待直到应该打印2}System.out.print("2");counter++;condition3.signal(); // 通知打印3的线程} catch (InterruptedException e) {Thread.currentThread().interrupt();System.out.println("Thread interrupted.");} finally {lock.unlock();}}}public void print3() {for (int i = 0; i < totalPrints; i++) {lock.lock();try {while (counter % 3 != 0) {condition3.await(); // 等待直到应该打印3}System.out.print("3");counter++;condition1.signal(); // 循环回到打印1，通知打印1的线程} catch (InterruptedException e) {Thread.currentThread().interrupt();System.out.println("Thread interrupted.");} finally {lock.unlock();}}}}public static void main(String[] args) {PrintNumber printNumber = new PrintNumber();Thread t1 = new Thread(printNumber::print1);Thread t2 = new Thread(printNumber::print2);Thread t3 = new Thread(printNumber::print3);t1.start();t2.start();t3.start();}
}

4、使用Semaphore实现

package com.java.demo.LeetCode;import java.util.concurrent.Semaphore;public class Print123BySemaphore {private static final int PRINT_COUNT = 10; // 每个线程打印的次数// 创建三个信号量，初始状态只允许第一个线程运行private static final Semaphore semaphore1 = new Semaphore(1);private static final Semaphore semaphore2 = new Semaphore(0);private static final Semaphore semaphore3 = new Semaphore(0);public static void main(String[] args) {new Thread(new PrintTask(semaphore1, semaphore2, 1)).start();new Thread(new PrintTask(semaphore2, semaphore3, 2)).start();new Thread(new PrintTask(semaphore3, semaphore1, 3)).start();}static class PrintTask implements Runnable {private final Semaphore currentSemaphore;private final Semaphore nextSemaphore;private final int number;public PrintTask(Semaphore currentSemaphore, Semaphore nextSemaphore, int number) {this.currentSemaphore = currentSemaphore;this.nextSemaphore = nextSemaphore;this.number = number;}@Overridepublic void run() {for (int i = 0; i < PRINT_COUNT; i++) {try {currentSemaphore.acquire(); // 获取当前信号量System.out.print(number); // 打印数字nextSemaphore.release(); // 释放下一个信号量} catch (InterruptedException e) {Thread.currentThread().interrupt(); // 设置线程中断状态}}}}
}

5、使用AtomicInteger实现

package com.java.demo.LeetCode;import java.util.concurrent.atomic.AtomicInteger;public class Print123ByAtomicInteger {private static final int PRINT_COUNT = 10; // 每个线程打印的次数private static final int THREAD_COUNT = 3; // 线程数量private static final AtomicInteger current = new AtomicInteger(0); // 当前应当打印的线程索引public static void main(String[] args) {for (int i = 0; i < THREAD_COUNT; i++) {new Thread(new PrintTask(i)).start();}}static class PrintTask implements Runnable {private final int threadId;public PrintTask(int threadId) {this.threadId = threadId;}@Overridepublic void run() {for (int i = 0; i < PRINT_COUNT; i++) {while (true) {if (current.get() % THREAD_COUNT == threadId) {System.out.print(threadId + 1); // 打印当前线程的ID+1（打印1,2,3）current.incrementAndGet(); // 当前线程索引加1break;}}}}}
}