多线程并发保证线程的顺序执行
 考虑为什么在并发的情况下要保证线程的并发执行
 考虑到可能有如下几种情况
 1.单纯面试 现场顺序执行的考点就是线程间的通信问题
 2.真正的业务需求，如解析XML 我们想并发执行xml下多个节点，但是我们需要解析完成后再继续下不操作，如果节点中有依赖关系那我们就必须要保证一些顺序执行。
 
一.单纯面试来说 可实现的方式
 
1.join关键字
 
关键代码
 
        Thread t3 = new Thread(()->{
             System.out.println(Thread.currentThread().getName()+"==开始执行");
             try {
                 TimeUnit.SECONDS.sleep(1);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }    
             System.out.println(Thread.currentThread().getName()+"==结束执行");
         },"t3");
         t1.start();
         t1.join();
         t2.start();
         t2.join();
         t3.start();
         t3.join();
         System.out.println("所有线程到此执行完毕");
 
输出结果
 
t1==开始执行
 t1==结束执行
 t2==开始执行
 t2==结束执行
 t3==开始执行
 t3==结束执行
 所有线程到此执行完毕
 
为什么join关键字能保证线程顺序执行那
 
我们看join方法的简介
 
    * <p> This implementation uses a loop of {@code this.wait} calls
      * conditioned on {@code this.isAlive}. As a thread terminates the
      * {@code this.notifyAll} method is invoked. It is recommended that
      * applications not use {@code wait}, {@code notify}, or
      * {@code notifyAll} on {@code Thread} instances.
 
