【巨人的肩膀】多个线程顺序打印问题，一网打尽

最新推荐文章于 2024-11-06 00:13:23 发布
最新推荐文章于 2024-11-06 00:13:23 发布
阅读量110 收藏
点赞数
分类专栏： 巨人的肩膀 文章标签： 面试
原文链接：https://www.cnblogs.com/lazyegg/p/13900847.html
版权

大家在换工作面试中，除了一些常规算法题，还会遇到各种需要手写的题目，所以打算总结出来，给大家个参考
第一篇打算总结下阿里最喜欢问的多个线程顺序打印问题，我遇到的是机试，直接写出运行。同类型的题目有很多，比如

  1. 三个线程分别打印 A，B，C，要求这三个线程一起运行，打印 n 次，输出形如“ABCABCABC…”的字符串
  2. 两个线程交替打印 0~100 的奇偶数
  3. 通过 N 个线程顺序循环打印从 0 至 100
  4. 多线程按顺序调用，A->B->C，AA 打印 5 次，BB 打印10 次，CC 打印 15 次，重复 10 次
  5. 用两个线程，一个输出字母，一个输出数字，交替输出 1A2B3C4D…26Z
使用 Lock

我们以第一题为例：三个线程分别打印 A，B，C，要求这三个线程一起运行，打印 n 次，输出形如“ABCABCABC…”的字符串
思路：使用一个取模的判断逻辑 C%M ==N，题为 3 个线程，所以可以按取模结果编号：0、1、2，他们与 3 取模结果仍为本身，则执行打印逻辑

public class PrintABCUsingLock {

    private int times; // 控制打印次数
    private int state;   // 当前状态值：保证三个线程之间交替打印
    private Lock lock = new ReentrantLock();

    public PrintABCUsingLock(int times) {
        this.times = times;
    }

    private void printLetter(String name, int targetNum) {
        for (int i = 0; i < times; ) {
            lock.lock();
            if (state % 3 == targetNum) {
                state++;
                i++;
                System.out.print(name);
            }
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        PrintABCUsingLock loopThread = new PrintABCUsingLock(1);

        new Thread(() -> {
            loopThread.printLetter("B", 1);
        }, "B").start();
        
        new Thread(() -> {
            loopThread.printLetter("A", 0);
        }, "A").start();
        
        new Thread(() -> {
            loopThread.printLetter("C", 2);
        }, "C").start();
    }
}

main 方法启动后，3 个线程会抢锁，但是 state 的初始值为 0，所以第一次执行 if 语句的内容只能是 线程 A，然后还在 for 循环之内，此时 state = 1，只有 线程 B 才满足 1% 3 == 1，所以第二个执行的是 B，同理只有 线程 C 才满足 2% 3 == 2，所以第三个执行的是 C，执行完 ABC 之后，才去执行第二次 for 循环，所以要把 i++ 写在 for 循环里边，不能写成 for (int i = 0; i < times;i++) 这样

使用 wait/notify

其实遇到这类型题目，好多同学可能会先想到的就是 join()，或者 wati/notify 这样的思路。算是比较传统且万能的解决方案。也有些面试官会要求不能使用这种方式
思路：还是以第一题为例，我们用对象监视器来实现，通过 wait 和 notify() 方法来实现等待、通知的逻辑，A 执行后，唤醒 B，B 执行后唤醒 C，C 执行后再唤醒 A，这样循环的等待、唤醒来达到目的

public class PrintABCUsingWaitNotify {

    private int state;
    private int times;
    private static final Object LOCK = new Object();

    public PrintABCUsingWaitNotify(int times) {
        this.times = times;
    }

    public static void main(String[] args) {
        PrintABCUsingWaitNotify printABC = new PrintABCUsingWaitNotify(10);
        new Thread(() -> {
            printABC.printLetter("A", 0);
        }, "A").start();
        new Thread(() -> {
            printABC.printLetter("B", 1);
        }, "B").start();
        new Thread(() -> {
            printABC.printLetter("C", 2);
        }, "C").start();
    }

