多线程（3）线程间的通信-小羊的记录本

导言：
JVM启动是多线程的，至少启动了主线程和垃圾回收线程。多线程是抢占资源的！比如主线程和垃圾回收的打印顺序会不一样的.

锁和同步lock、synchronized

• 锁：基于对象，又叫对象锁。一个锁同一时间只能被一个线程所有（婚姻关系）。一个锁被一个线程释放了（类似离婚），才能被另一个线程持有（类似结婚）。
• 同步：两个线程操作后的结果一样。

无锁状态：

public class NoneLock {

    static class ThreadA implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println("Thread A " + i);
            }
        }
    }

    static class ThreadB implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println("Thread B " + i);
            }
        }
    }

    public static void main(String[] args) {
        new Thread(new ThreadA()).start();
        new Thread(new ThreadB()).start();
    }
}

每次打印的结果都是不一样的！

引用了锁之后：

public class ObjectLock {
    private static Object lock = new Object();

    static class ThreadA implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 100; i++) {
                    System.out.println("Thread A " + i);
                }
            }
        }
    }

    static class ThreadB implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 100; i++) {
                    System.out.println("Thread B " + i);
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new Thread(new ThreadA()).start();
        Thread.sleep(10);
        new Thread(new ThreadB()).start();
    }
}

步骤：
Step1:声明一个锁
Step2:在线程A和线程B内需要同步的代码块中，用synchronized关键字加同一个锁
Step3:主线程sleep()来确定线程谁先运行

这里在主线程里使用sleep方法睡眠了10毫秒，是为了防止线程B先得到锁。
因为如果同时start，线程A和线程B都是出于就绪状态，操作系统可能会先让B运行。
这样就会先输出B的内容，然后B执行完成之后自动释放锁，线程A再执行。

等待和通知机制wait()、notify()、notifyAll()

Java多线程的等待/通知机制是基于Object类的wait()方法和notify(), notifyAll()方法来实现的。

• wait()：等待状态（释放锁）

• notify()：随机叫醒一个正在等待的线程

• notifyAll()；叫醒所有正在等待的线程
  比如前面线程A和线程B，线程A现在持有一个锁lock开始执行，它可以使用lock.wait()让自己处于在等待的状态，同时lock释放了。这时，线程B获得了lock这个锁并开始执行，它可以在某一时刻，使用lock.notify()，通知之前持有lock锁并进入等待状态的线程A，说“线程A你不用等了，可以往下执行了”。

   需要注意的是，这个时候线程B并没有释放锁lock，除非线程B这个时候使用lock.wait()释放锁，或者线程B执行结束自行释放锁，线程A才能得到lock锁。
  

线程A和线程B首先打印出自己需要的东西，然后使用notify()方法叫醒另一个正在等待的线程，然后自己使用wait()方法陷入等待并释放lock锁。
简单点说，就是A-B-A-B-A-B-A-B，谦让和谐的配合~~

代码实现：

public class WaitAndNotify {
    private static Object lock = new Object();

    static class ThreadA implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 5; i++) {
                    try {
                        System.out.println("ThreadA: " + i);
                        lock.notify();
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                lock.notify();
            }
        }
    }

    static class ThreadB implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 5; i++) {
                    try {
                        System.out.println("ThreadB: " + i);
                        lock.notify();
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                lock.notify();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new Thread(new ThreadA()).start();
        Thread.sleep(1000);
        new Thread(new ThreadB()).start();
    }
}

// 输出：
ThreadA: 0
ThreadB: 0
ThreadA: 1
ThreadB: 1
ThreadA: 2
ThreadB: 2
ThreadA: 3
ThreadB: 3
ThreadA: 4
ThreadB: 4

信号量volatile

Semaphore：信号量的类
要讲的是一种基于volatile关键字的自己实现的信号量通信
volitile关键字能够保证内存的【可见性】，如果用volitile关键字声明了一个变量，在一个线程里面改变了这个变量的值，那其它线程是立马可见更改后的值的。

我想让线程A输出0，然后线程B输出1，再然后线程A输出2…以此类推。我应该怎样实现呢？
代码：

public class Signal {
    private static volatile int signal = 0;

    static class ThreadA implements Runnable {
        @Override
        public void run() {
            while (signal < 5) {
                if (signal % 2 == 0) {
                    System.out.println("threadA: " + signal);
                    synchronized (this) {
                        signal++;
                    }
                }
            }
        }
    }

    static class ThreadB implements Runnable {
        @Override
        public void run() {
            while (signal < 5) {
                if (signal % 2 == 1) {
                    System.out.println("threadB: " + signal);
                    synchronized (this) {
                        signal = signal + 1;
                    }
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new Thread(new ThreadA()).start();
        Thread.sleep(1000);
        new Thread(new ThreadB()).start();
    }
}

// 输出：
threadA: 0
threadB: 1
threadA: 2
threadB: 3
threadA: 4

步骤：
Step1：声明一个volatile变量signal
Step2：由signal来决定线程A还是线程B执行
Step3：signal在各个线程里的运算需要用synchronized关键字“上锁”。

join()、sleep()

• join()
  解决的问题：主线程早于子线程结束之前结束（主线程创建并启动了子线程，如果子线程中需要进行大量的耗时运算）。
  如果主线程想等待子线程执行完毕后，获得子线程中的处理完的某个数据，就要用到join方法了。
  join()底层使用了wait()方法
  代码：

public class Join {
    static class ThreadA implements Runnable {

        @Override
        public void run() {
            try {
                System.out.println("我是子线程，开始运行");
                Thread.sleep(1000);
                System.out.println("我是子线程，运行结束");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new ThreadA());
        thread.start();
        thread.join();
        System.out.println("如果不加join方法，主线程会先结束");
    }
}

• sleep()
  是Thread类的一个静态方法，作用是让线程睡眠一段时间。不会释放锁！！
  Thread.sleep(long)
  Thread.sleep(long, int)

wait()和sleep()的区别

1.wait可以指定时间，也可以不指定；而sleep必须指定时间。
2.wait释放cpu资源，同时释放锁；sleep释放cpu资源，但是不释放锁，所以易死锁。
3.wait必须放在同步块或同步方法中，而sleep可以再任意位置。