关键代码
 
   if (millis == 0) {
             while (isAlive()) {
                 wait(0);
             }
         } else {
             while (isAlive()) {
                 long delay = millis - now;
                 if (delay <= 0) {
                     break;
                 }
                 wait(delay);
                 now = System.currentTimeMillis() - base;
             }
 
会发现如果这个线程是活着的话会用while循环阻塞 主线程的运行，来次达到线程顺序执行
 
2.Executor.newSimpleThreadPool
 
关键代码
 
        Thread t3 = new Thread(()->{
             System.out.println(Thread.currentThread().getName()+"=t3=开始执行");
             try {
                 TimeUnit.SECONDS.sleep(1);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }    
             System.out.println(Thread.currentThread().getName()+"=t3=结束执行");
         },"t3");
         
         ExecutorService es = Executors.newSingleThreadExecutor();
         es.execute(t1);
         es.execute(t2);
         es.execute(t3);
         if(es.isShutdown())
         es.shutdown();
         System.out.println("所有线程到此执行完毕");
 
执行结果
 
所有线程到此执行完毕
 pool-1-thread-1=t1=开始执行
 pool-1-thread-1=t1=结束执行
 pool-1-thread-1=t2=开始执行
 pool-1-thread-1=t2=结束执行
 pool-1-thread-1=t3=开始执行
 pool-1-thread-1=t3=结束执行
 可以看到 用SimlpPool的话 能保证线程顺序执行，且不阻塞主线程运行
 
我们可以看SimlpPool 方线程的是LinkedBlockingQueue 链表阻塞队列且容量只为1，而链表是阻塞所有保证线程先进先出的规则来执行
 
3.Lock下conditional
 
volatile static int  num = 1;
 
Lock lock = new ReentrantLock();
         Condition c1 = lock.newCondition();
         Condition c2 = lock.newCondition();
         Condition c3 = lock.newCondition();
         
         Thread t1 = new Thread(()->{
             lock.lock();
             try {
                 while(num!=1) {
                     c1.await();
                 }
                 System.out.println(Thread.currentThread().getName()+"==开始执行");
                 TimeUnit.SECONDS.sleep(1);
                  num = 2;
                 c2.signal();
                 System.out.println(Thread.currentThread().getName()+"==结束执行");
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }finally {
                 lock.unlock();
             }
             
         },"t1");
 
利用lock Condition num 阻塞的方式 实现 线程大顺序执行
 
我们看下Condition 说明
 
    * <p>Before waiting on the condition the lock must be held by the
      * current thread.
      * A call to {@link Condition#await()} will atomically release the lock
      * before waiting and re-acquire the lock before the wait returns.
 
在等待条件之前，锁由当前线程持有。调用wait()在等待和重新获得锁之前自动释放锁。
 
二 对于业务中我们可以考虑Callable接口
 
    public static void test4() throws InterruptedException, ExecutionException {
       Future<String> futA = new FutureTask<String>(new Sub1("A", null));
       Thread t1 = new Thread((Runnable) futA);
       t1.start();
       System.out.println(futA.get());
       
       Future<String> futB = new FutureTask<String>(new Sub1("B", null));
       Thread t2 = new Thread((Runnable) futB);
       t2.start();
       System.out.println(futB.get());
       
       Future<String> futC = new FutureTask<String>(new Sub1("C", null));
       Thread t3 = new Thread((Runnable) futC);
       t3.start();
       System.out.println(futC.get());
       System.out.println("程序结束");
     }
 }
 class Sub1 implements Callable<String> {
 
    private String str ;
     private Map<String, String> map ;
     
     public Sub1() {};
     public Sub1(String str,Map<String, String> map) {
         this.str = str;
         this.map = map ;
     };
 
 

 
作为面试宠儿的多线程，在面试的时候是一定会被询问的话题，今天，在和朋友聊天的时候，他问了我一道很好玩的多线程面试题，不难，但是想解释清楚，还真的是不容易
 
问题：现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行
 
当看到这个问题的时候，我的第一反应就是wait、notify(会在后面附上代码+解释)，然后脑子里闪过好多不同的方案，那我们就来看一下我的第一反应是如何处理的
 
分析：
 
Thread类中的join方法是用来同步的，底层其实是调用了 wait方法。先来看一下演示代码：
 
package com.whh.concurrency;
 
/**
 
*@description:
 
* 问题：现在有 T1、T2、T3 三个线程,怎样保证 T2 在 T1 执行完后执行T3在T2执行完
 
* 分析：使用join方法实现
 
*@author:wenhuohuo
 
*/
 
public class MyJoin {
 
public static void main(String[] args) {
 
final Thread t1 = new Thread(new Runnable() {
 
@Override
 
public void run() {
 
System.out.println("线程1");
 
}
 
},"t1");
 
final Thread t2 = new Thread(new Runnable() {
 
@Override
 
public void run() {
 
try {
 
t1.join();
 
} catch (Exception e) {
 
e.printStackTrace();
 
}
 
System.out.println("线程2");
 
}
 
},"t2");
 
final Thread t3 = new Thread(new Runnable() {
 
@Override
 
public void run() {
 
try {
 
t2.join();
 
}catch (Exception e){
 
e.printStackTrace();
 
}
 
System.out.println("线程3");
 
}
 
},"t3");
 
t3.start();
 
t2.start();
 
t1.start();
 
}
 
}
 
执行结果：
 
线程1
 
线程2
 
线程3
 
可以看到，我们让t2线程调用t1.join,t3调用t2.join，尽管是t3，t2，t1分别start，执行顺序还是t1，t2，t3。是因为join方法底层使用的是wait方法。
 
查看join方法源码
 
public final void join() throws InterruptedException {
 
join(0); //传入的是毫秒值
 
}
 
public final synchronized void join(long millis)
 
throws InterruptedException {
 
long base = System.currentTimeMillis();
 
long now = 0;
 
if (millis < 0) {
 
throw new IllegalArgumentException("timeout value is negative");
 
}
 
if (millis == 0) {
 
while (isAlive()) { //isAlive()是native方法，判断线程是否还存活
 
wait(0);//wait(0),不计时间，一直等待，直到有notify()或notifyAll()来唤醒。
 
}
 
} else {
 
while (isAlive()) {
 
long delay = millis - now;
 
if (delay <= 0) {
 
break;
 
}
 
wait(delay);//传入时间，表示在时间值消耗完之前一直等待，直到过了等待时间。
 
now = System.currentTimeMillis() - base;
 
}
 
}
 
}
 
1)从源码中，我们结合之前的代码分析，t2.join()和t3.join(),均没有传值，相当于join(0),表示不计时间，t2会一直wait等待t1执行完成，t3会一直wait等待t2执行完成。所以执行结果顺序是t3，t2，t1。
 
2)当传入的毫秒值不为0时，就一直循环等待，直到过了等待时间(dalay<=0)，则执行break方法，那么将不再等待。
 
改变join()传入的毫秒值，查看执行顺序并分析结果：
 
