精华内容
下载资源
问答
  • 线程顺序执行

    万次阅读 多人点赞 2019-11-23 11:43:57
    控制线程执行顺序 一、实现 本文使用了8种方法实现在多线程中让线程顺序运行的方法,涉及到多线程中许多常用的方法,不止为了知道如何让线程顺序运行,更是让读者对多线程的使用有更深刻的了解。使用的...

    控制线程执行顺序

     

     

    一、实现

    本文使用了8种方法实现在多线程中让线程按顺序运行的方法,涉及到多线程中许多常用的方法,不止为了知道如何让线程按顺序运行,更是让读者对多线程的使用有更深刻的了解。使用的方法如下:

    [1] 使用线程的join方法

    [2] 使用主线程的join方法

    [3] 使用线程的wait方法

    [4] 使用线程的线程池方法

    [5] 使用线程的Condition(条件变量)方法

    [6] 使用线程的CountDownLatch(倒计数)方法

    [7] 使用线程的CyclicBarrier(回环栅栏)方法

    [8] 使用线程的Semaphore(信号量)方法

    二、实现

    我们下面需要完成这样一个应用场景:

    1.早上;2.测试人员、产品经理、开发人员陆续的来公司上班;3.产品经理规划新需求;4.开发人员开发新需求功能;5.测试人员测试新功能。

    规划需求,开发需求新功能,测试新功能是一个有顺序的,我们把thread1看做产品经理,thread2看做开发人员,thread3看做测试人员。

     1 

    使用线程的 join 方法

    join():是Theard的方法,作用是调用线程需等待该join()线程执行完成后,才能继续用下运行。

    应用场景:当一个线程必须等待另一个线程执行完毕才能执行时可以使用join方法。

    package com.zhangsf.javabase.thread.order;
    
    
    
    /**
    
     * @author zhangsf
    
     * 通过子程序join使线程按顺序执行
    
     */
    
    public class ThreadJoinDemo {
    
    
    
        public static void main(String[] args) {
    
            final Thread thread1 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    System.out.println("产品经理规划新需求");
    
                }
    
            });
    
    
    
            final Thread thread2 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    try {
    
                        thread1.join();
    
                        System.out.println("开发人员开发新需求功能");
    
                    } catch (InterruptedException e) {
    
                        e.printStackTrace();
    
                    }
    
                }
    
            });
    
    
    
            Thread thread3 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    try {
    
                        thread2.join();
    
                        System.out.println("测试人员测试新功能");
    
                    } catch (InterruptedException e) {
    
                        e.printStackTrace();
    
                    }
    
                }
    
            });
    
    
    
            System.out.println("早上:");
    
            System.out.println("测试人员来上班了...");
    
            thread3.start();
    
            System.out.println("产品经理来上班了...");
    
            thread1.start();
    
            System.out.println("开发人员来上班了...");
    
            thread2.start();
    
        }
    
    }

    运行结果

    早上:

    测试人员来上班了…

    产品经理来上班了…

    开发人员来上班了…

    产品经理规划新需求

    开发人员开发新需求功能

    测试人员测试新功能

     2 

    使用主线程的 join 方法

    这里是在主线程中使用join()来实现对线程的阻塞。

    package com.zhangsf.javabase.thread.order;
    
    
    
    /**
    
     * @author zhangsf
    
     * 通过主程序join使线程按顺序执行
    
     */
    
    public class ThreadMainJoinDemo {
    
    
    
        public static void main(String[] args) throws Exception {
    
    
    
            final Thread thread1 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    System.out.println("产品经理正在规划新需求...");
    
                }
    
            });
    
    
    
            final Thread thread2 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    System.out.println("开发人员开发新需求功能");
    
                }
    
            });
    
    
    
            final Thread thread3 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    System.out.println("测试人员测试新功能");
    
                }
    
            });
    
    
    
            System.out.println("早上:");
    
            System.out.println("产品经理来上班了");
    
            System.out.println("测试人员来上班了");
    
            System.out.println("开发人员来上班了");
    
            thread1.start();
    
            //在父进程调用子进程的join()方法后,父进程需要等待子进程运行完再继续运行。
    
            System.out.println("开发人员和测试人员休息会...");
    
            thread1.join();
    
            System.out.println("产品经理新需求规划完成!");
    
            thread2.start();
    
            System.out.println("测试人员休息会...");
    
            thread2.join();
    
            thread3.start();
    
        }
    
    }

    运行结果

    产品经理来上班了

    测试人员来上班了

    开发人员来上班了

    开发人员和测试人员休息会…

    产品经理正在规划新需求…

    产品经理新需求规划完成!

    测试人员休息会…

    开发人员开发新需求功能

    测试人员测试新功能

     3 

    使用线程的 wait 方法

    wait():是Object的方法,作用是让当前线程进入等待状态,同时,wait()也会让当前线程释放它所持有的锁。“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”,当前线程被唤醒(进入“就绪状态”)

    notify()和notifyAll():是Object的方法,作用则是唤醒当前对象上的等待线程;notify()是唤醒单个线程,而notifyAll()是唤醒所有的线程。

    wait(long timeout):让当前线程处于“等待(阻塞)状态”,“直到其他线程调用此对象的notify()方法或 notifyAll() 方法,或者超过指定的时间量”,当前线程被唤醒(进入“就绪状态”)。

    应用场景:Java实现生产者消费者的方式。

    package com.zhangsf.javabase.thread.order;
    
    
    
    /**
    
     * @author zhangsf
    
     */
    
    public class ThreadWaitDemo {
    
    
    
        private static Object myLock1 = new Object();
    
        private static Object myLock2 = new Object();
    
    
    
        /**
    
         * 为什么要加这两个标识状态?
    
         * 如果没有状态标识,当t1已经运行完了t2才运行,t2在等待t1唤醒导致t2永远处于等待状态
    
         */
    
        private static Boolean t1Run = false;
    
        private static Boolean t2Run = false;
    
        public static void main(String[] args) {
    
    
    
            final Thread thread1 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    synchronized (myLock1){
    
                        System.out.println("产品经理规划新需求...");
    
                        t1Run = true;
    
                        myLock1.notify();
    
                    }
    
                }
    
            });
    
    
    
            final Thread thread2 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    synchronized (myLock1){
    
                        try {
    
                            if(!t1Run){
    
                                System.out.println("开发人员先休息会...");
    
                                myLock1.wait();
    
                            }
    
                            synchronized (myLock2){
    
                                System.out.println("开发人员开发新需求功能");
    
                                myLock2.notify();
    
                            }
    
                        } catch (InterruptedException e) {
    
                            e.printStackTrace();
    
                        }
    
                    }
    
                }
    
            });
    
    
    
            Thread thread3 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    synchronized (myLock2){
    
                        try {
    
                            if(!t2Run){
    
                                System.out.println("测试人员先休息会...");
    
                                myLock2.wait();
    
                            }
    
                            System.out.println("测试人员测试新功能");
    
                        } catch (InterruptedException e) {
    
                            e.printStackTrace();
    
                        }
    
                    }
    
                }
    
            });
    
    
    
            System.out.println("早上:");
    
            System.out.println("测试人员来上班了...");
    
            thread3.start();
    
            System.out.println("产品经理来上班了...");
    
            thread1.start();
    
            System.out.println("开发人员来上班了...");
    
            thread2.start();
    
        }
    
    }

    运行结果:这里输出会有很多种顺序,主要是因为线程进入的顺序,造成锁住线程的顺序不一致。

    早上:

    测试人员来上班了…

    产品经理来上班了…

    开发人员来上班了…

    测试人员先休息会…

    产品经理规划新需求…

    开发人员开发新需求功能

    测试人员测试新功能

     4 

    使用线程的线程池方法

    JAVA通过Executors提供了四种线程池

    • 单线程化线程池(newSingleThreadExecutor);

    • 可控最大并发数线程池(newFixedThreadPool);

    • 可回收缓存线程池(newCachedThreadPool);

    • 支持定时与周期性任务的线程池(newScheduledThreadPool)。

    单线程化线程池(newSingleThreadExecutor):优点,串行执行所有任务。

    submit():提交任务。

    shutdown():方法用来关闭线程池,拒绝新任务。

    应用场景:串行执行所有任务。如果这个唯一的线程因为异常结束,那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

    package com.zhangsf.javabase.thread.order;
    
    
    
    import java.util.concurrent.ExecutorService;
    
    import java.util.concurrent.Executors;
    
    
    
    /**
    
     * @author zhangsf
    
     * 通过SingleThreadExecutor让线程按顺序执行
    
     */
    
    public class ThreadPoolDemo {
    
    
    
        static ExecutorService executorService = Executors.newSingleThreadExecutor();
    
    
    
        public static void main(String[] args) throws Exception {
    
    
    
            final Thread thread1 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    System.out.println("产品经理规划新需求");
    
                }
    
            });
    
    
    
            final Thread thread2 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    System.out.println("开发人员开发新需求功能");
    
                }
    
            });
    
    
    
            Thread thread3 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    System.out.println("测试人员测试新功能");
    
                }
    
            });
    
    
    
            System.out.println("早上:");
    
            System.out.println("产品经理来上班了");
    
            System.out.println("测试人员来上班了");
    
            System.out.println("开发人员来上班了");
    
            System.out.println("领导吩咐:");
    
            System.out.println("首先,产品经理规划新需求...");
    
            executorService.submit(thread1);
    
            System.out.println("然后,开发人员开发新需求功能...");
    
            executorService.submit(thread2);
    
            System.out.println("最后,测试人员测试新功能...");
    
            executorService.submit(thread3);
    
            executorService.shutdown();
    
        }
    
    }

    运行结果

    早上:

    产品经理来上班了

    测试人员来上班了

    开发人员来上班了

    领导吩咐:

    首先,产品经理规划新需求…

    然后,开发人员开发新需求功能…

    最后,测试人员测试新功能…

    产品经理规划新需求

    开发人员开发新需求功能

    测试人员测试新功能

     5 

    使用线程的 Condition(条件变量) 方法

    Condition(条件变量):通常与一个锁关联。需要在多个Contidion中共享一个锁时,可以传递一个Lock/RLock实例给构造方法,否则它将自己生成一个RLock实例。

    • Condition中await()方法类似于Object类中的wait()方法。

    • Condition中await(long time,TimeUnit unit)方法类似于Object类中的wait(long time)方法。

    • Condition中signal()方法类似于Object类中的notify()方法。

    • Condition中signalAll()方法类似于Object类中的notifyAll()方法。

    应用场景:Condition是一个多线程间协调通信的工具类,使得某个,或者某些线程一起等待某个条件(Condition),只有当该条件具备( signal 或者 signalAll方法被调用)时 ,这些等待线程才会被唤醒,从而重新争夺锁。

    package com.zhangsf.javabase.thread.order;
    
    
    
    import java.util.concurrent.locks.Condition;
    
    import java.util.concurrent.locks.Lock;
    
    import java.util.concurrent.locks.ReentrantLock;
    
    
    
    /**
    
     * @author zhangsf
    
     * 使用Condition(条件变量)实现线程按顺序运行
    
     */
    
    public class ThreadConditionDemo {
    
    
    
        private static Lock lock = new ReentrantLock();
    
        private static Condition condition1 = lock.newCondition();
    
        private static Condition condition2 = lock.newCondition();
    
    
    
        /**
    
         * 为什么要加这两个标识状态?
    
         * 如果没有状态标识,当t1已经运行完了t2才运行,t2在等待t1唤醒导致t2永远处于等待状态
    
         */
    
        private static Boolean t1Run = false;
    
        private static Boolean t2Run = false;
    
    
    
        public static void main(String[] args) {
    
    
    
            final Thread thread1 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    lock.lock();
    
                    System.out.println("产品经理规划新需求");
    
                    t1Run = true;
    
                    condition1.signal();
    
                    lock.unlock();
    
                }
    
            });
    
    
    
            final Thread thread2 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    lock.lock();
    
                    try {
    
                        if(!t1Run){
    
                            System.out.println("开发人员先休息会...");
    
                            condition1.await();
    
                        }
    
                        System.out.println("开发人员开发新需求功能");
    
                        t2Run = true;
    
                        condition2.signal();
    
                    } catch (InterruptedException e) {
    
                        e.printStackTrace();
    
                    }
    
                    lock.unlock();
    
                }
    
            });
    
    
    
            Thread thread3 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    lock.lock();
    
                    try {
    
                        if(!t2Run){
    
                            System.out.println("测试人员先休息会...");
    
                            condition2.await();
    
                        }
    
                        System.out.println("测试人员测试新功能");
    
                        lock.unlock();
    
                    } catch (InterruptedException e) {
    
                        e.printStackTrace();
    
                    }
    
                }
    
            });
    
    
    
            System.out.println("早上:");
    
            System.out.println("测试人员来上班了...");
    
            thread3.start();
    
            System.out.println("产品经理来上班了...");
    
            thread1.start();
    
            System.out.println("开发人员来上班了...");
    
            thread2.start();
    
        }
    
    }

    运行结果:这里输出会有很多种顺序,主要是因为线程进入的顺序,造成锁住线程的顺序不一致

    早上:

    测试人员来上班了…

    产品经理来上班了…

    开发人员来上班了…

    测试人员先休息会…

    产品经理规划新需求

    开发人员开发新需求功能

    测试人员测试新功能

     6 

    使用线程的 CuDownLatch(倒计数) 方法

    CountDownLatch:位于java.util.concurrent包下,利用它可以实现类似计数器的功能。

    应用场景:比如有一个任务C,它要等待其他任务A,B执行完毕之后才能执行,此时就可以利用CountDownLatch来实现这种功能了。

    package com.zhangsf.javabase.thread.order;
    
    
    
    import java.util.concurrent.CountDownLatch;
    
    
    
    /**
    
     * @author zhangsf
    
     * 通过CountDownLatch(倒计数)使线程按顺序执行
    
     */
    
    public class ThreadCountDownLatchDemo {
    
    
    
        /**
    
         * 用于判断线程一是否执行,倒计时设置为1,执行后减1
    
         */
    
        private static CountDownLatch c1 = new CountDownLatch(1);
    
    
    
        /**
    
         * 用于判断线程二是否执行,倒计时设置为1,执行后减1
    
         */
    
        private static CountDownLatch c2 = new CountDownLatch(1);
    
    
    
        public static void main(String[] args) {
    
            final Thread thread1 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    System.out.println("产品经理规划新需求");
    
                    //对c1倒计时-1
    
                    c1.countDown();
    
                }
    
            });
    
    
    
            final Thread thread2 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    try {
    
                        //等待c1倒计时,计时为0则往下运行
    
                        c1.await();
    
                        System.out.println("开发人员开发新需求功能");
    
                        //对c2倒计时-1
    
                        c2.countDown();
    
                    } catch (InterruptedException e) {
    
                        e.printStackTrace();
    
                    }
    
                }
    
            });
    
    
    
            Thread thread3 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    try {
    
                        //等待c2倒计时,计时为0则往下运行
    
                        c2.await();
    
                        System.out.println("测试人员测试新功能");
    
                    } catch (InterruptedException e) {
    
                        e.printStackTrace();
    
                    }
    
                }
    
            });
    
    
    
            System.out.println("早上:");
    
            System.out.println("测试人员来上班了...");
    
            thread3.start();
    
            System.out.println("产品经理来上班了...");
    
            thread1.start();
    
            System.out.println("开发人员来上班了...");
    
            thread2.start();
    
        }
    
    }

    运行结果

    早上:

    测试人员来上班了…

    产品经理来上班了…

    开发人员来上班了…

    产品经理规划新需求

    开发人员开发新需求功能

    测试人员测试新功能

     7 

    使用 CyclicBarrier (回环栅栏)实现线程按顺序执行

     

    CyclicBarrier(回环栅栏):通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后,CyclicBarrier可以被重用。我们暂且把这个状态就叫做barrier,当调用await()方法之后,线程就处于barrier了。

    应用场景:公司组织春游,等待所有的员工到达集合地点才能出发,每个人到达后进入barrier状态。都到达后,唤起大家一起出发去旅行。

    package com.zhangsf.javabase.thread.order;
    
    
    
    import java.util.concurrent.BrokenBarrierException;
    
    import java.util.concurrent.CyclicBarrier;
    
    
    
    /**
    
     * @author zhangsf
    
     * 使用CyclicBarrier(回环栅栏)实现线程按顺序运行
    
     */
    
    public class CyclicBarrierDemo {
    
    
    
        static CyclicBarrier barrier1 = new CyclicBarrier(2);
    
        static CyclicBarrier barrier2 = new CyclicBarrier(2);
    
    
    
        public static void main(String[] args) {
    
    
    
            final Thread thread1 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    try {
    
                        System.out.println("产品经理规划新需求");
    
                        //放开栅栏1
    
                        barrier1.await();
    
                    } catch (InterruptedException e) {
    
                        e.printStackTrace();
    
                    } catch (BrokenBarrierException e) {
    
                        e.printStackTrace();
    
                    }
    
                }
    
            });
    
    
    
            final Thread thread2 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    try {
    
                        //放开栅栏1
    
                        barrier1.await();
    
                        System.out.println("开发人员开发新需求功能");
    
                        //放开栅栏2
    
                        barrier2.await();
    
                    } catch (InterruptedException e) {
    
                        e.printStackTrace();
    
                    } catch (BrokenBarrierException e) {
    
                        e.printStackTrace();
    
                    }
    
                }
    
            });
    
    
    
            final Thread thread3 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    try {
    
                        //放开栅栏2
    
                        barrier2.await();
    
                        System.out.println("测试人员测试新功能");
    
                    } catch (InterruptedException e) {
    
                        e.printStackTrace();
    
                    } catch (BrokenBarrierException e) {
    
                        e.printStackTrace();
    
                    }
    
                }
    
            });
    
    
    
            System.out.println("早上:");
    
            System.out.println("测试人员来上班了...");
    
            thread3.start();
    
            System.out.println("产品经理来上班了...");
    
            thread1.start();
    
            System.out.println("开发人员来上班了...");
    
            thread2.start();
    
        }
    
    }

    运行结果

    早上:

    测试人员来上班了…

    产品经理来上班了…

    开发人员来上班了…

    产品经理规划新需求

    开发人员开发新需求功能

    测试人员测试新功能

     8 

    使用线程的 Sephmore(信号量) 实现线程按顺序执行

    Sephmore(信号量):Semaphore是一个计数信号量,从概念上将,Semaphore包含一组许可证,如果有需要的话,每个acquire()方法都会阻塞,直到获取一个可用的许可证,每个release()方法都会释放持有许可证的线程,并且归还Semaphore一个可用的许可证。然而,实际上并没有真实的许可证对象供线程使用,Semaphore只是对可用的数量进行管理维护。

    acquire():当前线程尝试去阻塞的获取1个许可证,此过程是阻塞的,当前线程获取了1个可用的许可证,则会停止等待,继续执行。

    release():当前线程释放1个可用的许可证。

    应用场景:Semaphore可以用来做流量分流,特别是对公共资源有限的场景,比如数据库连接。假设有这个的需求,读取几万个文件的数据到数据库中,由于文件读取是IO密集型任务,可以启动几十个线程并发读取,但是数据库连接数只有10个,这时就必须控制最多只有10个线程能够拿到数据库连接进行操作。这个时候,就可以使用Semaphore做流量控制。

    package com.zhangsf.javabase.thread.order;
    
    
    
    import java.util.concurrent.Semaphore;
    
    /**
    
     * @author zhangsf
    
     * 使用Sephmore(信号量)实现线程按顺序运行
    
     */
    
    public class SemaphoreDemo {
    
        private static Semaphore semaphore1 = new Semaphore(1);
    
        private static Semaphore semaphore2 = new Semaphore(1);
    
        public static void main(String[] args) {
    
            final Thread thread1 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    System.out.println("产品经理规划新需求");
    
                    semaphore1.release();
    
                }
    
            });
    
    
    
            final Thread thread2 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    try {
    
                        semaphore1.acquire();
    
                        System.out.println("开发人员开发新需求功能");
    
                        semaphore2.release();
    
                    } catch (InterruptedException e) {
    
                        e.printStackTrace();
    
                    }
    
                }
    
            });
    
    
    
            Thread thread3 = new Thread(new Runnable() {
    
                @Override
    
                public void run() {
    
                    try {
    
                        semaphore2.acquire();
    
                        thread2.join();
    
                        semaphore2.release();
    
                        System.out.println("测试人员测试新功能");
    
                    } catch (InterruptedException e) {
    
                        e.printStackTrace();
    
                    }
    
                }
    
            });
    
    
    
            System.out.println("早上:");
    
            System.out.println("测试人员来上班了...");
    
            thread3.start();
    
            System.out.println("产品经理来上班了...");
    
            thread1.start();
    
            System.out.println("开发人员来上班了...");
    
            thread2.start();
    
        }
    
    }

    运行结果

    早上:

    测试人员来上班了…

    产品经理来上班了…

    开发人员来上班了…

    产品经理规划新需求

    开发人员开发新需求功能

    测试人员测试新功能


    三、总结

    代码拷贝均可运行

    使用的场景还有很多,根据开发需求场景,选择合适的方法,秒杀提问者!

    展开全文
  • 多线程有很好的并发性即无序性,在某些特殊情况下需要用到多线程然而又要使其具备顺序性,这种时候就有了一个特殊的场景那就是多线程顺序执行,在现在VS2015中Task自带了顺序执行的方法,但在此之前的旧项目中如果...
  • Java多线程顺序执行

    千次阅读 2019-02-26 19:26:23
    此方法实现java多线程顺序执行,依赖的是LinkedList < Runnable > ,链表里的元素是有序的,先放进去的先出来,所以最先进去的CreateTaskByThread最先出来. 其次consumptionThread 线程...

    方法实现java多线程顺序执行,依赖的是LinkedList < Runnable > ,因为链表里的元素是有序的,先放进去的先出来,所以最先进去的CreateTaskByThread最先出来. 其次consumptionThread 线程监听tasks里面放进去的任务,类似于消费者,如果有任务的话会立即执行,消费掉tasks里面的任务;productionThread 线程负责向LinkedList 链表里增加任务(每隔2s增加一个任务),这样呢就简单模仿了一个多线程顺序执行的一个案例

    import java.util.LinkedList;
    
    public class MultithreadedOrder {
    
        //链表
        private volatile static LinkedList<Runnable> tasks = new LinkedList<Runnable>();
    
        public static void main(String[] args){
            //开始执行,输出,现在链表里插入10个 runnable 执行
            System.out.println("start");
            for (int i = 0; i < 10; i++) {
                excuteTime();
            }
            System.out.println("end");
    
            //消费者  执行链表里的任务,消耗链表里的任务
            Thread consumptionThread = new Thread(){
                @Override
                public void run(){
                    while(true){
                        try {
                            Thread.sleep(1);
                        } catch (InterruptedException e) {
    
                        }
                        if (!tasks.isEmpty()) {
                            final Runnable task;
                            synchronized (tasks) {
                                task = tasks.getFirst();
                            }
                            try {
                                System.out.println("LinkedList-tasks size:"+tasks.size());
                                task.run();
                            } catch (Exception ex) {
                                //throw ex;
                                System.out.println(ex);
                            } finally {
                                synchronized (tasks) {
                                    tasks.removeFirst();
                                }
                            }
                        }
    
                    }
                }
    
            };
            consumptionThread.start();
    
            //生产者 负责向链表里面添加 runnable
            Thread productionThread = new Thread() {
                @Override
                public void run() {
                    while(true) {
                        try {
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        CreateTaskByThread createTaskByThread = new CreateTaskByThread();
                        tasks.add(createTaskByThread);
                    }
                }
            };
            productionThread.start();
        }
    
        public static void excuteTime(){
            CreateTaskByThread createTaskByThread = new CreateTaskByThread();
            tasks.add(createTaskByThread);
        }
    
    }
    
    class CreateTaskByThread implements Runnable{
        private static  int i = 0;
        @Override
        public void run() {
            System.out.println("best_"+ i++);
        }
    }
    
    展开全文
  • java中如何保证多线程顺序执行

    千次阅读 2019-07-30 17:59:47
    如何保证多线程顺序执行 代码: public class ThreadDemo { static Thread threadA = new Thread(()->{ System.out.println("线程A"); }); ​ static Thread threadB = new Thread(()->{ System.out....

    如何保证多线程顺序执行

    代码:

    public class ThreadDemo {
     static Thread threadA = new Thread(()->{
     System.out.println("线程A");
     });
    ​
     static Thread threadB = new Thread(()->{
     System.out.println("线程B");
     });
     
     static Thread threadC = new Thread(() -> {
     System.out.println("线程C");
     });
     public static void main(String[] args){
     threadA.start();
     threadB.start();
     threadC.start();
     }
     }
     输出结果:
     线程A
     线程C
     线程B
     输出结果每次不确定
    

    解决方案一

    1、join方法

    public class ThreadDemo {
     static Thread threadA = new Thread(()->{
     System.out.println("线程A");
     });
    ​
     static Thread threadB = new Thread(()->{
     System.out.println("线程B");
     });
     
     static Thread threadC = new Thread(() -> {
     System.out.println("线程C");
     });
     public static void main(String[] args) throws InterruptedException {
     threadA.start();
     threadA.join();
     threadB.start();
     threadB.join();
     threadC.start();
     threadC.join();
     }
     }
     输出结果:
     线程A
     线程B
     线程C
    

    分析,join原理

    a.查看jdk文档,join作用是让主线程等待子线程执行完之后再执行

    java中如何保证多线程顺序执行

    jdk:join()定义

    b.查看源码

    join()的调用

    java中如何保证多线程顺序执行

     

    java中如何保证多线程顺序执行

     

    位于main Thread的main()中,所以这里当然就是阻塞main Thread了。所以threadA.join()调用后,main Thread会阻塞起来。

    2、Executors.newSingleThreadExecutor

    public class ThreadDemo {
     static Thread threadA = new Thread(()->{
     System.out.println("线程A");
     });
    ​
     static Thread threadB = new Thread(()->{
     System.out.println("线程B");
     });
    ​
     static Thread threadC = new Thread(() -> {
     System.out.println("线程C");
     });
     static ExecutorService executors = Executors.newSingleThreadExecutor();
     public static void main(String[] args) throws InterruptedException {
    ​
     executors.submit(threadA);
     executors.submit(threadB);
     executors.submit(threadC);
     executors.shutdown();
     }
    }
    结果:
    线程A
    线程B
    线程C
    ​
    

    分析:直接查看源代码

    java中如何保证多线程顺序执行

     

    java中如何保证多线程顺序执行

     

    采用FIFO方式,保证每次只运行一个线程

    最后分享一个我自己的后端技术群,群里自己收集了很多Java架构资料,大家可以进群即可免费领取,群号:680075317,也可以进群一起交流,比如遇到技术瓶颈、面试不过的,大家一些交流学习!

    展开全文
  • 面试题:如何让线程顺序执行

    万次阅读 2019-09-22 10:23:52
    本文使用了8种方法实现在多线程中让线程顺序运行的方法,涉及到多线程中许多常用的方法,不止为了知道如何让线程顺序运行,更是让读者对多线程的使用有更深刻的了解。使用的方法如下: [1] 使用线程的join方法 ...

    一、实现

    本文使用了8种方法实现在多线程中让线程按顺序运行的方法,涉及到多线程中许多常用的方法,不止为了知道如何让线程按顺序运行,更是让读者对多线程的使用有更深刻的了解。使用的方法如下:

    [1] 使用线程的join方法
    [2] 使用主线程的join方法
    [3] 使用线程的wait方法
    [4] 使用线程的线程池方法
    [5] 使用线程的Condition(条件变量)方法
    [6] 使用线程的CountDownLatch(倒计数)方法
    [7] 使用线程的CyclicBarrier(回环栅栏)方法
    [8] 使用线程的Semaphore(信号量)方法

     

    二、实现

    我们下面需要完成这样一个应用场景:

    1.早上;2.测试人员、产品经理、开发人员陆续的来公司上班;3.产品经理规划新需求;4.开发人员开发新需求功能;5.测试人员测试新功能。

    规划需求,开发需求新功能,测试新功能是一个有顺序的,我们把thread1看做产品经理,thread2看做开发人员,thread3看做测试人员。

     1 

    使用线程的 join 方法

    join():是Theard的方法,作用是调用线程需等待该join()线程执行完成后,才能继续用下运行。

    应用场景:当一个线程必须等待另一个线程执行完毕才能执行时可以使用join方法。

    public class ThreadJoinDemo {
    
        public static void main(String[] args) {
            final Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("产品经理规划新需求");
                }
            });
    
            final Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        thread1.join();
                        System.out.println("开发人员开发新需求功能");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            Thread thread3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        thread2.join();
                        System.out.println("测试人员测试新功能");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            System.out.println("早上:");
            System.out.println("测试人员来上班了...");
            thread3.start();
            System.out.println("产品经理来上班了...");
            thread1.start();
            System.out.println("开发人员来上班了...");
            thread2.start();
        }
    }

    运行结果

    早上:
    测试人员来上班了…
    产品经理来上班了…
    开发人员来上班了…
    产品经理规划新需求
    开发人员开发新需求功能
    测试人员测试新功能

     2 

    使用主线程的 join 方法

    这里是在主线程中使用join()来实现对线程的阻塞。

    public class ThreadMainJoinDemo {
    
        public static void main(String[] args) throws Exception {
    
            final Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("产品经理正在规划新需求...");
                }
            });
    
            final Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("开发人员开发新需求功能");
                }
            });
    
            final Thread thread3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("测试人员测试新功能");
                }
            });
    
            System.out.println("早上:");
            System.out.println("产品经理来上班了");
            System.out.println("测试人员来上班了");
            System.out.println("开发人员来上班了");
            thread1.start();
            //在父进程调用子进程的join()方法后,父进程需要等待子进程运行完再继续运行。
            System.out.println("开发人员和测试人员休息会...");
            thread1.join();
            System.out.println("产品经理新需求规划完成!");
            thread2.start();
            System.out.println("测试人员休息会...");
            thread2.join();
            thread3.start();
        }
    }

    运行结果

    产品经理来上班了
    测试人员来上班了
    开发人员来上班了
    开发人员和测试人员休息会…
    产品经理正在规划新需求…
    产品经理新需求规划完成!
    测试人员休息会…
    开发人员开发新需求功能
    测试人员测试新功能

     3 

    使用线程的 wait 方法

    wait():是Object的方法,作用是让当前线程进入等待状态,同时,wait()也会让当前线程释放它所持有的锁。“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”,当前线程被唤醒(进入“就绪状态”)

    notify()和notifyAll():是Object的方法,作用则是唤醒当前对象上的等待线程;notify()是唤醒单个线程,而notifyAll()是唤醒所有的线程。

    wait(long timeout):让当前线程处于“等待(阻塞)状态”,“直到其他线程调用此对象的notify()方法或 notifyAll() 方法,或者超过指定的时间量”,当前线程被唤醒(进入“就绪状态”)。

    应用场景:Java实现生产者消费者的方式。

    public class ThreadWaitDemo {
    
        private static Object myLock1 = new Object();
        private static Object myLock2 = new Object();
    
        /**
         * 为什么要加这两个标识状态?
         * 如果没有状态标识,当t1已经运行完了t2才运行,t2在等待t1唤醒导致t2永远处于等待状态
         */
        private static Boolean t1Run = false;
        private static Boolean t2Run = false;
        public static void main(String[] args) {
    
            final Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (myLock1){
                        System.out.println("产品经理规划新需求...");
                        t1Run = true;
                        myLock1.notify();
                    }
                }
            });
    
            final Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (myLock1){
                        try {
                            if(!t1Run){
                                System.out.println("开发人员先休息会...");
                                myLock1.wait();
                            }
                            synchronized (myLock2){
                                System.out.println("开发人员开发新需求功能");
                                myLock2.notify();
                            }
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
    
            Thread thread3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (myLock2){
                        try {
                            if(!t2Run){
                                System.out.println("测试人员先休息会...");
                                myLock2.wait();
                            }
                            System.out.println("测试人员测试新功能");
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
    
            System.out.println("早上:");
            System.out.println("测试人员来上班了...");
            thread3.start();
            System.out.println("产品经理来上班了...");
            thread1.start();
            System.out.println("开发人员来上班了...");
            thread2.start();
        }
    }

    运行结果:这里输出会有很多种顺序,主要是因为线程进入的顺序,造成锁住线程的顺序不一致。

    早上:
    测试人员来上班了…
    产品经理来上班了…
    开发人员来上班了…
    测试人员先休息会…
    产品经理规划新需求…
    开发人员开发新需求功能
    测试人员测试新功能

     4 

    使用线程的线程池方法

    JAVA通过Executors提供了四种线程池

    • 单线程化线程池(newSingleThreadExecutor);

    • 可控最大并发数线程池(newFixedThreadPool);

    • 可回收缓存线程池(newCachedThreadPool);

    • 支持定时与周期性任务的线程池(newScheduledThreadPool)。

    单线程化线程池(newSingleThreadExecutor):优点,串行执行所有任务。

    submit():提交任务。

    shutdown():方法用来关闭线程池,拒绝新任务。

    应用场景:串行执行所有任务。如果这个唯一的线程因为异常结束,那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

    public class ThreadPoolDemo {
    
        static ExecutorService executorService = Executors.newSingleThreadExecutor();
    
        public static void main(String[] args) throws Exception {
    
            final Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("产品经理规划新需求");
                }
            });
    
            final Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("开发人员开发新需求功能");
                }
            });
    
            Thread thread3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("测试人员测试新功能");
                }
            });
    
            System.out.println("早上:");
            System.out.println("产品经理来上班了");
            System.out.println("测试人员来上班了");
            System.out.println("开发人员来上班了");
            System.out.println("领导吩咐:");
            System.out.println("首先,产品经理规划新需求...");
            executorService.submit(thread1);
            System.out.println("然后,开发人员开发新需求功能...");
            executorService.submit(thread2);
            System.out.println("最后,测试人员测试新功能...");
            executorService.submit(thread3);
            executorService.shutdown();
        }
    }

    运行结果

    早上:
    产品经理来上班了
    测试人员来上班了
    开发人员来上班了
    领导吩咐:
    首先,产品经理规划新需求…
    然后,开发人员开发新需求功能…
    最后,测试人员测试新功能…
    产品经理规划新需求
    开发人员开发新需求功能
    测试人员测试新功能

     5 

    使用线程的 Condition(条件变量) 方法

    Condition(条件变量):通常与一个锁关联。需要在多个Contidion中共享一个锁时,可以传递一个Lock/RLock实例给构造方法,否则它将自己生成一个RLock实例。

    • Condition中await()方法类似于Object类中的wait()方法。

    • Condition中await(long time,TimeUnit unit)方法类似于Object类中的wait(long time)方法。

    • Condition中signal()方法类似于Object类中的notify()方法。

    • Condition中signalAll()方法类似于Object类中的notifyAll()方法。

    应用场景:Condition是一个多线程间协调通信的工具类,使得某个,或者某些线程一起等待某个条件(Condition),只有当该条件具备( signal 或者 signalAll方法被调用)时 ,这些等待线程才会被唤醒,从而重新争夺锁。

    public class ThreadConditionDemo {
    
        private static Lock lock = new ReentrantLock();
        private static Condition condition1 = lock.newCondition();
        private static Condition condition2 = lock.newCondition();
    
        /**
         * 为什么要加这两个标识状态?
         * 如果没有状态标识,当t1已经运行完了t2才运行,t2在等待t1唤醒导致t2永远处于等待状态
         */
        private static Boolean t1Run = false;
        private static Boolean t2Run = false;
    
        public static void main(String[] args) {
    
            final Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    lock.lock();
                    System.out.println("产品经理规划新需求");
                    t1Run = true;
                    condition1.signal();
                    lock.unlock();
                }
            });
    
            final Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    lock.lock();
                    try {
                        if(!t1Run){
                            System.out.println("开发人员先休息会...");
                            condition1.await();
                        }
                        System.out.println("开发人员开发新需求功能");
                        t2Run = true;
                        condition2.signal();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    lock.unlock();
                }
            });
    
            Thread thread3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    lock.lock();
                    try {
                        if(!t2Run){
                            System.out.println("测试人员先休息会...");
                            condition2.await();
                        }
                        System.out.println("测试人员测试新功能");
                        lock.unlock();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            System.out.println("早上:");
            System.out.println("测试人员来上班了...");
            thread3.start();
            System.out.println("产品经理来上班了...");
            thread1.start();
            System.out.println("开发人员来上班了...");
            thread2.start();
        }
    }

    运行结果:这里输出会有很多种顺序,主要是因为线程进入的顺序,造成锁住线程的顺序不一致

    早上:
    测试人员来上班了…
    产品经理来上班了…
    开发人员来上班了…
    测试人员先休息会…
    产品经理规划新需求
    开发人员开发新需求功能
    测试人员测试新功能

     6 

    使用线程的 CuDownLatch(倒计数) 方法

    CountDownLatch:位于java.util.concurrent包下,利用它可以实现类似计数器的功能。

    应用场景:比如有一个任务C,它要等待其他任务A,B执行完毕之后才能执行,此时就可以利用CountDownLatch来实现这种功能了。

    public class ThreadCountDownLatchDemo {
    
        /**
         * 用于判断线程一是否执行,倒计时设置为1,执行后减1
         */
        private static CountDownLatch c1 = new CountDownLatch(1);
    
        /**
         * 用于判断线程二是否执行,倒计时设置为1,执行后减1
         */
        private static CountDownLatch c2 = new CountDownLatch(1);
    
        public static void main(String[] args) {
            final Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("产品经理规划新需求");
                    //对c1倒计时-1
                    c1.countDown();
                }
            });
    
            final Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        //等待c1倒计时,计时为0则往下运行
                        c1.await();
                        System.out.println("开发人员开发新需求功能");
                        //对c2倒计时-1
                        c2.countDown();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            Thread thread3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        //等待c2倒计时,计时为0则往下运行
                        c2.await();
                        System.out.println("测试人员测试新功能");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            System.out.println("早上:");
            System.out.println("测试人员来上班了...");
            thread3.start();
            System.out.println("产品经理来上班了...");
            thread1.start();
            System.out.println("开发人员来上班了...");
            thread2.start();
        }
    }

    运行结果

    早上:
    测试人员来上班了…
    产品经理来上班了…
    开发人员来上班了…
    产品经理规划新需求
    开发人员开发新需求功能
    测试人员测试新功能

     7 

    使用 CyclicBarrier (回环栅栏)实现线程按顺序执行

     

    CyclicBarrier(回环栅栏):通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后,CyclicBarrier可以被重用。我们暂且把这个状态就叫做barrier,当调用await()方法之后,线程就处于barrier了。

    应用场景:公司组织春游,等待所有的员工到达集合地点才能出发,每个人到达后进入barrier状态。都到达后,唤起大家一起出发去旅行。

    public class CyclicBarrierDemo {
    
        static CyclicBarrier barrier1 = new CyclicBarrier(2);
        static CyclicBarrier barrier2 = new CyclicBarrier(2);
    
        public static void main(String[] args) {
    
            final Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("产品经理规划新需求");
                        //放开栅栏1
                        barrier1.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            final Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        //放开栅栏1
                        barrier1.await();
                        System.out.println("开发人员开发新需求功能");
                        //放开栅栏2
                        barrier2.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            final Thread thread3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        //放开栅栏2
                        barrier2.await();
                        System.out.println("测试人员测试新功能");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            System.out.println("早上:");
            System.out.println("测试人员来上班了...");
            thread3.start();
            System.out.println("产品经理来上班了...");
            thread1.start();
            System.out.println("开发人员来上班了...");
            thread2.start();
        }
    }

    运行结果

    早上:
    测试人员来上班了…
    产品经理来上班了…
    开发人员来上班了…
    产品经理规划新需求
    开发人员开发新需求功能
    测试人员测试新功能

     8 

    使用线程的 Sephmore(信号量) 实现线程按顺序执行

    Sephmore(信号量):Semaphore是一个计数信号量,从概念上将,Semaphore包含一组许可证,如果有需要的话,每个acquire()方法都会阻塞,直到获取一个可用的许可证,每个release()方法都会释放持有许可证的线程,并且归还Semaphore一个可用的许可证。然而,实际上并没有真实的许可证对象供线程使用,Semaphore只是对可用的数量进行管理维护。

    acquire():当前线程尝试去阻塞的获取1个许可证,此过程是阻塞的,当前线程获取了1个可用的许可证,则会停止等待,继续执行。

    release():当前线程释放1个可用的许可证。

    应用场景:Semaphore可以用来做流量分流,特别是对公共资源有限的场景,比如数据库连接。假设有这个的需求,读取几万个文件的数据到数据库中,由于文件读取是IO密集型任务,可以启动几十个线程并发读取,但是数据库连接数只有10个,这时就必须控制最多只有10个线程能够拿到数据库连接进行操作。这个时候,就可以使用Semaphore做流量控制。

    public class SemaphoreDemo {
        private static Semaphore semaphore1 = new Semaphore(1);
        private static Semaphore semaphore2 = new Semaphore(1);
        public static void main(String[] args) {
            final Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("产品经理规划新需求");
                    semaphore1.release();
                }
            });
    
            final Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        semaphore1.acquire();
                        System.out.println("开发人员开发新需求功能");
                        semaphore2.release();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            Thread thread3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        semaphore2.acquire();
                        thread2.join();
                        semaphore2.release();
                        System.out.println("测试人员测试新功能");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            System.out.println("早上:");
            System.out.println("测试人员来上班了...");
            thread3.start();
            System.out.println("产品经理来上班了...");
            thread1.start();
            System.out.println("开发人员来上班了...");
            thread2.start();
        }
    }

    运行结果

    早上:
    测试人员来上班了…
    产品经理来上班了…
    开发人员来上班了…
    产品经理规划新需求
    开发人员开发新需求功能
    测试人员测试新功能


    三、总结

    看完了这么多种方法,是不是对多线程有了更深入的了解呢?不妨自己试试吧(代码拷贝均可运行)

    使用的场景还有很多,根据开发需求场景,选择合适的方法,达到事半功倍的效果。

     

    展开全文
  • 如何确保三个线程顺序执行

    万次阅读 多人点赞 2018-07-03 09:42:00
    使用join thread.Join把指定的线程加入到当前线程,可以将两个交替执行的线程合并为顺序执行线程。比如在线程B中调用了线程A的Join()方法,直到线程A执行完毕后,才会继续执行线程B。t.join(); //调用join方法,...
  • JUC之线程顺序执行 方式一:使用Thread中的join() ​ join() 用于不断让当前线程等待join线程之行结束。其原理就是不停的检查join线程是否存活,如果join线程存活则让当前线程影院等待。其中源码中wait(0)表示永远...
  • java 多线程顺序执行

    千次阅读 2019-06-14 16:22:44
    这道阿里巴巴多线程面试题,你学会了没有? 置顶2019年06月14日 15:43:55XingXing_Java阅读数 447 点关注,不迷路;持续更新Java相关技术及资讯!...通过N个线程顺序循环打印从0至100,如给定N=3则输出: threa...
  • 1.有A、B、C、D四个线程,A线程输出A, B线程输出B, C线程输出C,D线程输出D,要求, 同时启动四个线程, 按顺序输出ABCD; 本题主要通过join方法来实现顺序输出ABCD。 代码如下: package thread; /** * @author ...
  • 以上代码实现了线程顺序执行 from threading import Thread import time from time import ctime,sleep def my_counter () : for i in range( 2 ): i+= 1 sleep( 1 ) return True...
  • 三个线程顺序执行

    千次阅读 2017-04-07 11:12:25
    面试遇到这样一个问题:如果你有三个线程,分别为T1,T2,T3,如何让线程T2在线程T1之后执行,在线程T3之前执行。 public class Test { public static void main(String[] args) throws InterruptedException { ...
  • 题目描述:如何保证多个线程顺序执行? join方式实现 join方式即使用Thread.join方法来实现。Thread.join含义当前线程需要等待previousThread线程终止之后才从thread.join返回。简单来说,就是线程没有执行完...
  • 问题:假设当前有四个线程,分别是A,B,C,D四个线程,假设现在设计一个程序,让A,B,C,D四个线程一次输出A,B,C,D,循环十次。 当时面试过程中稍微有点紧张,虽然是面试实习生的岗位,可怕的是居然面试了三轮技术面。...
  • 文章目录前言一、pa ? 一.synchronized的缺陷 二.Lock接口的特性 三.Lock接口基本的方法: 四、Lock接口的实现类:...使用Condition实现顺序执行 七、ReentrantReadWriteLock 八、公平锁与非公平锁 九、可重入锁
  • ABC三个线程顺序执行(简单实现)

    千次阅读 2019-06-29 18:05:57
    需求:3个线程 输出ABC ------...1、 使用线程池将所有线程放入一个队列 ,保证顺序输出 public class ThreeThread { public static void main(String[] args) throws InterruptedException { //用线程池来实...
  • java多线程顺序执行问题 使用join 假设我要让3个线程按照顺序打印ABC,那么可以使用Join,如果要求多线程按顺序循环打印,则不能用join了 join关键字 join是Thread类的一个方法,启动线程后直接调用。在很多情况下,...
  • 有的时候我们希望线程按照希望的顺序依次执行,比如线程A,B,C,按照顺序依次执行,这时候就要用到阻塞和唤醒,之前的时候我们学到过wait()和nofity/notifyAll()这两个方法,这里我们使用java.concurrent.locks....
  • 一 基本信息 首先,从Executor接口开始 查看注释 An object that executes ...一个执行“”提交的任务“”的对象 * This interface provides a way of decoupling task submission from the * mechanics of how ...
  • Android中让多个线程顺序执行探究

    千次阅读 2015-09-14 10:27:15
    所以,让多个线程顺序执行有三个确切的办法: 1、改变线程的优先级(不同的系统上可能并不会按照优先级来执行) 2、调用join()方法,一个线程在run中调用join()方法时,会阻塞当前线程,而让新加入的线程执行完...
  • c#线程顺序执行,并解决假死

    千次阅读 2017-12-26 22:29:22
    private void Do_Pro()  {  foreach (Thread t in LT_Current)  {  a_mutex = 1;  t.Start(LT_Current_Xprops);  //解决Join添加后窗体假

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 515,152
精华内容 206,060
关键字:

线程如何顺序执行