多线程编程常见面试题-使用多线程实现循环打印功能-duidaima 堆代码

多线程编程常见面试题-使用多线程实现循环打印功能

发布于 2个月前
 175 热度

 0 评论

晴格与猫
0 粉丝 37 篇博客

问题描述
给定三个线程，分别命名为A、B、C，要求这三个线程按照顺序交替打印ABC，每个字母打印100次，最终输出结果为：

A
B
C
A
B
C
...
A
B
C

解决思路
这是一个典型的多线程同步的问题，需要保证每个线程在打印字母之前，能够判断是否轮到自己执行，以及在打印字母之后，能够通知下一个线程执行。为了实现这一目标，博主讲介绍以下5种方法：
方法一：使用synchronized和wait/notify
synchronized是Java中的一个关键字，用于实现对共享资源的互斥访问。wait和notify是Object类中的两个方法，用于实现线程间的通信。wait方法会让当前线程释放锁，并进入等待状态，直到被其他线程唤醒。notify方法会唤醒一个在同一个锁上等待的线程。

我们可以使用一个共享变量state来表示当前应该打印哪个字母，初始值为0。当state为0时，表示轮到A线程打印；当state为1时，表示轮到B线程打印；当state为2时，表示轮到C线程打印。每个线程在打印完字母后，需要将state加1，并对3取模，以便循环。同时，每个线程还需要唤醒下一个线程，并让自己进入等待状态。

具体的代码实现如下：

public class PrintABC {
    // 堆代码 duidaima.com
    // 共享变量，表示当前应该打印哪个字母
    private static int state = 0;

    // 共享对象，作为锁和通信的媒介
    private static final Object lock = new Object();