public class MyJoin {
 
public static void main(String[] args) {
 
final Thread t1 = new Thread(new Runnable() {
 
@Override
 
public void run() {
 
try {
 
//处理业务时间，模拟为8秒
 
Thread.sleep(8000);
 
} catch (InterruptedException e) {
 
e.printStackTrace();
 
}
 
System.out.println("线程1");
 
}
 
},"t1");
 
final Thread t2 = new Thread(new Runnable() {
 
@Override
 
public void run() {
 
try {
 
t1.join(4000); //t2等待t1线程4秒
 
} catch (Exception e) {
 
e.printStackTrace();
 
}
 
System.out.println("线程2");
 
}
 
},"t2");
 
final Thread t3 = new Thread(new Runnable() {
 
@Override
 
public void run() {
 
try {
 
t2.join(2000); //t3等待t2线程2秒
 
}catch (Exception e){
 
e.printStackTrace();
 
}
 
System.out.println("线程3");
 
}
 
},"t3");
 
t3.start();
 
t2.start();
 
t1.start();
 
}
 
}
 
执行结果：
 
线程3//程序启动过了2秒执行t3
 
线程2 //过了4秒执行t2
 
线程1 //过了8秒执行t1
 
分析：我们让t1 睡眠8秒模拟业务执行时间，t2等待t1 的时间为4秒，t3等待t2的时间为2秒。那么当t1，t2，t3启动后，等待的时间，t3会因为t2的等待时间4秒太长而先与t2执行，t2会因为t1的8秒太长而先与t1执行。
 
好了，到这里不知道大家感觉怎么样，有没有想明白，其实，关于多线程顺序执行的问题，我总结了一个万能的解答方法，通过一个小例子进行演示
 
例题描述：建立三个线程，A线程打印100次A，B线程打印100次B,C线程打印100次C，要求线程同时运行，交替打印100次ABC。这个问题用Object的wait()，notify()就可以很方便的解决。
 
代码如下：
 
public class QueueThread implements Runnable{
 
private Object current;
 
private Object next;
 
private int max=100;
 
private String word;
 
public QueueThread(Object current, Object next, String word) {
 
this.current = current;
 
this.next = next;
 
this.word = word;
 
}
 
@Override
 
public void run() {
 
// TODO Auto-generated method stub
 
for(int i=0;i
 
synchronized (current) {
 
synchronized (next) {
 
System.out.println(word);
 
next.notify();
 
}
 
try {
 
current.wait();
 
} catch (InterruptedException e) {
 
// TODO Auto-generated catch block
 
e.printStackTrace();
 
}
 
}
 
}
 
//必须做一下这样处理，否则thread1-thread4停不了
 
synchronized (next) {
 
next.notify();
 
System.out.println(Thread.currentThread().getName()+"执行完毕");
 
}
 
}
 
public static void main(String[] args) throws InterruptedException {
 
long startTime = System.currentTimeMillis();
 
Object a = new Object();
 
Object b = new Object();
 
Object c = new Object();
 
Object d = new Object();
 
Object e = new Object();
 
//之所以每次当前线程都要sleep(10)是为了保证线程的执行顺序
 
new Thread(new QueueThread(a,b,"a")).start();
 
Thread.sleep(10);
 
new Thread(new QueueThread(b,c,"b")).start();
 
Thread.sleep(10);
 
new Thread(new QueueThread(c,d,"c")).start();
 
Thread.sleep(10);
 
new Thread(new QueueThread(d,e,"d")).start();
 
Thread.sleep(10);
 
Thread thread4 = new Thread(new QueueThread(e,a,"e"));
 
thread4.start();
 
thread4.join();//因为线程0-4停止是依次执行的，所以如果保证主线程在线程4后停止，那么就能保证主线程是最后关闭的
 
System.out.println("程序耗时："+ (System.currentTimeMillis()-startTime ));
 
}
 
}
 
其实这个程序很容易理解，首先，我们保证了线程0-线程4依次启动，并设置了Thread.sleep(10)，保证线程0-4依次执行他们的run方法。
 
其次，我们看QueueThread的run()便可知：1.线程获得current锁，2.获得next锁。3.打印并notify拥有next锁的一个对象4.线程执行current.wait(),释放current锁对象，并使线程处于阻塞状态。
 
然后，假设已经执行到了thread-4的run方法，那么此时的情况是这样的：
 
线程0处于阻塞状态，需要a.notify()才能使其回到runnale状态
 
线程1处于阻塞状态，需要b.notify()才能使其回到runnale状态
 
线程2处于阻塞状态，需要c.notify()才能使其回到runnale状态
 
线程3处于阻塞状态，需要d.notify()才能使其回到runnale状态
 
而线程4恰好可以需要执行a.notify()，所以能够使线程0回到runnale状态。然后执行e,wait()方法，使自身线程阻塞，需要e.notify()才能唤醒。
 
