java八股文面试[多线程]——三个线程交替打印ABC

心已赠人 2024-03-02 09:53 59阅读 0赞

建立三个线程A、B、C，A线程打印10次字母A，B线程打印10次字母B,C线程打印10次字母C，但是要求三个线程同时运行，并且实现交替打印，即按照ABCABCABC的顺序打印。

######    一、Synchronized同步法 ######

1、基本思路  
使用**同步块和wait、notify**的方法控制三个线程的执行次序。具体方法如下：从大的方向上来讲，该问题为三线程间的同步唤醒操作，主要的目的就是**ThreadA->ThreadB->ThreadC->ThreadA循环执行**三个线程。为了控制线程执行的顺序，那么就必须要确定唤醒、等待的顺序，所以每一个线程**必须同时持有两个对象锁**，才能进行打印操作。一个**对象锁是prev**，就是前一个线程所对应的对象锁，其主要作用是保证当前线程一定是在**前一个线程操作完成后**（即前一个线程释放了其对应的对象锁）才开始执行。还有一个锁就是**自身对象锁**。主要的思想就是，为了控制执行的顺序，必须要**先持有prev锁**（也就前一个线程要释放其自身对象锁），然后当前线程**再申请自己对象锁**，两者兼备时打印。之后首先调用self.notify()唤醒下一个等待线程（注意notify不会立即释放对象锁，只有等到同步块代码执行完毕后才会释放），再调用prev.wait()**立即释放**prev对象锁，当前线程进入休眠，等待其他线程的notify操作再次唤醒。

