本篇是系列第二篇，主要介绍下java中线程操作常用的函数和隔离区数据保护方法，join（）、wait（）、notify（）、synchronized、volatile。

1.join（）

当使用join的时候，表示该线程插入，当前线程等待该线程执行完毕
当线程执行完毕后，被等待的线程会在退出前调用notifyAll通知所有等待线程继续执行。下面我们做个实验来看下join的具体效果，这样比较好理解。

public class JoinThreadMain {
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(new TestThread());
        thread1.start();

        System.out.println("count = " + count);

    }

    private static int count = 0;

    public static class TestThread implements Runnable{
        @Override
        public void run() {
            for(int i=0; i<10000; i++){
                count++;
            }
        }
    }
}

从代码看定义了一个static的count变量用于计数，在main函数主线程中调用线程start方法后，接着输出count值，因为start后线程，主线程会直接输出当前的count值，当前count值可能还未执行完线程的循环，所以输出的值一般都是小于10000的，例如下面之行后输出的是63。

count = 63

如果我们要实现子线程完成后再其他线程再输出，就可以使用join方法将该线程临时插入当前线程去执行，直到执行完毕再继续执行当前线程，修改后的代码如下：

public class JoinThreadMain {
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(new TestThread());
        thread1.start();
        thread1.join();
        System.out.println("count = " + count);

    }

    private static int count = 0;

    public static class TestThread implements Runnable{
        @Override
        public void run() {
            for(int i=0; i<10000; i++){
                count++;
            }
        }
    }
}

现在的输出结果就是我们期望的10000了。

count = 10000

2.wait（）、notify（）

jdk中两个非常重要的接口线程方法，wait和notity，这两个方法不在Thread类而是在Object类。当一个对象实例调用wait方法后，当前线程就会在这个对象上等待，当thread1调用了obj.wait()，那么thread1就会进入等待队列，当obj.notify被调用，系统会从队列中随机选择一个线程继续执行。obj.wait方法不可以随便调用必须包含在对应的synchronzied语句中，无论是wait还是notify都需要先获得目标对象的监视器。

public class WaitNotifyMain {
    private final static Object object = new Object();

    public static void main(String[] args) throws InterruptedException {
        
        Thread thread1 = new Thread(new Thread1());
        Thread thread2 = new Thread(new Thread2());
        thread1.start();
        thread2.start();

    }

    public static class Thread1 extends Thread {
        public void run() {
            synchronized (object) {
                System.out.println(System.currentTimeMillis() + ":thread1 start !");
                try {
                    System.out.println(System.currentTimeMillis() + ":thread1 wait for object !");
                    object.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(System.currentTimeMillis() + ":thread1 end!");
            }
        }
    }

    public static class Thread2 extends Thread {
        public void run() {
            synchronized (object) {
                System.out.println(System.currentTimeMillis() + ":thread2 start ! notify one thread");
                object.notify();

                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(System.currentTimeMillis() + ":thread2 end!");
            }
        }
    }
}

3.synchronized

synchronized是最常用的隔离区保护的关键字，线程中方法如果使用synchronized则表示该方法同时只能有一个线程访问，这就能够保证隔离区数据的线程安全，这也是保证隔离区数据安全最常用的方法，下面定义的add方法不管并发多大计算的结果都不会改变。

public class SyncThread implements Runnable {
    private synchronized void add(){
        SynchronizedMain.count2++;
    }

    @Override
    public void run() {
        for(int i=0; i<100000; i++){
            add();
        }
    }
}

4.Volatile

当用volatile去申明变量时，就等于告诉虚拟机，这个变量极有可能会被某些程序或者线程修改，当值修改，所有线程都能看到该值变化。但是执行会发现count还是不等于100000，因为当有线程并发操作count的时候，虽然count修改后通知到各个线程，但是并发读取到值的线程还是会存在修改后覆盖的情况，所以肯定是小于100000，所以volatile不适合用在大并发的场景。

public class VolatileMain {
    
    static volatile int count = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[10];
        for(int i=0; i<10; i++){
            threads[i] = new Thread(new MyVolatileThread());
            threads[i].start();
        }

        for(int i=0; i<10; i++){
            threads[i].join();
        }
        
        System.out.println(count);
    }

    public static class MyVolatileThread implements Runnable{
        @Override
        public void run() {
            for(int i=0; i<10000; i++){
                count++;
            }
        }
    }

}