依次执行下去，就可以发现规律了！
 
最后之所以要在for循环后加上一个处理，是因为，如果不进行处理，除了线程0能够结束for循环，其余线程1-4实际上是会停在current,wait()这句代码的。
 
假设已经执行到最后一次循环了，此时线程4唤醒线程0，并将自身阻塞。线程0被唤醒后，继续执行，然而因为i=max的缘故，它无法再进入循环了。然而如果循环后没有唤醒下一个线程的操作的话，那么剩下的线程1-4就会一直处于阻塞状态！也就不会停止了。但是加了处理之后就完美解决了。
 
好啦，到这里两个小实例就讲完了，不知道通过这两个小实例有没有让你很好的理解这道面试题呢？有问题的话，下方评论区，大家一起讨论吧
 
欢迎大家关注我，一个脑回路清奇的程序猿，在娱乐中学习是我的真谛，大家一起努力进步
 

多线程情况下由于会有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都会获得执行权。
 
 

文章介绍4种方法，简单易懂，通过4个demo抛砖引玉。
 
目录
 
在子线程中通过join()方法指定顺序
 
在主线程中通过join()方法指定顺序
 
通过倒数计时器CountDownLatch实现
 
通过创建单一化线程池newSingleThreadExecutor()实现
 

在子线程中通过join()方法指定顺序
 
通过join()方法使当前线程“阻塞”，等待指定线程执行完毕后继续执行。举例：在线程thread2中，加上一句thread1.join()，其意义在于，当前线程2运行到此行代码时会进入阻塞状态，直到线程thread1执行完毕后，线程thread2才会继续运行，这就保证了线程thread1与线程thread2的运行顺序。
 
public class ThreadJoinDemo {
    public static void main(String[] args) throws InterruptedException {
        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();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("拿出一瓶牛奶！");
            }
        });

        final Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    thread2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("关上冰箱！");
            }
        });

        //下面三行代码顺序可随意调整，程序运行结果不受影响，因为我们在子线程中通过“join()方法”已经指定了运行顺序。
        thread3.start();
        thread2.start();
        thread1.start();

    }
}
 
运行结果：
 
打开冰箱！
拿出一瓶牛奶！
关上冰箱！
 
在主线程中通过join()方法指定顺序
 
简单说一下子线程与主线程的区别，子线程指的是发生在Thread内部的代码，主线程指的是发生在main函数中的代码，我们可以在main函数中通过join()方法让主线程阻塞等待以达到指定顺序执行的目的。
 
public class ThreadMainJoinDemo {
    public static void main(String[] args) throws InterruptedException {
        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("关上冰箱！");
            }
        });

        thread1.start();
        thread1.join();
        thread2.start();
        thread2.join();
        thread3.start();
    }
}
 
输出结果：
 
打开冰箱！
拿出一瓶牛奶！
关上冰箱！
 
通过倒数计时器CountDownLatch实现
 
CountDownLatch通过计数器提供了更灵活的控制，只要检测到计数器为0当前线程就可以往下执行而不用管相应的thread是否执行完毕。
 
public class ThreadCountDownLatchDemo {

    private static CountDownLatch countDownLatch1 = new CountDownLatch(1);

    private static CountDownLatch countDownLatch2 = new CountDownLatch(1);

    public static void main(String[] args) {
        final Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("打开冰箱！");
                countDownLatch1.countDown();
            }
        });

        final Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    countDownLatch1.await();
                    System.out.println("拿出一瓶牛奶！");
                    countDownLatch2.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        final Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    countDownLatch2.await();
                    System.out.println("关上冰箱！");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        //下面三行代码顺序可随意调整，程序运行结果不受影响
        thread3.start();
        thread1.start();
        thread2.start();
    }
}
 
输出结果：
 
打开冰箱！
拿出一瓶牛奶！
关上冰箱！
 
通过创建单一化线程池newSingleThreadExecutor()实现
 
单线程化线程池(newSingleThreadExecutor)的优点，串行执行所有任务。
 
public class ThreadPoolDemo {

   static ExecutorService executorService = Executors.newSingleThreadExecutor();

    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() {
                System.out.println("拿出一瓶牛奶！");
            }
        });

        final Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("关上冰箱！");
            }
        });
        executorService.submit(thread1);
        executorService.submit(thread2);
        executorService.submit(thread3);
        executorService.shutdown();        //使用完毕记得关闭线程池
    }

}
 
输出结果：
 
打开冰箱！
拿出一瓶牛奶！
关上冰箱！