线程间的通信

1.wait/notify机制原理

　　持有相同锁的线程才可以实现wait/notify机制。

　　wait()方法是Object类的方法，它的作用是使当前执行wait()方法的线程等待，在wait()所在的代码行处暂停执行，并释放锁，直到接到通知或被中断为止，在调用wait()之前，线程必须获得该对象的对象级别锁，即只能在同步方法或同步块中调用wait()方法。通过通知机制使某个线程继续执行wait()方法后面的代码时，对线程的选择是按照执行wait()方法的顺序确定的，并需要重新获得锁。如果调用wait()时没有持有适当的锁，则抛出IllegalMonitorStateException，它是RuntimeException的一个子类，因此不需要try-catch语句捕捉异常。

　　notify()方法要在同步方法或同步块中调用，即在调用前，线程必须获得锁，如果调用notify()时没有持有适当的锁，则会抛出IllegalMonitorStateException。该方法用来通知那些可能等待该锁的其他线程，如果有多个线程等待，则按照执行wait()方法的顺序对处于wait状态的线程发出一次通知（notify），并使该线程重新获得锁。注意，执行notify()方法后，当前线程不会马上释放该锁，呈wait状态的线程也并不能马上获取该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出synchronized同步区域后，当前线程才会释放锁，而呈wait状态的线程才可以获得该对象锁。当第一个获得了该对象锁的wait线程运行完毕后，它会释放该对象锁，此时如果没有再次使用notify语句，那么其他呈wait状态的线程因为没有得到通知，会继续处于wait状态。

　　总结：wait()方法使线程暂停运行，而notify()方法通知暂停的线程继续运行。

//实现wait/notify机制
public class Service {
    public Object lock = new Object();

