[Java 并发]面试官:三个线程顺序执行,你来说说有几种实现方式?

红太狼 2022-12-07 12:27 52阅读 0赞

写在前面:  
越是基础知识,越要系统  
正文开始:

先说下要求,就是三个线程,假设是线程 1,2,3, 现在的要求是:必须是线程 1 先执行,然后线程 2 再执行,最后是线程 3 执行  
然后有几种实现方法呢?  
其实它的本质就是实现,让线程 2,3 等待线程 1 执行完毕,所以重点就是有哪些方法可以让线程 2,3 等待

# join #

第一反应应该就是使用 join 方法,因为 join 本来就是支持这种机制的  
比如,我在线程 B 中调用了线程 A 的 join 方法,那么线程 B 就会等线程 A 执行结束之后再执行.  
那么具体应该怎么使用嘞?  
别慌嘛,我这里有例子,你瞅瞅:

public class ThreadLoopOne { 
        public static void main(String[] args) { 
            Thread t1 = new Thread(new Work(null));
            Thread t2 = new Thread(new Work(t1));
            Thread t3 = new Thread(new Work(t2));
    
            t1.start();
            t2.start();
            t3.start();
        }
    
        static class Work implements Runnable { 
            private Thread beforeThread;
            public Work(Thread beforeThread){ 
                this.beforeThread = beforeThread;
            }
    
            @Override
            public void run() { 
                // 如果有线程,就 join 进来,没有的话就直接输出
                if (beforeThread != null ){ 
                    try { 
                        beforeThread.join();
                        System.out.println("thread start : " + Thread.currentThread().getName());
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }else{ 
                    System.out.println("thread start : " + Thread.currentThread().getName());
                }
            }
        }
    }

# CountDownLatch #

刚才说了,本质就是让线程 B,C 等待线程 A 执行完毕  
那么信号量就是一个不错的选择  
如果想要实现的话,那大概就是下面这样:

public class ThreadLoopTwo { 
        public static void main(String[] args) { 
            // 设置线程 1 的信号量为 0
            CountDownLatch cOne = new CountDownLatch(0);
            // 设置线程 2 的信号量为 1
            CountDownLatch cTwo = new CountDownLatch(1);
            // 设置线程 3 的信号量为 1
            CountDownLatch cThree = new CountDownLatch(1);
    
            // 因为 cOne 为 0 ,故 t1 可以直接执行
            Thread t1 = new Thread(new Work(cOne,cTwo));
            // 线程 t1 执行完毕之后,此时的 cTwo 为 0 , t2 开始执行
            Thread t2 = new Thread(new Work(cTwo,cThree));
            // 线程 t2 执行完毕,此时 cThree 为 0 , t3 开始执行
            Thread t3 = new Thread(new Work(cThree,cThree));
    
            t1.start();
            t2.start();
            t3.start();
        }
    
        static class Work implements Runnable{ 
            CountDownLatch cOne;
            CountDownLatch cTwo;
    
            public Work(CountDownLatch cOne, CountDownLatch cTwo){ 
                super();
                this.cOne = cOne;
                this.cTwo = cTwo;
            }
            @Override
            public void run() { 
                try { 
                    // 当前一个线程信号量为 0 时,才执行
                    cOne.await();
                    System.out.println("thread start : " + Thread.currentThread().getName());
                    // 后一个线程信号量减 1
                    cTwo.countDown();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
        }
    }

# 使用单个线程池 #

之所以线程 1,2,3 的执行顺序无法保证,是因为在编译器可能会去做一些优化,导致没有办法按照顺序执行  
如果我们使用单个线程池去执行的话,那就没有这样的问题了  
具体实现:

public class ThreadLoopThree { 
        public static void main(String[] args) { 
            Thread t1 = new Thread(new Runnable() { 
                @Override
                public void run() { 
                    System.out.println("thread start : " + Thread.currentThread().getName() + " run one");
                }
            });
    
            Thread t2 = new Thread(new Runnable() { 
                @Override
                public void run() { 
                    System.out.println("thread start : " + Thread.currentThread().getName() + " run two");
                }
            });
    
            Thread t3 = new Thread(new Runnable() { 
                @Override
                public void run() { 
                    System.out.println("thread start : " + Thread.currentThread().getName() + " run three");
                }
            });
    
            ExecutorService executor = Executors.newSingleThreadExecutor();
            // 将线程依次加入到线程池中
            executor.submit(t1);
            executor.submit(t2);
            executor.submit(t3);
            // 及时将线程池关闭
            executor.shutdown();
        }
    }

# CompletableFuture #

如果使用 CompletableFuture 来实现的话,代码就非常简洁了

public class ThreadLoopFour { 
        public static void main(String[] args)  { 
            Thread t1 = new Thread(new Work());
            Thread t2 = new Thread(new Work());
            Thread t3 = new Thread(new Work());
    
            CompletableFuture.runAsync(()-> t1.start())
                    .thenRun(()->t2.start())
                    .thenRun(()->t3.start());
        }
    
        static class Work implements Runnable{ 
            @Override
            public void run() { 
                System.out.println("thread start : " + Thread.currentThread().getName());
            }
        }
    }

你还有别的什么方法么?欢迎评论区和我交流~  
以上,非常感谢您的阅读哇