    public static void main(String[] args) {
        // 创建三个线程
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    // 循环100次
                    for (int i = 0; i < 100; i++) {
                        // 获取锁
                        synchronized (lock) {
                            // 判断是否轮到自己执行
                            while (state % 3 != 0) {
                                // 不是则等待
                                lock.wait();
                            }
                            // 打印字母
                            System.out.println("A");
                            // 修改状态
                            state++;
                            // 唤醒下一个线程
                            lock.notifyAll();
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    for (int i = 0; i < 100; i++) {
                        synchronized (lock) {
                            while (state % 3 != 1) {
                                lock.wait();
                            }
                            System.out.println("B");
                            state++;
                            lock.notifyAll();
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread threadC = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    for (int i = 0; i < 100; i++) {
                        synchronized (lock) {
                            while (state % 3 != 2) {
                                lock.wait();
                            }
                            System.out.println("C");
                            state++;
                            lock.notifyAll();
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // 启动三个线程
        threadA.start();
        threadB.start();
        threadC.start();
    }
}

方法二：使用ReentrantLock和Condition
ReentrantLock是Java中的一个类，用于实现可重入的互斥锁。Condition是ReentrantLock中的一个接口，用于实现线程间的条件等待和唤醒。ReentrantLock可以创建多个Condition对象，每个Condition对象可以绑定一个或多个线程，实现对不同线程的精确控制。

我们可以使用一个ReentrantLock对象作为锁，同时创建三个Condition对象，分别绑定A、B、C三个线程。每个线程在打印字母之前，需要调用对应的Condition对象的await方法，等待被唤醒。每个线程在打印字母之后，需要调用下一个Condition对象的signal方法，唤醒下一个线程。

具体的代码实现如下：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class PrintABC {

    // 共享变量，表示当前应该打印哪个字母
    private static int state = 0;

    // 可重入锁
    private static final ReentrantLock lock = new ReentrantLock();

    // 三个条件对象，分别绑定A、B、C三个线程
    private static final Condition A = lock.newCondition();
    private static final Condition B = lock.newCondition();
    private static final Condition C = lock.newCondition();

    public static void main(String[] args) {
        // 创建三个线程
        Thread threaA = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    // 循环100次
                    for (int i = 0; i < 100; i++) {
                        // 获取锁
                        lock.lock();
                        try {
                            // 判断是否轮到自己执行
                            while (state % 3 != 0) {
                                // 不是则等待
                                A.await();
                            }
                            // 打印字母
                            System.out.println("A");
                            // 修改状态
                            state++;
                            // 唤醒下一个线程
                            B.signal();
                        } finally {
                            // 释放锁
                            lock.unlock();
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread threaB = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    for (int i = 0; i < 100; i++) {
                        lock.lock();
                        try {
                            while (state % 3 != 1) {
                                B.await();
                            }
                            System.out.println("B");
                            state++;
                            C.signal();
                        } finally {
                            lock.unlock();
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread threaC = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    for (int i = 0; i < 100; i++) {
                        lock.lock();
                        try {
                            while (state % 3 != 2) {
                                C.await();
                            }
                            System.out.println("C");
                            state++;
                            A.signal();
                        } finally {
                            lock.unlock();
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // 启动三个线程
        threaA.start();
        threaB.start();
        threaC.start();
    }
}

方法三：使用Semaphore
Semaphore是Java中的一个类，用于实现信号量机制。信号量是一种计数器，用于控制对共享资源的访问。Semaphore可以创建多个信号量对象，每个信号量对象可以绑定一个或多个线程，实现对不同线程的精确控制。

我们可以使用三个Semaphore对象，分别初始化为1、0、0，表示A、B、C三个线程的初始许可数。每个线程在打印字母之前，需要调用对应的Semaphore对象的acquire方法，获取许可。每个线程在打印字母之后，需要调用下一个Semaphore对象的release方法，释放许可。

具体的代码实现如下：

import java.util.concurrent.Semaphore;

public class PrintABC {
    private static int state = 0;

    // 三个信号量对象，分别表示A、B、C三个线程的初始许可数
    private static final Semaphore A = new Semaphore(1);
    private static final Semaphore B = new Semaphore(0);
    private static final Semaphore C = new Semaphore(0);

    public static void main(String[] args) {
        // 创建三个线程
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    // 循环100次
                    for (int i = 0; i < 100; i++) {
                        // 获取许可
                        A.acquire();
                        // 打印字母
                        System.out.println("A");
                        // 修改状态
                        state++;
                        // 释放许可
                        B.release();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    for (int i = 0; i < 100; i++) {
                        B.acquire();
                        System.out.println("B");
                        state++;
                        C.release();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread threadC = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    for (int i = 0; i < 100; i++) {
                        C.acquire();
                        System.out.println("C");
                        state++;
                        A.release();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // 启动三个线程
        threadA.start();
        threadB.start();
        threadC.start();
    }
}

方法四：使用AtomicInteger和CAS
AtomicInteger是Java中的一个类，用于实现原子性的整数操作。CAS是一种无锁的算法，全称为Compare And Swap，即比较并交换。CAS操作需要三个参数：一个内存地址，一个期望值，一个新值。如果内存地址的值与期望值相等，就将其更新为新值，否则不做任何操作。

我们可以使用一个AtomicInteger对象来表示当前应该打印哪个字母，初始值为0。当state为0时，表示轮到A线程打印；当state为1时，表示轮到B线程打印；当state为2时，表示轮到C线程打印。每个线程在打印完字母后，需要使用CAS操作将state加1，并对3取模，以便循环。

具体的代码实现如下：

import java.util.concurrent.atomic.AtomicInteger;
public class PrintABC {

    // 共享变量，表示当前应该打印哪个字母
    private static AtomicInteger state = new AtomicInteger(0);

    public static void main(String[] args) {
        // 创建三个线程
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                // 循环100次
                for (int i = 0; i < 100; ) {
                    // 判断是否轮到自己执行
                    if (state.get() % 3 == 0) {
                        // 打印字母
                        System.out.println("A");
                        // 修改状态，使用CAS操作保证原子性
                        state.compareAndSet(state.get(), state.get() + 1);
                        // 计数器加1
                        i++;
                    }
                }
            }
        });

        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; ) {
                    if (state.get() % 3 == 1) {
                        System.out.println("B");
                        state.compareAndSet(state.get(), state.get() + 1);
                        i++;
                    }
                }
            }
        });

        Thread threadC = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; ) {
                    if (state.get() % 3 == 2) {
                        System.out.println("C");
                        state.compareAndSet(state.get(), state.get() + 1);
                        i++;
                    }
                }
            }
        });

        // 启动三个线程
        threadA.start();
        threadB.start();
        threadC.start();
    }
}

方法五：使用CyclicBarrier
CyclicBarrier是Java中的一个类，用于实现多个线程之间的屏障。CyclicBarrier可以创建一个屏障对象，指定一个参与等待线程数和一个到达屏障点时得动作。当所有线程都到达屏障点时，会执行屏障动作，然后继续执行各自的任务。CyclicBarrier可以重复使用，即当所有线程都通过一次屏障后，可以再次等待所有线程到达下一次屏障。

我们可以使用一个CyclicBarrier对象，指定三个线程为参与等待数，以及一个打印字母的到达屏障点动作。每个线程在执行完自己的任务后，需要调用CyclicBarrier对象的await方法，等待其他线程到达屏障点。当所有线程都到达屏障点时，会执行打印字母的屏障动作，并根据state的值判断应该打印哪个字母。然后，每个线程继续执行自己的任务，直到循环结束。需要注意得就是由于打印操作在到达屏障点得动作内执行，所以三个线程得循环次数得乘以参与线程数量，也就是三。

具体的代码实现如下：

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class PrintABC {

    // 共享变量，表示当前应该打印哪个字母
    private static int state = 0;

    // 参与线程数量
    private static int threadNum = 3;

    // 循环屏障，指定三个线程为屏障点，以及一个打印字母的屏障动作
    private static final CyclicBarrier barrier = new CyclicBarrier(threadNum, new Runnable() {
        @Override
        public void run() {
            // 根据state的值判断应该打印哪个字母
            switch (state) {
                case 0:
                    System.out.println("A");
                    break;
                case 1:
                    System.out.println("B");
                    break;
                case 2:
                    System.out.println("C");
                    break;
            }
            // 修改状态
            state = (state + 1) % 3;
            System.out.println(state);
        }
    });

    public static void main(String[] args) {
        // 创建三个线程
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    // 循环100次
                    for (int i = 0; i < threadNum * 100; i++) {
                        // 执行自己的任务
                        // ...
                        // 等待其他线程到达屏障点
                        barrier.await();
                    }
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    for (int i = 0; i < threadNum * 100; i++) {
                        // 执行自己的任务
                        // ...
                        // 等待其他线程到达屏障点
                        barrier.await();
                    }
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread threadC = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    for (int i = 0; i < threadNum * 100; i++) {
                        // 执行自己的任务
                        // ...
                        // 等待其他线程到达屏障点
                        barrier.await();
                    }
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        });

        // 启动三个线程
        threadA.start();
        threadB.start();
        threadC.start();
    }
}

总结
到此，本文内容已经讲解完毕，以上的这五种方法都可以利用不同的工具和机制来实现多线程之间的同步和通信，从而保证按照顺序交替打印ABC。这些方法各有优缺点，具体的选择需要根据实际的场景和需求来决定。

最后本文讲解代码是在单个JVM内的实现方法，如果大家对涉及到多个JVM来实现按照顺序交替打印ABC的话，可以私信博主，博主再给大家出一期文章进行讲解。

 用户评论

JAVA编程
 197 成员 |  794 话题
+我要提问 +随便写写

可能感兴趣的话题

JAVA转其它语言不行，那JAVA转大数据如何？

SpringBoot中如何使用策略模式解决多路支付通道问题

过滤器 (Filter) 和拦截器 (Interceptor) 有什么区别？

新版Spring Security 中的路径匹配方案