1、如何控制线程执行的顺序？
第一种办法是通过join方法去保证多线程的顺序性的特性
join：让主线程等待子线程结束以后才能够进行运行
//
static Thread thread1 = new Thread(){
@Override
public void run() {
System.out.println("thread 1");
}
};
static Thread thread2 = new Thread(){
@Override
public void run() {
System.out.println("thread 2");
}
};
static Thread thread3 = new Thread(){
@Override
public void run() {
System.out.println("thread 3");
}
};
public static void main(String[] args) throws InterruptedException {
thread1.start();
thread1.join();
thread2.start();
thread2.join();
thread3.start();
}
运行结果：
thread 1
thread 2
thread 3
第二种是通过ExecutorService这个方法，这是Java5的时候出来的。
static Runnable runnable1=()->{
System.out.println("RunningfromLambda 1");
};
static Runnable runnable2=()->{
System.out.println("RunningfromLambda 2");
};
static Runnable runnable3=()->{
System.out.println("RunningfromLambda 3");
};
static ExecutorService executorService = Executors.newSingleThreadExecutor();
public static void main(String[] args) {
executorService.submit(runnable1);
executorService.submit(runnable2);
executorService.submit(runnable3);
executorService.shutdown();
}
运行结果：
RunningfromLambda 1
RunningfromLambda 2
RunningfromLambda 3
2、Java中Volatile和Synchronized的区别？
首先什么是JMM（Java Memory Model）？
它主要是用来处理并发过程中如何处理可见性、原子性、有序性的问题。
并发编程中有两个关键问题
a.线程之间如何通信 ;
方法：wait() 、notify()、notifyall()
线程通信有两种，一种是共享内存(隐式通信)，第二种是消息传递（显示通信）。
b.线程之间如何同步
在共享内存的并发模型中，同步是显示做的；可以通过Synchronized线程排队访问做到。
在消息传递的并发模型中，由于消息的发送必须在消息接收之前，所以同步是隐式。
3、定位内存可见性问题
什么是对象内存共享，什么不是？
每一个线程都会有一个私有的本地内存，例如线程A想和线程B进行通信，线程A会先把本地内存的信息共享到主内存的共享变量里面去，然后B会到主内存里面去拿这个共享变量到B的本地内存，这个过程就完成了一个线程通信。
那么线程A什么时候去刷新共享这个内存？线程B什么时候去主内存里面去拿，这就是线程安全的核心问题。
那么怎么去解决这个问题呢？
通过Volatile和Synchronized解决。
那么使用Volatile会发生什么呢？
1、对于使用了Volatile的变量进行写操作的时候，JVM会向处理器发送一条Lock前缀的指令。会把这个变量所在缓存行的数据写回到系统内存
2、在多多处理器的情况下，保证各个处理器缓存一致性的特点，就回实现缓存一致性协议。就是每个处理器会嗅探到总线传过的数据进行检测，自己缓存的值是不是过期了，当处理器发现自己缓存的内存地址被修改以后，它就会把当前缓存的处理器设置为失效状态，这个时候处理器对它进行修改的时候，它会重新去把这个值读准确，读到自己的处理器缓存里面。
Volatile：可以做到原子性、可见性；不能做到复合操作的原子性。
synchronized：可重入锁、互斥性、可见性
我们来编译一下这段代码，看下会有什么东西
public class App {
public static void main(String[] args) {
synchronized(App.class){
}
}
public static synchronized void test(){
}
}
{
public com.tuling.springcloud.bean.App();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 6: 0
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this Lcom/tuling/springcloud/bean/App;
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=3, args_size=1
0: ldc #2 // class com/tuling/springcloud/bean/App
2: dup
3: astore_1
4: monitorenter(synchronized核心)
5: aload_1
6: monitorexit(synchronized的核心)
7: goto 15
10: astore_2
11: aload_1
12: monitorexit
13: aload_2
14: athrow
15: return
Exception table:
from to target type
5 7 10 any
10 13 10 any
LineNumberTable:
line 9: 0
line 11: 5
line 12: 15
LocalVariableTable:
Start Length Slot Name Signature
0 16 0 args [Ljava/lang/String;
StackMapTable: number_of_entries = 2
frame_type = 255 /* full_frame */
offset_delta = 10
locals = [ class "[Ljava/lang/String;", class java/lang/Object ]
stack = [ class java/lang/Throwable ]
frame_type = 250 /* chop */
offset_delta = 4
public static synchronized void test();
descriptor: ()V
flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
Code:
stack=0, locals=0, args_size=0
0: return
LineNumberTable:
line 15: 0
}
4: monitorenter(synchronized核心)
6: monitorexit(synchronized的核心)
它会先去获得一个锁，如果成功了然后再去调用这个对象，如果失败了进入一个队列，开始执行下一个线程。
Lock和Synchronized的区别
1、Synchronized线程执行出现异常的时候释放
2、Synchronized的缺陷
Lock可以主动释放锁，而Synchronized是被动的。