精华内容
下载资源
问答
  • 并发学习(四) — 多线程有序执行

    千次阅读 2018-05-21 23:58:46
    前言:在看了这些多线程的知识之后,突发奇想到怎么让多线程有序执行呢?第一种:用Thread.join()方法来确定该线程执行完毕第二种:用线程池的队列来执行任务第一种方法:join方法是阻塞的,会一定等到取消或者...

    前言:

    在看了这些多线程的知识之后,突发奇想到怎么让多线程有序执行呢?

    第一种:用Thread.join()方法来确定该线程执行完毕

    第二种:用线程池的队列来执行任务

    第三种:用公共锁Object,配合wait/notifyAll方法,睡眠自己,唤醒另一个线程~


    join方法:

    join方法是阻塞的,会一定等到取消或者超时为止,这样就可以按顺序来。

    @Slf4j
    public class JoinExample {
    
        public static void main(String[] args) throws InterruptedException{
    
            log.info("{} is start", Thread.currentThread().getName());
    
            Thread t0 = new Thread(() -> {
                try{
                    log.info( "{} is Start,sleep 6 second", Thread.currentThread().getName());
                    Thread.sleep(6000);
                    log.info("{} is Completed", Thread.currentThread().getName());
                }catch (InterruptedException e){
                    log.error("exception", e);
                }
            });
            t0.start();
            t0.join();
    
            Thread t1 = new Thread(() -> {
                try{
                    log.info( "{} is Start,sleep 2 second", Thread.currentThread().getName());
                    Thread.sleep(2000);
                    log.info( "{} is Completed", Thread.currentThread().getName());
                }catch (InterruptedException e){
                    log.error("exception", e);
                }
            });
            t1.start();
            t1.join();
    
            log.info("{} is Completed", Thread.currentThread().getName() );
        }
    }
    


    再来一个,

    @Slf4j
    public class JoinExample1 {
    
        public static void main(String[] args) {
            final Thread t1 = new Thread(() -> {
                log.info("{} is first", Thread.currentThread().getName());
            },"线程1");
    
            final Thread t2 = new Thread(() -> {
                try {
                    t1.join();
                    log.info("{} is second", Thread.currentThread().getName());
                }catch (InterruptedException e){
                    log.info("exception", e);
                }
            },"线程2");
    
            final Thread t3 = new Thread(() -> {
                try {
                    t2.join();
                    log.info("{} is third", Thread.currentThread().getName());
                }catch (InterruptedException e){
                    log.info("exception", e);
                }
            },"线程3");
            
            t2.start();
            t3.start();
            t1.start();
    //顺序sart是没有关系的
        }
    }

    线程池newSingleThreadExecutor:

    @Slf4j
    public class JoinExample2 {
    
        public static void main(String[] args) {
    
            final Thread t1 = new Thread(() -> {
                log.info("{}, the first 运行了!", Thread.currentThread().getName());
            },"线程1");
    
    
            final Thread t2 = new Thread(() -> {
                log.info("{}, the second 运行了!", Thread.currentThread().getName());
            }, "线程2");
    
            final Thread t3 = new Thread(() -> {
                log.info("{}, the third 运行了!", Thread.currentThread().getName());
            }, "线程3");
    
            ExecutorService exec = Executors.newSingleThreadExecutor();
            exec.submit(t1);
            exec.submit(t2);
            exec.submit(t3);
            exec.shutdown();
        }
    }
    

    由于线程池中只有一个,所以默认就它一个能运行的线程~~

    展开全文
  • 利用join方法,让线程有序执行

    千次阅读 2018-01-29 13:51:39
    和wait()有点类似,join()方法可以让线程之间排队等待,按照一定的顺序执行。join方法是阻塞的,会一直等到取消或超时为止。假如现在有三个线程,main,t0,t1,要在main线程启动之后相继执行t0,t1,那么可以在...

    和wait()有点类似,join()方法可以让多个线程之间排队等待,按照一定的顺序执行。join方法是阻塞的,会一直等到取消或超时为止。假如现在有三个线程,main,t0,t1,要在main线程启动之后相继执行t0,t1,那么可以在main线程之后,启动t0,t0加入执行队列,即t0.join(),之后再启动t1,t1.join()。

    
    public class JoinDemo {
    
          public static void main(String args[]) throws InterruptedException{
    
                System.out.println(Thread.currentThread().getName() + " is Started");
    
                Thread t0 = new Thread(){
                    public void run(){
                        try {
                            System.out.println(Thread.currentThread().getName() + " is Started,sleep 2 second");
                            Thread.sleep(2000);
                            System.out.println(Thread.currentThread().getName() + " is Completed");
                        } catch (InterruptedException ex) {
                        }
                    }
                };
    
                t0.start();
                t0.join();
    
    
                Thread t1 = new Thread(){
                    public void run(){
                        try {
                            System.out.println(Thread.currentThread().getName() + " is Started,sleep 6 second");
                            Thread.sleep(6000);
                            System.out.println(Thread.currentThread().getName() + " is Completed");
                        } catch (InterruptedException ex) {
                        }
                    }
                };
    
                t1.start();
                t1.join();
    
                System.out.println(Thread.currentThread().getName() + " is Completed");
            }
    
    }

    执行结果:

    main is Started
    Thread-0 is Started,sleep 2 second
    Thread-0 is Completed
    Thread-1 is Started,sleep 6 second
    Thread-1 is Completed
    main is Completed
    展开全文
  • python同步应用:线程有序执行

    千次阅读 2017-08-12 22:43:59
    可以使用互斥锁完成个任务,有序的进程工作,这就是线程的同步 from threading import Thread, Lock import time mutex1= Lock() # 创建一个互斥锁 mutex2= Lock() # 创建一个互斥锁 mutex3= Lock() # ...

    可以使用互斥锁完成多个任务,有序的进程工作,这就是线程的同步

    from threading import Thread, Lock

    import time

    mutex1= Lock()  # 创建一个互斥锁

    mutex2= Lock()  # 创建一个互斥锁

    mutex3= Lock()  # 创建一个互斥锁

     

     

    def fun1():

        while 1:

            mutex1.acquire()  # 阻塞

            print("线程1 执行")

            mutex2.release()   # 释放锁2,让线程2继续执行

            time.sleep(0.1)

     

     

    def fun2():

        while 1:

            mutex2.acquire()  # 阻塞

            print("线程2 执行")

            mutex3.release()   # 释放锁3,让线程3继续执行

            time.sleep(0.1)

     

     

    def fun3():

        while 1:

            mutex3.acquire()  # 阻塞

            print("线程3 执行")

            mutex1.release()   # 释放锁1,让线程1继续执行

            time.sleep(0.1)

     

    t1 =Thread(target=fun1)  # 创建一个线程对象

    t2 =Thread(target=fun2)  # 创建一个线程对象

    t3 =Thread(target=fun3)  # 创建一个线程对象

     

    mutex2.acquire()  # 将锁2设置为上锁,线程2不能运行

    mutex3.acquire()  # 将锁2设置为上锁,线程2不能运行

     

    t1.start()  # 开启线程的执行

    t2.start()

    t3.start()

     

    t1.join()  # 回收线程资源

    t2.join()

    t3.join()

    展开全文
  • 使得几个线程有序执行的两种方式

    千次阅读 2019-06-10 21:03:14
    thread.Join把指定的线程加入到当前线程,可以将两个交替执行线程合并为顺序执行线程。比如在线程B中调用了线程A的Join()方法,直到线程A执行完毕后,才会继续执行线程B public class ThreadTest1 { public ...

    1、使用Thread.join()方法

    thread.Join把指定的线程加入到当前线程,可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法,直到线程A执行完毕后,才会继续执行线程B

    public class ThreadTest1 {
        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.setName("第一个");
            t2.setName("第二个");
            t3.setName("第三个");
            t1.start();
            t2.start();
            t3.start();
        }
        static class Work implements Runnable {
            private Thread thread;
            public Work(Thread thread) {
                this.thread = thread;
            }
            @Override
            public void run() {
                if (thread != null) {
                    try {
                        thread.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    execute();
                } else {
                    execute();
                }
            }
            private void execute() {
                System.out.println("线程" + Thread.currentThread().getName() + "执行");
            }
        }
    }
    

    执行结果:

    线程第一个执行
    线程第二个执行
    线程第三个执行
    
    Process finished with exit code 0
    

    2、使用线程池使用一个固定大小的线程池

    public class ThreadTest2 {
        private static ExecutorService es = Executors.newFixedThreadPool(1);
        public static void main(String[] args) {
            Work t1 = new Work("t1");
            Work t2 = new Work("t2");
            Work t3 = new Work("t3");
            es.submit(t1);
            es.submit(t2);
            es.submit(t3);
        }
        static class Work implements Runnable {
            private String key;
            public Work(String key) {
                this.key = key;
            }
            @Override
            public void run() {
                execute();
            }
            private void execute() {
                try {
                    TimeUnit.MILLISECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程:" + Thread.currentThread().getName() + "执行" + key);
            }
        }
    }
    
    

    执行结果:

    线程:pool-1-thread-1执行t1
    线程:pool-1-thread-1执行t2
    线程:pool-1-thread-1执行t3
    
    Process finished with exit code 0
    

    注意:

    线程池shutdown方法和shutdownNow有区别,shutdown要等所有线程执行完后再关闭,shutdownNow将线程池内正在执行的线程强制停掉。

    展开全文
  • 线程A调用B线程join()方法后,线程A将会阻塞,只有等B线程执行完后在会执行线程A public class ThreadMain { public static void main(String[] args) throws Exception { Thread myThread1 = new Threa...
  • 在使用多线程时,简单的IO操作有时满足不了我们的需求,我们需要有序的接收返回值,例如:调用第三方API 我这个栗子是调用TTS的在线合成API,先看一下结果吧: 左侧:正常的顺序执行,共进行了4次调用,最后的总...
  • Java多线程顺序执行

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

    千次阅读 2018-11-01 14:30:58
    控制多线程执行顺序 示例代码的码云地址:https://gitee.com/suwenguang/test/blob/master/fuxi/src/main/java/多线程/控制多线程的顺序执行/App.java 多线程是为了同步完成多项任务,不是为了提高运行效率,而是...
  • Java多线程实现有序输出ABC

    千次阅读 2018-08-31 17:59:10
    看到这个题目,感觉很有意思,问题的本质是在多线程执行环境,控制线程的执行顺序,实现的方式有非常多种,本质上需要解决Java多线程环境下的线程执行的同步和利用锁机制来控制线程的执行顺序。 方式1:利用...
  • java 多线程顺序执行

    千次阅读 2019-06-14 16:22:44
    这道阿里巴巴多线程面试题,你学会了没有? 置顶2019年06月14日 15:43:55XingXing_Java阅读数 447 点关注,不迷路;持续更新Java相关技术及资讯!!! 前言 有个朋友问了我一道面试阿里的时候遇到的多线程...
  • 多线程并行执行与顺序执行(一)

    千次阅读 2018-11-05 18:28:36
    package test; import java.util.Vector; import java.util.concurrent.ExecutorService; import java.util.concurrent.... * 通过 join()方法并行执行线程。 * @author Smile */ public class ThreadJoinTest ...
  • Java多线程有序性(一)

    千次阅读 2018-05-18 15:08:09
    其实细想一下,多线程和单线程相比,出现问题不就是内存里面的值可能与预期值(单线程运行/串行运行)之间不一致嘛。所以一定至少要知道读写操作是怎么操作内存的!! 2.Java程序的运行顺序: 程序...
  • 如何保证多线程的顺序执行

    千次阅读 2019-03-20 21:39:46
    多线程情况下由于会有CPU在不同线程之间的来回切换,各个线程的执行结果会产生交叉 。 举个例子:现有T1、T2、T3、主线程四个线程,如何安照T1执行完才执行T2、T2执行完才执行T3、T3执行完最后执行主线程才结束? ...
  • Java多线程有序性(二)

    千次阅读 2018-05-18 15:16:36
    有序性:指在什么情况下一个处理器上运行的一个线程执行的内存访问在另一处理器运行的另外一个线程看来是乱序的,乱序是指:内存访问的顺序看起来像是发生了变化。 我不随意揣测这个定义了,看不懂也没关系,我们...
  • 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....
  • 1.有A、B、C、D四个线程,A线程输出A, B线程输出B, C线程输出C,D线程输出D,要求, 同时启动四个线程, 按顺序输出ABCD; 本题主要通过join方法来实现顺序输出ABCD。 代码如下: package thread; /** * @author ...
  • 设定一个 orderNum,每个线程执行结束之后,更新 orderNum,指明下一个要执行线程。并且唤醒所有的等待线程。 在每一个线程的开始,要 while 判断 orderNum 是否等于自己的要求值!!不是,...
  • 有序性是指,同一线程中的指令应该按顺序执行,而多线程中的指令未必按顺序执行。 示例 在下面的演示代码中,我们做了这样的事情: 首先,定义一个全局的静态变量 singleton ,使用1000个线程对调用 getInstance()...
  • 在学习Java多线程的时候,其中很重要的部分就是线程同步,曾经有一个问题是开三个线程,每个线程打印一个字母,依次是ABC。现在我把这一类的需求都封装到一个有序线程类中,大家有兴趣的可以看看。源码...
  • 万字图解Java多线程

    万次阅读 多人点赞 2020-09-06 14:45:07
    java多线程我个人觉得是javaSe中最难的一部分,我以前也是感觉学会了,但是真正有多线程的需求却不知道怎么下手,实际上还是对多线程这块知识了解不深刻,不知道多线程api的应用场景,不知道多线程的运行流程等等,...
  • 多线程导致数据重复添加

    千次阅读 2019-02-14 16:00:57
    多线程有序执行的方法!! 1.测试用例 @Test public void testthread() throws InterruptedException { List<String> list = new ArrayList&...
  • 多线程并发执行的注意事项

    千次阅读 2014-05-29 22:18:54
    同步就是要解决进程和线程...比如多线程的同步,资源共享与争用,进程间通信等。 线程同步技术主要包含两个方面: 1、多个线程推进顺序的控制问题。 2、访问共享资源的问题。   线程间的同步与互斥: 1、
  • Java解决线程有序

    2019-03-25 14:32:23
    多数情况下,线程运行时线程之间执行任务的时机是无序的。下面将讲解怎么使线程具有有序性。 package test.t4.t_3; public class MyThread1 extends Thread { private Object lock; private String showChar...
  • 简单入门java多线程三:线程控制API

    万次阅读 2014-12-11 10:21:51
    4.1 Lock:同synchronize,用于实现同步,保证多线程有序执行 ReentrantLock():创建可重入锁对象 lock():获取锁对象,锁对象属于当前线程,如果被其他线程占用,则进入阻塞状态 unlock():释放锁对象,如果在...
  • Java多线程的可见性与有序

    千次阅读 2019-06-19 08:00:00
    多线程的可见性 一个线程对共享变量值的修改,能够及时的被其他线程看到。 共享变量 如果一个变量在多个线程的工作内存中都存在副本,那么这个变量就是这几个线程的共享变量。 Java内存模型 JMM(Java Memory ...
  • 多线程----有序

    千次阅读 2019-12-20 09:10:04
    多线程笔记(六):概念 所谓有序性,是指程序在执行过程中的先后顺序,由于Java在编译器以及运行期的优化,导致了代码的执行顺序未必就是开发者编写代码时的顺序。 实例 int x = 10; int y = 0; x++; y = 20; ...
  • 两个线程的任务都是打印1到1000的数据,要求线程1打印一次后线程2继续打印,实现轮流打印方法1:使用interrupt()和sleep()协调使用,一个打印完成后sleep(),并且interrupt另一个线程的睡眠,同时让自己睡眠,循环...
  • 原子性 原子性:即一个操作或者个操作 要么全部执行并且执行的过程不会被任何因素打断,要么就都不执行
  • 测试例子: package serializer.pattern; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; public class Main { ... volatile private static int nextPrintWho = ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 114,155
精华内容 45,662
关键字:

多线程有序执行