Java线程那点事

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是被动的。