线程开始运行，拥有自己的栈空间，每个运行中线程，如果仅仅是孤立地运行，那么没有一点点的价值，或者说价值很少，如果每个线程能够互相配合
完成工作，这将会带来巨大的价值。

1.1Volatile和synchronized关键字

Java支持多个线程同时访问一个对象或者对象的成员变量，由于每个线程可以拥有这个线程这个变量的拷贝，所以程序在执行过程中，一个线程看到的变量并不一定是最新的。（虽然对象及成员变量分配的内存实在共享内存中的，但是每个执行的线程还是可以拥有一份拷贝，这样做的目的是加速程序的执行这是现代多核处理器的一个显著特性）

关键字volatile可以用来修饰字段，告知程序任何对该变量的访问都要从共享内存中获取，而对他的改变必须同步刷新会共享内存，它能保证所有线程对变量访问的可见性。

关键字synchronized可以修饰方法或者同步块的 形式来进行使用，它主要确保多个线程在同一时刻，只能有一个线程处于方法或者同步块中，它保证了线程对变量访问的可见性和排他性。

我们通过javap工具查看生产的class文件信息来分析synchronize关键字 的实现细节。

public class Synchronized {
    public static void main(String[] args) {
        // 对synchronized Class对象进行加锁
        synchronized (Synchronized.class) {

        }
        // 静态同步方法，对synchronized Class对象进行加锁
        m();
    }

    public static synchronized void m() {

    }
}

在Synchronized.java同级目录先执行javac Synchronized.java，在执行 javap -v Synchronized.class，部分相关输出如下:

 public static void main(java.lang.String[]);
 flags: ACC_PUBLIC, ACC_STATIC
    Code:
    	stack=2, locals=1, args_size=1
       0: ldc           #2                  // class com/example/demo/thread/Synchronized
       2: dup
       3: astore_1
       4: monitorenter						// 监视器进入：获取锁
       5: aload_1
       6: monitorexit						// 监视器退出：释放锁
       7: goto          15
      10: astore_2
      11: aload_1
      12: monitorexit
      13: aload_2
      14: athrow
      15: invokestatic  #3                  // Method m:()V
      18: return
 public static synchronized void m();
  flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
    Code:
      stack=0, locals=0, args_size=0
       0: return

上面class信息总，对于同步块的实现使用了monitorenter和monitorexit指令，而同步方法则是依靠方法修饰符上的 ACC_SYNCHRONIZED来完成的。这两种方式本质都是对一个对象的监视器(monitor)进行获取，同时这个获取是排他的，也就是同一时刻只能有一个线程获取到有synchronized所保护对象的监视器。

任意一个对象都拥有自己的监视器，当这个对象有同步代码块或者这个对象的同步方法调用时，执行方法的线程必须先获取到该对象的监视器才能进入同步块或者同步方法，而没有获取到监视器的线程将会被祖册在同步代码块和同步方法的入口处，进入BOLOCKED状态。

对象、对象的监视器、同步队列和执行线程之间的关系。

从图中可以看到，任意线程对Object的访问，首先要获得Object的监视器，如果获取失败，该线程就进入同步状态，线程状态变为BLOCKED，当Object的监视器占有者释放后，在同步队列中得线程就会有机会重新获取该监视器。

1.2 等待/通知机制

等待/通知的相关方法是任意Java对象都具备的，因为这些方法被定义在所有对象的超类java.lang.Object上，方法和描述如下表所示。

等待/通知机制，是指一个线程A调用了对象O的wait()方法进入等待状态，而另一个线程B调用了对象O的notify()或者notifyAll()方法，线程A收到通知后从对象O的wait()方法返回，进而执行后续操作。

创建两个线程——WaitThread和NotifyThread，前者检查flag否为false，如果符合要求，进行后续操作，否则在lock上等待，后者在睡眠了一段时间后对lock进行通知。

public class WaitAndNotifyThread {

    static boolean flag = true;
    static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread waitThread = new Thread(new Wait(), "WaitThread");
        waitThread.start();
        SleepUtils.second(1);
        Thread notifyThread = new Thread(new Notify(), "NotifyThread");
        notifyThread.start();
    }


    static class Wait implements Runnable {

        @Override
        public void run() {
            //加锁，拥有lock的Monitor
            synchronized (lock) {
                //当条件不满足时，继续wait，同时释放了lock锁
                while (flag) {
                    System.out.println(Thread.currentThread() + " flag is true. wait@ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //条件满足时，完成工作
                System.out.println(Thread.currentThread() + " flag is false. running@ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            }
        }
    }


    static class Notify implements Runnable {

        @Override
        public void run() {
            //加锁，拥有lock的Monitor
            synchronized (lock) {
                //获取lock的锁然后进行通知，通知时不会释放lock的锁
                //直到当前线程释放了lock后，WaitThread才能从wait方法中返回
                System.out.println(Thread.currentThread() + " hold lock. notify@ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                lock.notifyAll();
                flag = false;
                SleepUtils.second(5);
            }
            //再次加锁
            synchronized (lock) {
                System.out.println(Thread.currentThread() + " hold lock again. sleep@ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                SleepUtils.second(5);
            }
        }
    }

}

运行结果

Thread[WaitThread,5,main] flag is true. wait@ 00:03:06
Thread[NotifyThread,5,main] hold lock. notify@ 00:03:07
Thread[NotifyThread,5,main] hold lock again. sleep@ 00:03:12
Thread[WaitThread,5,main] flag is false. running@ 00:03:17

上述例子主要说明了调用wait()、notify()以及notifyAll()时需要注意的细节，如下。

1. 使用wait()、notify()和notifyAll()时需要先对调用对象加锁。
2. 调用wait()方法后，线程状态由RUNNING变为WAITING，并将当前线程放置到对象的等待队列。
3. notify()或notifyAll()方法调用后，等待线程依旧不会从wait()返回，需要调用notify()或notifAll()的线程释放锁之后，等待线程才有机会从wait()返回。
4. notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而notifyAll()方法则是将等待队列中所有的线程全部移到同步队列，被移动的线程状态由WAITING变为BLOCKED。
5. 从wait()方法返回的前提是获得了调用对象的锁。

从上述细节中可以看到，等待/通知机制依托于同步机制，其目的就是确保等待线程从wait()方法返回时能够感知到通知线程对变量做出的修改。

WaitThread首先获取了对象的锁，然后调用对象的wait()方法，从而放弃了锁并进入了对象的等待队列WaitQueue中，进入等待状态。由于WaitThread释放了对象的锁，NotifyThread随后获取了对象的锁，并调用对象的notify()方法，将WaitThread从WaitQueue移到SynchronizedQueue中，此时WaitThread的状态变为阻塞状态。NotifyThread释放了锁之后，WaitThread再次获取到锁并从wait()方法返回继续执行。

1.3 小结

本篇文章主讲了Volatile和Synchronized关键字的概念(后面会写这两个关键字的原理以及特性)，线程间通信的方法，希望对大家有用。感谢观看，欢迎大家评论区交流探讨。