精华内容
下载资源
问答
  • (谨以此贴感谢boss直聘首席架构师李川的指导)这个例子是某架构师让我回来一定要理解体会试着做的一个例子,主要是避免对线程的纸上谈兵:先来段源码 /** * Creates an Executor that uses a single worker thread...

    (谨以此贴感谢boss直聘首席架构师李川的指导)

    这个例子是某架构师让我回来一定要理解体会试着做的一个例子,主要是避免对线程的纸上谈兵:

    先来段源码

     /**
         * Creates an Executor that uses a single worker thread operating
         * off an unbounded queue. (Note however that if this single
         * thread terminates due to a failure during execution prior to
         * shutdown, a new one will take its place if needed to execute
         * subsequent tasks.)  Tasks are guaranteed to execute
         * sequentially, and no more than one task will be active at any
         * given time. Unlike the otherwise equivalent
         * {@code newFixedThreadPool(1)} the returned executor is
         * guaranteed not to be reconfigurable to use additional threads.
         *
         * @return the newly created single-threaded Executor
         */
        public static ExecutorService newSingleThreadExecutor() {
            return new FinalizableDelegatedExecutorService
                (new ThreadPoolExecutor(1, 1,
                                        0L, TimeUnit.MILLISECONDS,
                                        new LinkedBlockingQueue<Runnable>()));
        }

       

    public class AbcThread {
        public static void main(String[] args) {
            final Thread t1 =new Thread(new Runnable() {
                @Override
                public void run() {
                 System.out.println(Thread.currentThread().getName()+"run 1");
                }
            },"T1");
            final  Thread t2=new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"run 1");
                    try{
                        t1.join(10);
                    }catch (InterruptedException e){
                        e.printStackTrace();
    
                    }
                }
            },"T2");
            final  Thread t3=new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"run 3");
                try{
                        t2.join(10);
                }catch (InterruptedException e){
                        e.printStackTrace();
    
                }
                }
            },"T3");
    
            ExecutorService executorService= Executors.newSingleThreadExecutor();
            executorService.submit(t1);
            executorService.submit(t2);
            executorService.submit(t3);
            executorService.shutdown();
    
        }
    }

    展开全文
  • 如何保证多线程顺序执行代码:public class ThreadDemo { static Thread threadA = new Thread(()->{ System.out.println("线程A"); });​ static Thread threadB = new Thread(()->{ System.out.println(...

    如何保证多线程顺序执行

    代码:

    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作用是让主线程等待子线程执行完之后再执行

    9d9a75fce93c3e5995167a96bc0f7002.png

    jdk:join()定义

    b.查看源码

    join()的调用

    4545b3fe49bae8f01aff2790f809045b.png
    d904ecb9924c2d7e7a149f22eceaaf3e.png

    位于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​

    分析:直接查看源代码

    61befb677d65b4062caec1c8b6125996.png
    f0bcb093d4c9e5fa1c67801c58c536ca.png

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

    展开全文
  • 其实这一个题有很解,面试官想听的可能是CountDownLatch这一种,因为面试官也只会这一种。。 参考了网络不过总体思路没错。 public class ThreadOderRun { public static void main(String[] args) { ...

    其实这一个题有很多解,面试官想听的可能是CountDownLatch这一种,因为面试官也只会这一种。。

    参考了网络不过总体思路没错。

    public class ThreadOderRun {
    
        public static void main(String[] args) {
            ThreadOderRun threadOderRun = new ThreadOderRun();
            CountDownLatch l1 = new CountDownLatch(0);
            CountDownLatch l2 = new CountDownLatch(1);
            CountDownLatch l3 = new CountDownLatch(1);
            Thread work1 = new Thread(threadOderRun.new Work(l1, l2, "1"));
            Thread work2 = new Thread(threadOderRun.new Work(l2, l3, "2"));
            Thread work3 = new Thread(threadOderRun.new Work(l3, l3, "3"));
            work1.start();
            work2.start();
            work3.start();
        }
    
    
        class Work implements Runnable {
            CountDownLatch c1;
            CountDownLatch c2;
            String msg;
    
            public Work(CountDownLatch c1, CountDownLatch c2, String msg) {
                this.c1 = c1;
                this.msg = msg;
                this.c2=c2;
            }
    
            public void run() {
                try {
                    c1.await();
                    System.out.println(msg);
                    c2.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
            }
        }
    }
    

    如果能多几种方式就更好了

    public class ThreadOrderRun2 {
    
        private AtomicInteger val = new AtomicInteger(1);
    
        public static void main(String[] args) {
            ThreadOrderRun2 threadOrderRun2 = new ThreadOrderRun2();
            Thread work1 = new Thread(threadOrderRun2.new Work("1", 1));
            Thread work2 = new Thread(threadOrderRun2.new Work("2", 2));
            Thread work3 = new Thread(threadOrderRun2.new Work("3", 3));
            work1.start();
            work2.start();
            work3.start();
        }
    
    
        class Work implements Runnable {
            private String msg;
            private int order;
    
            public Work(String msg, Integer order) {
                this.msg = msg;
                this.order = order;
            }
    
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(100);
                        if (val.get() == order) {
                            System.out.println(msg);
                            val.incrementAndGet();
                            break;
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
    
            }
        }
    }
    

    参见这个博客吧:https://blog.csdn.net/Evankaka/article/details/80800081

    展开全文
  • 如何保证多线程顺序执行

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

    多线程情况下由于会有CPU在不同线程之间的来回切换,各个线程的执行结果会产生交叉 。

    举个例子:现有T1、T2、T3、主线程四个线程,如何安照T1执行完才执行T2、T2执行完才执行T3、T3执行完最后执行主线程才结束?

    答案:使用join()方法,让其他线程等待。使用join的线程会独占执行资源,直到使用完毕,其它线程才能获取执行权。

    代码示例如下:  

    public class JoinDemo {
    
    	public static void main(String[] args) throws InterruptedException {
    		// 线程t1
    		Thread t1 = new Thread(new Runnable() {
    			public void run() {
    				for (int i = 0; i < 5; i++) {
    				    System.out.println("-----T1-----" + i);
    				}
    			}
    		},"t1");
    		t1.start();
    		// 使用join让其他线程等待,本线程执行完成后其它线程才能执行
    		t1.join();
    
    		// 线程t2
    		Thread t2 = new Thread(new Runnable() {
    			public void run() {
    				for (int i = 0; i < 5; i++) {
    				    System.out.println("-----T2-----" + i);
    				}
    			}
    		},"t2");
    		t2.start();
    		// 使用join让其他线程等待,本线程执行完成后其它线程才能执行
    		t2.join();
    
    		// 线程t3
    		Thread t3 = new Thread(new Runnable() {
    			public void run() {
    				for (int i = 0; i < 5; i++) {
    				    System.out.println("-----T3-----" + i);
    				}
    			}
    		},"t3");
    		t3.start();
    		// 使用join让其他线程等待,本线程执行完成后其它线程才能执行
    		t3.join();
    
    		System.out.println("-----main------");
    
    	}
    
    }

    执行结果截图:

    当然join()方法,也可以设置一个时间参数。

    例如:
     

    Thread t1 = new Thread();
    
    t1 .start(); 
    
    t1 .join(100) ;
    
    Thread t2 = new Thread();
    
    t2.start();

    表示经过100ms后,不管t1有没有执行完毕,t2都会获得执行权。

     

    展开全文
  • 如何保证多线程按一定顺序执行

    千次阅读 2019-05-13 14:32:19
    假设现在有三个线程t1、t2和t3 让t2在t1完成后执行,t3在t2完成后执行 自定义Thread类 public class Thread extends java.lang.Thread { private String str ; private int time; public Thread(String str,int ...
  • 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....
  • //使用join()让其他线程等待,等到当前线程执行完之后再去执行其他线程 A.join(); B.start(); B.join(); C.start(); C.join(); } @Override public void run() { System.out.print(Thread.currentThread()....
  • 1. java多线程环境中,如何保证多个线程按指定的顺序执行呢? 1.1 通过thread的join方法保证多线程顺序执行, wait是让主线程等待 比如一个main方法里面先后运行thread1,,thread2,thread3,那么thread1.start()...
  • 当多个线程执行任务时,可以通过Thread.join()方法保证多线程执行顺序,其内部是通过调用主线程的wait方法,使主线程等待;当子线程执行完成后,再唤醒主线程。 下面写一个简单的实例:创建ABCD四个线程,每个线程...
  • 通过join方法去保证多线程顺序性的特性 Join:让主线程等待子线程结束以后才能运行 ExecutorService executor=Excutors.newSingleThreadExecutor(); import java.util.concurrent.ExecutorService; import ...
  • 有三个线程T1,T2,T3,如何保证顺序执行? 在多线程中有多种方法让线程按特定顺序执行,你可以用线程类的join()方法在一个线程中启动另一个 线程,另外一个线程完成该线程继续执行。为了确保三个线程的顺序你应该先...
  • 比如在线程thread2中,加上一句thread1.join(),其意义在于,当前线程2运行到此行代码时会进入阻塞状态,直到线程thread1执行完毕后,线程thread2才会继续运行,这就保证线程thread1与线程thread2的运行顺序 ...
  • 面试的时候你是否经常被问到这样的问题:你一般...要想控制多线程顺序,你首先应该搞清楚线程和进程到底是什么东西?1、进程进程其实是操作系统的基础,是系统中一次程序的执行,也是一次程序和数据在机器上顺序...
  • 期望的执行顺序: 1.按下启动按钮后弹出box1并启动线程, 2.线程执行时弹出box2,并一直等待用户按确定按钮 3.用户按box2的确认按钮后,弹出box3 实际结果 消息响应函数一直等待用户按确定按钮,但线程继续执行...
  • 介绍先看如下代码:重复执行多次,发现输出并不是按照...方法1通过join方法去保证多线程顺序执行可以看到输出一直是如下thread1thread2thread3join是怎么实现这个功能的呢?join方法让主线程等待子线程结束以后才能...
  • 如何线程按照顺序执行

    千次阅读 2018-10-12 19:21:20
    因为不保证有序性,可能执行出来是混乱的 解决如下: 第一种使用join()方法,这个方法的作用是,让当前执行线程等待直到调用join方法的线程结束运行 代码如下: class Thread1 extends Thread{ public void ...
  • 1. 通过join方法去保证多线程顺序行的特性 join: 让主线程等待子线程结束以后才能继续运行 2.ExecutorService executorService = Executors.newSingleThreadExecutor(); //FIFO import java.util.concurrent...
  • 一:案例数据 (模拟多线程) public class ThreadTest { static Thread t1 = new Thread(new Runnable() { @Override public void run() { System.err.println("t1 执行"); } }); st...
  • 使用Join保证线程顺序执行 join的作用 Thread类中的join方法的主要作用就是同步,它可以使得线程之间的并行执行变为串行执行。当我们调用某个线程的这个方法时,这个方法会挂起调用线程,直到被调用线程结束执行,...
  • 1.为什么要保证顺序消息队列中的若干消息如果是对同一个数据进行操作,这些操作具有前后的关系,必须要按前后的顺序执行,否则就会造成数据异常。举例:比如通过mysql binlog进行两个数据库的数据同步,由于对数据库...
  • 在面试的时候是一定会被询问的话题,今天,在和朋友聊天的时候,他问了我一道很好玩的多线程面试题,不难,但是想解释清楚,还真的是不容易问题:现在有T1、T2、T3三个线程,你怎样保证T2在T1执行完后执行,...
  • 1、通过join方法去保证多线程顺序性特性。join让主线程等待子线程结束以后才能继续运行。 2、通过xecutorService executor = Excutors.newSingleThreadExecutor():单线程池处理,内部是弄个了FIFO队列。 ...
  • 前几天有一位同事在阿里一面的时候被问到这么一个多线程问题:如何保证多个线程的顺序执行。当时他没有回答上来,所以为了避免大家以后遇到同样的面试题还是回答不上来,今天我们就来分析解答下这个问题。问题缘由...
  • 通过join方法去保证多线程顺序执行 join:让主线程等待子结束以后才能继续运行 方法2 ExecutorService executorService = Executors.newSingleThreadExecutor(); 代码 public class Test { static Thread...
  • 三个线程T1,T2,T3,如何保证顺序执行? 在多线程中有多种方法让线程按特定顺序执行,你可以用线程类的join()方法在一个线程中启动另一个线程,另外一个线程完成该线程继续执行。为了确保三个线程的顺序你应该先启动...
  • 题目描述:如何保证多线程顺序执行? join方式实现 join方式即使用Thread.join方法来实现。Thread.join含义当前线程需要等待previousThread线程终止之后才从thread.join返回。简单来说,就是线程没有执行完...
  • 线程执行顺序

    2018-07-17 16:00:00
    三个线程T1,T2,T3,如何保证线程T2在T1执行执行,T3在T2执行执行。 利用join()方法。 package 多线程并发; /** * Created by z84102272 on 2018/7/17. */ public class ThreadJoin extends Thread{ ...
  • 线程顺序执行——join()

    千次阅读 2015-09-07 08:30:17
    * 假如有三个线程T1,T2,T3,如何保证T2在T3之前执行完成,T1在T2之前完成? * @author jiangyu 2015年9月7日 * 注意:线程的优先级无法保障线程执行次序。只不过优先级高的线程获取 CPU 资源的概率大一点而已。...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 169
精华内容 67
关键字:

多线程如何保证顺序执行