    public static void printA(Object lock) {
        try {
            synchronized (lock) {
                System.out.println("开始  wait time=" + System.currentTimeMillis());
                lock.wait();
                System.out.println("结束  wait time=" + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void printB(Object lock) {
        synchronized (lock) {
            System.out.println("开始  notify time=" + System.currentTimeMillis());
            lock.notify();
            System.out.println("结束  notify time=" + System.currentTimeMillis());
        }

    }
}

public class ThreadA extends Thread{
    private Service service;
    public ThreadA(Service service){
        super();
        this.service = service;
    }

    @Override
    public void run() {
        Object lock = service.lock;
        service.printA(lock);
    }
}

public class ThreadB extends Thread{
    private Service service;
    public ThreadB(Service service){
        super();
        this.service = service;
    }

    @Override
    public void run() {
        Object lock = service.lock;
        service.printB(lock);
    }
}

public class Run {

    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();
        ThreadA t1 = new ThreadA(service);
        t1.start();
        Thread.sleep(3000);
        ThreadB t2 = new ThreadB(service);
        t2.start();
    }
}

//运行结果如下：
开始  wait time=1619757440583
开始  notify time=1619757443606
结束  notify time=1619757443606
结束  wait time=1619757443606

2. 几个常用方法的区别

wait()方法立即释放锁；当线程调用wait()方法后，再对该线程对象执行interrupt()方法会出现InterruptedException异常。
sleep()方法不释放锁；
notify()方法不立即释放锁，必须执行完notify()方法所在的同步synchronized代码块后才释放锁，且按照执行wait()方法的顺序唤醒其他线程。每调用一次notify()方法，只通知一个线程进行唤醒。
在执行同步代码块的过程中，遇到异常而导致线程终止，锁也会被释放。
notifyAll()方法可以唤醒全部线程，且会按照wait()方法的倒序依次对其他线程进行唤醒。
wait(long)：等待某一时间内是否有线程对锁进行notify()通知唤醒，如果超过这个时间则线程自动唤醒，能继续向下运行的前提是再次持有锁。

　　此外，注意，唤醒的顺序是正序、倒序、随机，取决于具体的JVM实现，不是所有的JVM在执行notify()时都是按调用wait()方法的正序进行唤醒的，也不是所有的JVM在执行notifyAll()时都是按调用wait()方法的倒序进行唤醒的，具体的唤醒顺序依赖于JVM的具体实现。

3. join()方法的使用

　　在很多情况下，主线程创建并启动子线程，如果子线程要进行大量的耗时运算，主线程往往将早于子线程结束之前结束，这时如果主线程想等待子线程执行完成之后再结束，例如，当子线程处理一个数据，主线程要取得这个数据中的值时，就要用到join()方法了，join()方法的作用是等待线程对象摧毁。

public class MyThread extends Thread{
    @Override
    public void run() {
        try {
            int secondValue = (int) (Math.random() * 10000);
            System.out.println(secondValue);
            Thread.sleep(secondValue);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

public class Test {
    public static void main(String[] args) {
        try {
            MyThread myThread = new MyThread();
            myThread.start();
            myThread.join();
            System.out.println("myThread执行完毕后，我才执行");
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

//运行结果如下：
5864
myThread执行完毕后，我才执行

　　join()方法的作用是使所属的线程对象x正常执行run()方法中的任务，而使当前线程z进行无限期的阻塞，等待线程x销毁后再继续执行线程z后面的代码，具有串行执行的效果。

　　join()方法具有使线程排队运行的效果，有些类似同步的运行效果，但是join()方法与synchronized的区别是join()方法在内部使用wait()方法进行等待，而synchronized关键字使用锁作为同步。

　　在使用join()方法的过程中，如果当前线程对象被中断，则当前线程出现异常。

　　x.join(long)方法中的参数用于设定等待的时间，不管x线程是否执行完毕，时间到了并且重新获得了锁，则当前进程会继续向后运行。如果没有重新获得锁，则一直在尝试，直到获得锁为止。

4. ThreadLocal的使用

　　类ThreadLocal的主要作用是将数据放入当前线程对象中的Map中，这个Map是Thread类的实例变量。类ThreadLocal自己不管理、不存储任何数据，它只是数据和Map之间的桥梁，用于将数据放入Map中。执行后每个线程中的Map存有自己的数据，Map中的key存储的是ThreadLocal对象，value就是存储的值。每个Thread中的Map值只对当前线程可见，其他线程不可以访问当前线程中Map的值。当前线程销毁，Map随之销毁，Map的数据如果没有被引用、没有被使用，则随时GC收回。

5. 类InheritableThreadLocal的使用

　　使用InheritableThreadLocal可使子线程继承父线程的值。

　　子线程将父线程中的table对象以复制的方式赋值给子线程的table数组，这个过程是在创建Thread类对象时发生的，也就说明当子线程对象创建完毕后，子线程中的数据就是主线程中旧的数据，主线程使用新的数据时，子线程还是使用旧的数据，因为主子线程使用两个Entry[]对象数组各自存储自己的值。

//父线程有最新的值，子线程仍是旧值
public class Tools {
    public static InheritableThreadLocal t1 = new InheritableThreadLocal();
}
public class ThreadA extends Thread{
    @Override
    public void run() {
        try {
            for (int i = 0;i < 10;i++){
                System.out.println("在ThreadA线程中取值=" + Tools.t1.get());
                Thread.sleep(1000);
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}
public class Run {

    public static void main(String[] args) throws InterruptedException {
       if (Tools.t1.get() == null)
           Tools.t1.set("此值是main线程放入的！");
        System.out.println("    在Main线程中取值=" + Tools.t1.get());
        Thread.sleep(1000);
        ThreadA a = new ThreadA();
        a.start();
        Thread.sleep(5000);
        Tools.t1.set("此值是main线程new放入的！");
        System.out.println("    在Main线程中取值=" + Tools.t1.get());
    }
}
//输出结果如下
    在Main线程中取值=此值是main线程放入的！
在ThreadA线程中取值=此值是main线程放入的！
在ThreadA线程中取值=此值是main线程放入的！
在ThreadA线程中取值=此值是main线程放入的！
在ThreadA线程中取值=此值是main线程放入的！
在ThreadA线程中取值=此值是main线程放入的！
    在Main线程中取值=此值是main线程new放入的！
在ThreadA线程中取值=此值是main线程放入的！
在ThreadA线程中取值=此值是main线程放入的！
在ThreadA线程中取值=此值是main线程放入的！
在ThreadA线程中取值=此值是main线程放入的！
在ThreadA线程中取值=此值是main线程放入的！

posted @ 2021-08-09 23:33 明羽1 阅读(63) 评论(0) 收藏举报

刷新页面返回顶部