    private void printLetter(String name, int targetState) {
        for (int i = 0; i < times; i++) {
            synchronized (LOCK) {
                while (state % 3 != targetState) {
                    try {
                        LOCK.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                state++;
                System.out.print(name);
                LOCK.notifyAll();
            }
        }
    }
}

同样的思路，来解决下第 2 题：两个线程交替打印奇数和偶数，使用对象监视器实现，两个线程 A、B 竞争同一把锁，只要其中一个线程获取锁成功，就打印 ++i，并通知另一线程从等待集合中释放，然后自身线程加入等待集合并释放锁即可

public class OddEvenPrinter {

    private Object monitor = new Object();
    private final int limit;
    private volatile int count;

    OddEvenPrinter(int initCount, int times) {
        this.count = initCount;
        this.limit = times;
    }

    public static void main(String[] args) {

        OddEvenPrinter printer = new OddEvenPrinter(0, 10);
        new Thread(printer::print, "odd").start();
        new Thread(printer::print, "even").start();
    }

    private void print() {
        synchronized (monitor) {
            while (count < limit) {
                try {
                    System.out.println(String.format("线程[%s]打印数字:%d", Thread.currentThread().getName(), ++count));
                    monitor.notifyAll();
                    monitor.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //防止有子线程被阻塞未被唤醒，导致主线程不退出
            monitor.notifyAll();
        }
    }
}

同样的思路，来解决下第 5 题：用两个线程，一个输出字母，一个输出数字，交替输出 1A2B3C4D…26Z

public class NumAndLetterPrinter {
    private static char c = 'A';
    private static int i = 0;
    static final Object lock = new Object();

    public static void main(String[] args) {
        new Thread(() -> printer(), "numThread").start();
        new Thread(() -> printer(), "letterThread").start();
    }

    private static void printer() {
        synchronized (lock) {
            for (int i = 0; i < 26; i++) {
                if (Thread.currentThread().getName() == "numThread") {
                    //打印数字1-26
                    System.out.print((i + 1));
                    // 唤醒其他在等待的线程
                    lock.notifyAll();
                    try {
                        // 让当前线程释放锁资源，进入wait状态
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else if (Thread.currentThread().getName() == "letterThread") {
                    // 打印字母A-Z
                    System.out.print((char) ('A' + i));
                    // 唤醒其他在等待的线程
                    lock.notifyAll();
                    try {
                        // 让当前线程释放锁资源，进入wait状态
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            lock.notifyAll();
        }
    }
}
使用 Lock/Condition

还是以第一题为例，使用 Condition 来实现，其实和 wait/notify 的思路一样
Condition 中的 await() 方法相当于 Object 的 wait() 方法，Condition 中的 signal() 方法相当于Object 的 notify() 方法，Condition 中的 signalAll() 相当于 Object 的 notifyAll() 方法
不同的是，Object 中的 wait(),notify(),notifyAll()方法是和"同步锁"(synchronized关键字)捆绑使用的；而 Condition 是需要与"互斥锁"/"共享锁"捆绑使用的

public class PrintABCUsingLockCondition {

    private int times;
    private int state;
    private static Lock lock = new ReentrantLock();
    private static Condition c1 = lock.newCondition();
    private static Condition c2 = lock.newCondition();
    private static Condition c3 = lock.newCondition();

    public PrintABCUsingLockCondition(int times) {
        this.times = times;
    }

    public static void main(String[] args) {
        PrintABCUsingLockCondition print = new PrintABCUsingLockCondition(10);
        new Thread(() -> {
            print.printLetter("A", 0, c1, c2);
        }, "A").start();
        new Thread(() -> {
            print.printLetter("B", 1, c2, c3);
        }, "B").start();
        new Thread(() -> {
            print.printLetter("C", 2, c3, c1);
        }, "C").start();
    }

    private void printLetter(String name, int targetState, Condition current, Condition next) {
        for (int i = 0; i < times; ) {
            lock.lock();
            try {
                while (state % 3 != targetState) {
                    current.await();
                }
                state++;
                i++;
                System.out.print(name);
                next.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}

使用 Lock 锁的多个 Condition 可以实现精准唤醒，所以碰到那种多个线程交替打印不同次数的题就比较容易想到，比如解决第四题：多线程按顺序调用，A->B->C，AA 打印 5 次，BB 打印10 次，CC 打印 15 次，重复 10 次
以上几种方式，其实都会存在一个锁的抢夺过程，如果抢锁的的线程数量足够大，就会出现很多线程抢到了锁但不该自己执行，然后就又解锁或 wait() 这种操作，这样其实是有些浪费资源的

使用 Semaphore

在信号量上我们定义两种操作： 信号量主要用于两个目的，一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制

  1. acquire（获取） 当一个线程调用 acquire 操作时，它要么通过成功获取信号量（信号量减1），要么一直等下去，直到有线程释放信号量，或超时
  2. release（释放）实际上会将信号量的值加1，然后唤醒等待的线程
    先看下如何解决第一题：三个线程循环打印 A，B，C
public class PrintABCUsingSemaphore {
    private int times;
    private static Semaphore semaphoreA = new Semaphore(1); // 只有A 初始信号量为1,第一次获取到的只能是A
    private static Semaphore semaphoreB = new Semaphore(0);
    private static Semaphore semaphoreC = new Semaphore(0);

    public PrintABCUsingSemaphore(int times) {
        this.times = times;
    }

    public static void main(String[] args) {
        PrintABCUsingSemaphore printer = new PrintABCUsingSemaphore(1);
        new Thread(() -> {
            printer.print("A", semaphoreA, semaphoreB);
        }, "A").start();

        new Thread(() -> {
            printer.print("B", semaphoreB, semaphoreC);
        }, "B").start();

        new Thread(() -> {
            printer.print("C", semaphoreC, semaphoreA);
        }, "C").start();
    }

    private void print(String name, Semaphore current, Semaphore next) {
        for (int i = 0; i < times; i++) {
            try {
                System.out.println("111" + Thread.currentThread().getName());
                current.acquire();  // A获取信号执行,A信号量减1,当A为0时将无法继续获得该信号量
                System.out.print(name);
                next.release();    // B释放信号，B信号量加1（初始为0），此时可以获取B信号量
                System.out.println("222" + Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

如果题目中是多个线程循环打印的话，一般使用信号量解决是效率较高的方案，上一个线程持有下一个线程的信号量，通过一个信号量数组将全部关联起来，这种方式不会存在浪费资源的情况
接着用信号量的方式解决下第三题：通过 N 个线程顺序循环打印从 0 至 100

public class LoopPrinter {

    private final static int THREAD_COUNT = 3;
    static int result = 0;
    static int maxNum = 10;

    public static void main(String[] args) throws InterruptedException {
        final Semaphore[] semaphores = new Semaphore[THREAD_COUNT];
        for (int i = 0; i < THREAD_COUNT; i++) {
            //非公平信号量，每个信号量初始计数都为1
            semaphores[i] = new Semaphore(1);
            if (i != THREAD_COUNT - 1) {
                System.out.println(i+"==="+semaphores[i].getQueueLength());
                //获取一个许可前线程将一直阻塞, for 循环之后只有 syncObjects[2] 没有被阻塞
                semaphores[i].acquire();
            }
        }
        for (int i = 0; i < THREAD_COUNT; i++) {
            // 初次执行，上一个信号量是 syncObjects[2]
            final Semaphore lastSemphore = i == 0 ? semaphores[THREAD_COUNT - 1] : semaphores[i - 1];
            final Semaphore currentSemphore = semaphores[i];
            final int index = i;
             new Thread(() -> {
                try {
                    while (true) {
                        // 初次执行，让第一个 for 循环没有阻塞的 syncObjects[2] 先获得令牌阻塞了
                        lastSemphore.acquire();
                        System.out.println("thread" + index + ": " + result++);
                        if (result > maxNum) {
                            System.exit(0);
                        }
                        // 释放当前的信号量，syncObjects[0] 信号量此时为 1，下次 for 循环中上一个信号量即为syncObjects[0]
                        currentSemphore.release();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}
使用 LockSupport

LockSupport 是 JDK 底层的基于 sun.misc.Unsafe 来实现的类，用来创建锁和其他同步工具类的基本线程阻塞原语。它的静态方法 unpark() 和 park() 可以分别实现阻塞当前线程和唤醒指定线程的效果，所以用它解决这样的问题会更容易一些。（在AQS中，就是通过调用LockSupport.park()和LockSupport.unpark()来实现线程的阻塞和唤醒的）

public class PrintABCUsingLockSupport {

    private static Thread threadA, threadB, threadC;

    public static void main(String[] args) {
        threadA = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                // 打印当前线程名称
                System.out.print(Thread.currentThread().getName());
                // 唤醒下一个线程
                LockSupport.unpark(threadB);
                // 当前线程阻塞
                LockSupport.park();
            }
        }, "A");
        threadB = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                // 先阻塞等待被唤醒
                LockSupport.park();
                System.out.print(Thread.currentThread().getName());
                // 唤醒下一个线程
                LockSupport.unpark(threadC);
            }
        }, "B");
        threadC = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                // 先阻塞等待被唤醒
                LockSupport.park();
                System.out.print(Thread.currentThread().getName());
                // 唤醒下一个线程
                LockSupport.unpark(threadA);
            }
        }, "C");
        threadA.start();
        threadB.start();
        threadC.start();
    }
}

理解了思路，解决其他问题就容易太多了
比如，我们再解决下第五题：用两个线程，一个输出字母，一个输出数字，交替输出 1A2B3C4D…26Z

public class NumAndLetterPrinter {

    private static Thread numThread, letterThread;

    public static void main(String[] args) {
        letterThread = new Thread(() -> {
            for (int i = 0; i < 26; i++) {
                System.out.print((char) ('A' + i));
                LockSupport.unpark(numThread);
                LockSupport.park();
            }
        }, "letterThread");

        numThread = new Thread(() -> {
            for (int i = 1; i <= 26; i++) {
                System.out.print(i);
                LockSupport.park();
                LockSupport.unpark(letterThread);
            }
        }, "numThread");
        numThread.start();
        letterThread.start();
    }
}

好了，以上就是常用的五种实现方案，多练习几次，手撕没问题
当然，这类问题，解决方式不止是我列出的这些，还会有 join、CountDownLatch、也有放在队列里解决的，思路有很多，面试官想考察的其实只是对多线程的编程功底，其实自己练习的时候，是个很好的巩固理解 JUC 的过程

我永远吹着泡泡
关注
专栏目录
并发与多线程(三) --- 线程同步
weixin_47081743的博客
10-25 277
文章目录一、线程同步是什么？二、Volatile三、信号量同步总结 一、线程同步是什么？ 资源共享的两个原因是资源紧缺和共建需求。线程共享CPU 是从资源紧缺的维度来考虑的，而多线程共享同一变量，通常是从共建需求的维度来考虑的。 在多个线程对同一变量进行写操作时，如果操作没有原子性，就可能产生脏数据。 所谓原子性是指不可分割的一系列操作指令，在执行完毕前不会被任何其他操作中断，要么全部执行，要么全部不执行。如果每个线程的修改都是原子操作，就不存在线程同步问题。有些看似非常简单的操作其实不具备具备原子性..
多个线程线程顺序打印
m0_47360218的博客
02-28 249
多个线程线程顺序打印：标序号，顺序打印。 下面程序使用可重入锁ReentranceLock。每个线程的打印部分循环了十次，循环打印的核心操作由lock控制。 import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class test { private int times = 10; // 启动四个线程 private int count =
多线程按序打印
dhusubing的博客
12-16 334
多线程按序打印录
多线程之间按顺序调用，实现A-＞B-＞C 要求如下：AA打印5次，BB打印10次，CC打印15次 ，接着AA打印5次，BB打印10次，CC打印15次，来10轮
m0_56098159的博客
08-31 222
多个线程之间按顺序调用。实现A -> B -> C 三个线程打印A打印5次，B打印10次，C打印15次 重复10次
that summer
10-11 691
package test; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /* 多个线程之间按顺序调用。实现A -> B -> C 三个线程打印 * A打印5...
浩克 绿巨人拆件3d打印stl模型.zip
07-07
在这个案例中，绿巨人浩克模型被分解成了多个部件，这样每个部分都可以在3D打印机的有效工作区域内轻松打印，减少了打印过程中的复杂性。 3D渲染是指在计算机图形学中，将三维模型转化为二维图像的过程，通常用于...
（Linux C）利用多进程或多线程模拟实现生产者/消费者问题
12-30
最后，关于"站在巨人的肩膀上"，这句描述可能暗示在实现过程中参考了已有的开源代码或研究，这是学习和进步的一个良好实践。在编写代码时，借鉴他人的经验，理解其原理，再结合自身需求进行改进，可以有效地提高编程...
20210531-华金证券-卓越商企服务-6989.HK-站在巨人肩膀上的商务物管领军企业.pdf
05-31
在分析卓越商企服务有限公司（股票代码：6989.HK）的这篇证券研究报告中，我们可以提炼出以下几个重要的知识点： 1. **市场定位与业务模式**： - 卓越商企服务定位于中高端市场，其管理的大部分商务物业位于核心...
使用Java语言开发,站在巨人肩膀上制作了异步非阻塞的IM,采用官方协议适配器解决
10-18
本项目“站在巨人肩膀上制作的异步非阻塞IM”是一个基于Java语言实现的高效通信平台，它巧妙地利用了现有的开源技术和工具，以解决大规模并发下的高性能通信问题。以下将详细阐述这个项目中的关键知识点。 首先，...
绿洲APP产品分析报告：站在巨人肩膀上能否看得更远？.pdf
07-22
绿洲APP产品分析报告：站在巨人肩膀上能否看得更远？.pdf
JUC学习笔记（4）—多线程之间按顺序调用
java_kider的博客
07-31 368
多线程之间按顺序调用，实现A-&gt;B-&gt;C 三个线程启动，要求如下： AA打印5次，BB打印10次，CC打印15次   接着 AA打印5次，BB打印10次，CC打印15次    。来10轮     public class ThreadOrderAccess { public static void main(String[] args) { ShareResource s...
多线程打印每个线程的线程ID
力尽山拔的博客
10-28 1381
#include <iostream> #include<thread> #include<mutex> #include<condition_variable> using namespace std; mutex mu; condition_variable cv; int flag = 0; void print_id(int id){ unique_lock<mutex> lk(mu); for(int i=0; i&.
Java多线程之多线程之间按顺序调用
努力努力再努力L
05-13 643
Java多线程之多线程之间按顺序调用 多线程之间按顺序调用，实现A->B->C 1. 要求： AA打印5次，BB打印10次，CC打印15次 接着 AA打印5次，BB打印10次，CC打印15次 …来10轮 代码实现： import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Loc...
java种方法解决多线程循环打印AB问题
GEEK-BANANA
02-18 1377
目录使用notify和wait来实现交替打印使用阻塞队列来实现使用CyclicBarrier实现使用自旋实现使用ReentrantLock实现使用信号量实现 在控制台循环打印A和B 使用notify和wait来实现交替打印 public class PrintAAndB { public static void main(String[] args) { new ThreadA().start(); new ThreadB().start(); }
多线程之间按顺序调用，实现A->B->C三个线程启动（使用Lock锁）
热门推荐
BestQiang的博客
05-17 1万+
题目：多线程之间按顺序调用，实现A->B->C三个线程启动，要求如下： AA打印5次，BB打印10次，CC打印15次 …来十轮 思路：使用Lock锁的多个Condition实现精准唤醒。 package com.bestqiang.thread.Queue; /** * @author BestQiang */ import java.util.concurrent.loc...
synchronized和Lock有什么区别？用新的Lock有什么好处？多线程之间按顺序调用，实现A->B->C三个线程启动，要求如下： AA打印5次，BB打印10次，CC打印15次，循环10次
qq_40823802的博客
08-03 609
** 区别： ** 1.原始构成： synchronized： synchronized是Java关键字，属于JVM层面。（monitorenter（底层是通过monitor对象来完成，其实wait/notify等方法）也依赖于monitor对象只有在同步块或方法中才能调wait/notify等方法。） Lock： 是具体类（java.util.concurrent.locks.Lock）是api...
数据结构-栈和队列
theglasssky的博客
12-11 1040
关于栈和队列的基本操作方式
3^100的位数判断
T_Y_F_的博客
11-05 304
3^100的位数判断
摩尔线程嵌入式面试题及参考答案（2万字长文）
最新发布
大模型大数据攻城狮的专栏
11-06 231
说一下你对 drm 框架的理解。 DRM（Direct Rendering Manager）是 Linux 系统中用于管理图形显示设备的一个重要框架。 从架构层面来讲，它处于内核空间，主要目的是为用户空间的图形应用程序提供一个统一的接口来访问图形硬件。DRM 包括内核态的驱动模块和用户态的库。内核态的驱动负责和硬件进行交互，比如对显存的管理、硬件寄存器的配置等。用户态的库则方便应用程序利用内核态提供的功能进行图形渲染等操作。 在图形显示的具体流程中，DRM 可以控制显示设备的分辨率、刷
巨人花园Scratch编程项目源码素材
资源摘要信息:"此资源包包含了一个名为《巨人的花园》的Scratch编程项目，项目源文件的格式为.zip，适用于Scratch 2.0和3.0版本。该项目可用于个人技术学习、学生毕业设计以及小团队项目开发作为参考案例和素材。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值