public class ABC_Synch {
        public static class ThreadPrinter implements Runnable {
            private String name;
            private Object prev;
            private Object self;
            private ThreadPrinter(String name, Object prev, Object self) {
                this.name = name;
                this.prev = prev;
                this.self = self;
            }
            @Override
            public void run() {
                int count = 10;
                while (count > 0) {// 多线程并发，不能用if，必须使用whil循环
                    synchronized (prev) { // 先获取 prev 锁
                        synchronized (self) {// 再获取 self 锁
                            System.out.print(name);// 打印
                            count--;
    
                            self.notifyAll();// 唤醒其他线程竞争self锁，注意此时self锁并未立即释放。
                        }
                        // 此时执行完self的同步块，这时self锁才释放。
                        try {
                            if (count == 0) {// 如果count==0,表示这是最后一次打印操作，通过notifyAll操作释放对象锁。
                                prev.notifyAll();
                            } else {
                                prev.wait(); // 立即释放 prev锁，当前线程休眠，等待唤醒
                            }
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
        public static void main(String[] args) throws Exception {
            Object a = new Object();
            Object b = new Object();
            Object c = new Object();
            ThreadPrinter pa = new ThreadPrinter("A", c, a);
            ThreadPrinter pb = new ThreadPrinter("B", a, b);
            ThreadPrinter pc = new ThreadPrinter("C", b, c);
    
            new Thread(pa).start();
            Thread.sleep(100);// 保证初始ABC的启动顺序
            new Thread(pb).start();
            Thread.sleep(100);
            new Thread(pc).start();
            Thread.sleep(100);
        }
    }

可以看到程序一共定义了a,b,c三个对象锁，分别对应A、B、C三个线程。**A线程最先运行**，A线程按顺序申请c,a对象锁，打印操作后按**顺序释放a,c对象锁**，并且通过notify操作唤醒线程B。线程B首先等待获取A锁，再申请B锁，后打印B，再释放B，A锁，唤醒C。线程C等待B锁，再申请C锁，后打印C，再释放C,B锁，唤醒A。看起来似乎没什么问题，但如果你仔细想一下，就会发现有问题，就是初始条件，三个线程**必须按照A,B,C的顺序来启动**，但是这种假设**依赖于**JVM中线程调度、执行的顺序。

**wait和notify操作的异同**：  
wait() 与 notify/notifyAll() 是Object类的方法，在执行两个方法时，**要先获得锁**。  
当线程执行wait()时，会把当前的锁释放，然后让出CPU，进入**等待状态**。  
当执行notify/notifyAll方法时，**会唤醒**一个处于等待该 对象锁 的线程，然后继续往下执行，直到执行完退出对象锁锁住的区域（synchronized修饰的**代码块**）后再释放锁。  
从这里可以看出，notify/notifyAll()执行后，**并不立即释放锁**，而是要等到执行完临界区中代码后，再释放。所以在实际编程中，我们应该尽量在线程调用notify/notifyAll()后，**立即退出**临界区。即不要在notify/notifyAll()后面再写一些**耗时的代码。**

######    **二、Lock锁方法** ######

1、基本思路  
通过ReentrantLock我们可以很方便的进行**显式的锁操作**，即获取锁和释放锁，对于同一个对象锁而言，统一时刻只可能有一个线程拿到了这个锁，此时其他线程通过lock.lock()来获取对象锁时都会被阻塞，直到这个线程通过lock.unlock()操作释放这个锁后，其他线程才能拿到这个锁。

import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    public class ABC_Lock {
        private static Lock lock = new ReentrantLock();// 通过JDK5中的Lock锁来保证线程的访问的互斥
        private static int state = 0;//通过state的值来确定是否打印
        static class ThreadA extends Thread {
            @Override
            public void run() {
                for (int i = 0; i < 10;) {
                    try {
                        lock.lock();
                        while (state % 3 == 0) {// 多线程并发，不能用if，必须用循环测试等待条件，避免虚假唤醒
                            System.out.print("A");
                            state++;
                            i++;
                        }
                    } finally {
                        lock.unlock();// unlock()操作必须放在finally块中
                    }
                }
            }
        }
        static class ThreadB extends Thread {
            @Override
            public void run() {
                for (int i = 0; i < 10;) {
                    try {
                        lock.lock();
                        while (state % 3 == 1) {
                            System.out.print("B");
                            state++;
                            i++;
                        }
                    } finally {
                        lock.unlock();// unlock()操作必须放在finally块中
                    }
                }
            }
        }
        static class ThreadC extends Thread {
            @Override
            public void run() {
                for (int i = 0; i < 10;) {
                    try {
                        lock.lock();
                        while (state % 3 == 2) {
                            System.out.print("C");
                            state++;
                            i++;
                        }
                    } finally {
                        lock.unlock();// unlock()操作必须放在finally块中
                    }
                }
            }
        }
        public static void main(String[] args) {
            new ThreadA().start();
            new ThreadB().start();
            new ThreadC().start();
        }
    }

程序通过一个类变量，控制三个线程打印输出；因为有三个线程来争抢锁，一个线程释放锁之后不确定被哪个线程抢到锁，所以存在很多次线程拿到锁，但是实际没有打印数据的情况。

###### 三、ReentrantLock结合Condition ######

1、基本思路  
与ReentrantLock搭配的通行方式是Condition，如下：  
private Lock lock = new ReentrantLock();  
private Condition condition = lock.newCondition();  
condition.await();//this.wait();  
condition.signal();//this.notify();  
condition.signalAll();//this.notifyAll();  
Condition是被绑定到Lock上的，必须使用lock.newCondition()才能创建一个Condition。从上面的代码可以看出，Synchronized能实现的通信方式，Condition**都可以实现**，功能类似的代码写在同一行中。这样解题思路就和第一种方法基本一致，只是采用的方法不同。

import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    public class ABC_Condition {
        private static Lock lock = new ReentrantLock();
        private static Condition A = lock.newCondition();
        private static Condition B = lock.newCondition();
        private static Condition C = lock.newCondition();
        private static int count = 0;
        static class ThreadA extends Thread {
            @Override
            public void run() {
                try {
                    lock.lock();
                    for (int i = 0; i < 10; i++) {
                        while (count % 3 != 0)//注意这里是不等于0，也就是说在count % 3为0之前，当前线程一直阻塞状态
                            A.await(); // A释放lock锁
                        System.out.print("A");
                        count++;
                        B.signal(); // A执行完唤醒B线程
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
        static class ThreadB extends Thread {
            @Override
            public void run() {
                try {
                    lock.lock();
                    for (int i = 0; i < 10; i++) {
                        while (count % 3 != 1)
                            B.await();// B释放lock锁，当前面A线程执行后会通过B.signal()唤醒该线程
                        System.out.print("B");
                        count++;
                        C.signal();// B执行完唤醒C线程
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
        static class ThreadC extends Thread {
            @Override
            public void run() {
                try {
                    lock.lock();
                    for (int i = 0; i < 10; i++) {
                        while (count % 3 != 2)
                            C.await();// C释放lock锁，当前面B线程执行后会通过C.signal()唤醒该线程
                        System.out.print("C");
                        count++;
                        A.signal();// C执行完唤醒A线程
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
        public static void main(String[] args) throws InterruptedException {
            new ThreadA().start();
            new ThreadB().start();
            new ThreadC().start();
        }
    }

###### 四、Semaphore信号量方式 ######

1、基本思路  
Semaphore又称信号量，是操作系统中的一个概念，在Java并发编程中，信号量控制的是线程并发的**数量**。

public Semaphore(int permits)  
其中参数permits就是**允许同时运行的线程数目;**  
Semaphore是用来保护一个或者多个共享资源的访问，Semaphore内部维护了一个计数器，其值为可以访问的共享资源的个数。一个线程要访问共享资源，先获得信号量，如果信号量的计数器值大于1，意味着有共享资源可以访问，则使其计数器值**减去1，再访问共享资源**。如果计数器值为0,线程进入**休眠**。当某个线程使用完共享资源后，释放信号量，并将信号量内部的计数器**加1**，之前进入休眠的线程将被唤醒并再次试图获得信号量。

Semaphore使用时需要先构建一个参数来指定共享资源的数量，Semaphore构造完成后即是获取Semaphore、共享资源使用完毕后释放Semaphore。

Semaphore semaphore = new Semaphore(3,true);  
semaphore.acquire();  
//do something here  
semaphore.release();

import java.util.concurrent.Semaphore;
    public class ABC_Semaphore {
        // 以A开始的信号量,初始信号量数量为1
        private static Semaphore A = new Semaphore(1);
        // B、C信号量,A完成后开始,初始信号数量为0
        private static Semaphore B = new Semaphore(0);
        private static Semaphore C = new Semaphore(0);
        static class ThreadA extends Thread {
            @Override
            public void run() {
                try {
                    for (int i = 0; i < 10; i++) {
                        A.acquire();// A获取信号执行,A信号量减1,当A为0时将无法继续获得该信号量
                        System.out.print("A");
                        B.release();// B释放信号，B信号量加1（初始为0），此时可以获取B信号量
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        static class ThreadB extends Thread {
            @Override
            public void run() {
                try {
                    for (int i = 0; i < 10; i++) {
                        B.acquire();
                        System.out.print("B");
                        C.release();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        static class ThreadC extends Thread {
            @Override
            public void run() {
                try {
                    for (int i = 0; i < 10; i++) {
                        C.acquire();
                        System.out.println("C");
                        A.release();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            new ThreadA().start();
            new ThreadB().start();
            new ThreadC().start();
        }
    }

总结：synchronize 和 semaphore 两个没有使用while循环

知识来源：

[三线程按顺序交替打印ABC的四种方法 - 简书][ABC_ -]

[ABC_ -]: https://www.jianshu.com/p/f79fa5aafb44