只要了解过多线程，我们就知道线程开始的顺序跟执行的顺序是不一样的。如果只是创建三个线程然后执行，最后的执行顺序是不可预期的。这是因为在创建完线程之后，线程执行的开始时间取决于CPU何时分配时间片，线程可以看成是相对于的主线程的一个异步操作。
public class FIFOThreadExample {
public synchronized static void foo(String name) {
System.out.print(name);
}
public static void main(String[] args) {
Thread thread1 = new Thread(() -> foo("A"));
Thread thread2 = new Thread(() -> foo("B"));
Thread thread3 = new Thread(() -> foo("C"));
thread1.start();
thread2.start();
thread3.start();
}
}
输出结果：ACB/ABC/CBA...
那么我们该如何保证线程的顺序执行呢？
如何保证线程的顺序执行?
1. 使用Thread.join()实现
通过thread的join方法保证多线程的顺序执行， wait是让主线程等待
Thread.join()的作用是让父线程等待子线程结束之后才能继续运行。以上述例子为例，main()方法所在的线程是父线程，在其中我们创建了3个子线程A,B,C，子线程的执行相对父线程是异步的，不能保证顺序性。而对子线程使用Thread.join()方法之后就可以让父线程等待子线程运行结束后，再开始执行父线程，这样子线程执行被强行变成了同步的，我们用Thread.join()方法就能保证线程执行的顺序性。
public class FIFOThreadExample {
public static void foo(String name) {
System.out.print(name);
}
public static void main(String[] args) throws InterruptedException{
Thread thread1 = new Thread(() -> foo("A"));
Thread thread2 = new Thread(() -> foo("B"));
Thread thread3 = new Thread(() -> foo("C"));
thread1.start();
thread1.join();
thread2.start();
thread2.join();
thread3.start();
}
}
输出结果：ABC
2. 使用单线程线程池来实现
ExecutorService executor = Executors.newSingleThreadExecutor()
另一种保证线程顺序执行的方法是使用一个单线程的线程池，这种线程池中只有一个线程，相应的，内部的线程会按加入的顺序来执行。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class FIFOThreadExample {
public static void foo(String name) {
System.out.print(name);
}
public static void main(String[] args) throws InterruptedException{
Thread thread1 = new Thread(() -> foo("A"));
Thread thread2 = new Thread(() -> foo("B"));
Thread thread3 = new Thread(() -> foo("C"));
ExecutorService executor = Executors.newSingleThreadExecutor();
executor.submit(thread1);
executor.submit(thread2);
executor.submit(thread3);
executor.shutdown();
}
}
输出结果：ABC
3. 使用volatile关键字修饰的信号量实现
3.1JMM-java memory model
解决并发过程中如何处理可见性，原子性，有序性的问题 runnable ，thread。 并发编程中的2个关键问题： a. 线程间如何通信 --wait() notify() notifyAll() a) 共享内存 -隐式通信 b) 消息传递 - 显示通信 b. 线程之间如何同步 在共享内存的并发模型中，同步是显示做的； synchronized 在消息传递的并发模型中，由于小时发送必须在消息接受之前，所以同步是隐式的
3.2. 定位内存可见性问题
什么对象是内存共享的 ，什么不是，堆内存的对象，java虚拟机栈
JMM定义了线程和主内存之间的一个关系。线程之间通讯，必须通过主内存通讯。
volatile、synchronized volatile 功能，声明了volatile的变量，进行写操作的时候，jvm会向处理器发送一条Lock的前缀指令，会把这个变量所在缓存行的数据写回到系统内存。 在多处理器的情况下，保证各个处理器缓存一致性的特点，会实现缓存一致性协议。改变了值的volatile变量，在其他行程被指为失效状态其他线程要使用这个变量，需要重新到驻村里面去取。
synchronized：可重入锁、互斥性、可见性 volatile 可以做到原子性，可见性，不能做到复合操作的原子性
比如： volatile int i; i++ 读取i的值，给i加1，把新的值赋值给i，这个i++操作在多线程环境下是无法保证原子性的
synchronized后面锁定的对象，可以是一个类对象，也可以是一个成员变量。 第一个线程进来调用monitorener 和monitorexit实现，获取对象的监视器，释放对象监视器 后续进程过来，如果monitor还没有释放，那么他获取不到这个对象的monitor，会放到一个对列里面：synthronizedQueue。 等到对象的锁释放了，通知synthronizedQueue出队列，获取那个monitor。
上面两种的思路都是让保证线程的执行顺序，让线程按一定的顺序执行。这里介绍第三种思路，那就是线程可以无序运行，但是执行结果按顺序执行。 你应该可以想到，三个线程都被创建并start()，这时候三个线程随时都可能执行run()方法。因此为了保证run()执行的顺序性，我们肯定需要一个信号量来让线程知道在任意时刻能不能执行逻辑代码。 另外，因为三个线程是独立的，这个信号量的变化肯定需要对其他线程透明，因此volatile关键字也是必须要的。
public class TicketExample2 {
//信号量
static volatile int ticket = 1;
//线程休眠时间
public final static int SLEEP_TIME = 1;
public static void foo(int name){
//因为线程的执行顺序是不可预期的，因此需要每个线程自旋
while (true) {
if (ticket == name) {
try {
Thread.sleep(SLEEP_TIME);
//每个线程循环打印3次
for (int i = 0; i < 3; i++) {
System.out.println(name + " " + i);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
//信号量变更
ticket = name%3+1;
return;
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread thread1 = new Thread(() -> foo(1));
Thread thread2 = new Thread(() -> foo(2));
Thread thread3 = new Thread(() -> foo(3));
thread1.start();
thread2.start();
thread3.start();
}
}
执行结果： 1 0 1 1 1 2 2 0 2 1 2 2 3 0 3 1 3 2
4. 使用Lock、synchronized和信号量实现
Lock是java5以后出现的，在juc包： java.util.concurrentlocks
4.1 synthronized的锁什么时候释放
1.1 获取锁的线程执行完了该代码块
1.2 线程出现异常
4.2 synchronized的缺陷
2.1 读写冲突
4.3 Lock可以主动去释放锁，而synchronized是被动的
ReadWriteLock ReadLock WriteLock ReenterantLock可重入锁 可中断锁 公平锁 等待一个锁的实际越长，获取这个锁的几率越高 ReenterantReadWriteLock 可重入读写锁 Lock是java里面的一个接口，有丰富的实现，而synchronized是java的一个关键字，是一个内置的功能
竞争资源激烈的情况，Lock性能优于synchronized，但是jdk7,8对synchronized做了很多优化，性能差异不大。
此种方法的思想跟第三种方法是一样的，都是不考虑线程执行的顺序而是考虑用一些方法控制线程执行业务逻辑的顺序。这里我们同样用一个原子类型信号量ticket，当然你可以不用原子类型，这里我只是为了保证自增操作的线程安全。然后我们用了一个可重入锁ReentrantLock。用来给方法加锁，当一个线程拿到锁并且标识位正确的时候开始执行业务逻辑，执行完毕后唤醒下一个线程。 这里我们不需要使用while进行自旋操作了，因为Lock可以让我们唤醒指定的线程，所以改成if就可以实现顺序的执行。
public class TicketExample3 {
//信号量
AtomicInteger ticket = new AtomicInteger(1);
public Lock lock = new ReentrantLock();
private Condition condition1 = lock.newCondition();
private Condition condition2 = lock.newCondition();
private Condition condition3 = lock.newCondition();
private Condition[] conditions = {condition1, condition2, condition3};
public void foo(int name) {
try {
lock.lock();
//因为线程的执行顺序是不可预期的，因此需要每个线程自旋
System.out.println("线程" + name + " 开始执行");
if(ticket.get() != name) {
try {
System.out.println("当前标识位为" + ticket.get() + ",线程" + name + " 开始等待");
//开始等待被唤醒
conditions[name - 1].await();
System.out.println("线程" + name + " 被唤醒");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(name);
ticket.getAndIncrement();
if (ticket.get() > 3) {
ticket.set(1);
}
//执行完毕，唤醒下一次。1唤醒2,2唤醒3
conditions[name % 3].signal();
} finally {
//一定要释放锁
lock.unlock();
}
}
public static void main(String[] args) throws InterruptedException {
TicketExample3 example = new TicketExample3();
Thread t1 = new Thread(() -> {
example.foo(1);
});
Thread t2 = new Thread(() -> {
example.foo(2);
});
Thread t3 = new Thread(() -> {
example.foo(3);
});
t1.start();
t2.start();
t3.start();
}
}
输出结果： 线程2 开始执行 当前标识位为1,线程2 开始等待 线程1 开始执行 1 线程3 开始执行 当前标识位为2,线程3 开始等待 线程2 被唤醒 2 线程3 被唤醒 3
上述的执行结果并非唯一，但可以保证打印的顺序一定是123这样的顺序。
《王者荣耀》如梦令皮肤什么时候下架 如梦令皮肤下架时间一览
安卓手机如何恢复删除的照片