线程间通信

1 Java经典的等待/通知机制

在java中的等待通知机制就是，一个线程让其他线程从wait方法返回。
前提：wait会释放锁
相关方法：使用时要首先获得相关锁

方法名称	说明
wait()	使线程进入WAITING状态，只有等待另外线程的通知或被中断才会返回
wait(long)	等待超过一定时间，没有通知就返回
notify()	通知一个在对象上等待的线程，使其从wait方法返回，返回前提该线程获取到了对象锁
notify()	通知所有等待在该对象上的线程

public class ThreadOne {

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

    public static void main(String[] args) throws InterruptedException {
        Wait wait = new Wait();
        Notify notify = new Notify();
        new Thread(wait, "wait").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(notify, "notify").start();
    }

    static class Wait implements Runnable {

        public void run() {
            synchronized (lock) {
                while (flag) {
                    try {
                        System.out.println(Thread.currentThread().getName() + " flag is true");
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + " flag is false");
            }
        }
    }

    static class Notify implements Runnable {

        public void run() {
            synchronized (lock) {
                while (flag) {
                    System.out.println(Thread.currentThread().getName() + " flag is true"
                            + System.currentTimeMillis());
                    lock.notify();
                    flag = false;

                    System.out.println(Thread.currentThread().getName() + " flag is false");
                }
            }
        }
    }
}

1. wait线程在调用wait方法后，线程进入WAITING状态，会释放锁。
2. wait线程释放锁之后，Notify线程就会获得锁，继续执行调用兑现的notify方法。
3. 这里注意，wait和notify都是在锁的基础上执行的，所以有锁的代码块执行顺序是不变的，当notify线程中synchronized代码块完全执行完，释放线程锁的时候，线程wait才能获得锁，Wait线程的wait方法才返回。并不是notify方法一调用wait方法就返回。

2 ThreadLocal

ThreadLocal是一个线程变量，以ThreadLocal为键，以任意对象为值。这个结构附带在线程上，也就是说，多个线程使用同一个ThreadLocal变量，每个线程中的值是不一样的。Threadlocal变量提供set/get方法来设置和获取值。

public class ThreadOne implements Runnable {


    private ThreadLocal time = new ThreadLocal(){
        @Override
        protected String initialValue() {  
//如果没有先调用set方法，则调用get方法时会进行函数调用，初始化ThreadLocal变量
            return "";
        }
    };

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


    public void run() {
        time.set(Thread.currentThread().getName());
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(time.get() + " ");

    }
}

上面例子和以前的例子只是稍有不同，但却可以实现，每个线程都保存一份Threadlocal变量，而不会出现线程安全，这就是Threadlocal变量的使用。