线程通信

线程通信

学习材料来源于网络
如有侵权，联系删除

要想实现多个线程之间的协同，如:线程执行先后顺序、获取某个线程执行的结果等等。

涉及到线程之间相互通信，分为下面四类:

• 文件共享
• 网络共享
• 共享变量
• jdk提供的线程协调API

JDK提供的线程线程通信API: suspend()/resume()、wait()/notify()、park()/unpark()。

文件共享

文件共享主要使用文件系统的读写分离机制来实现线程通信。

    public static void main(String args){
        //线程1-写入数据
        new Thread(() ->{try {
            while (true){
                Files.write(Paths.get("Demo7.log"),
                        ("当前时间" + String.valueOf(System.currentTimeMillis())).getBytes());
                Thread.sleep(1000L);
            }
        } catch (Exception e){e.printStackTrace();}
        }).start();
    //线程2-读取数据new 
    new Thread(()->{try {
            while (true){
                Thread.sleep(1000L);
                byte[] allBytes= Files.readAllBytes(Paths.get("Demo7.log"));
                System.out.println(new String(allBytes));
            }
        } catch (Exception e){e.printStackTrace();}
        }).start();
    }

变量共享

//共享变量
public static String content="空";
public static void main(String args){ //线程1-写入数据
    new Thread(()-> {
        try {
            while (true) {
                content = "当前时间" + String.valueOf(System.currentTimeMillis());
                Thread.sleep(1000L);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }).start();
    //线程2-读取数据
    new Thread(() ->{
        try {
            while (true){
                Thread.sleep(1000L);
                System.out.println(content);
            }
        } catch (Exception e){
            e.printStackTrace();
        }
    }).start();
}

JDK线程协作API

JDK中对于需要多线程协作完成某一任务的场景，提供了对应API支持。多线程协作的典型场景是:生产者-消费者模型。(线程阻塞、线程唤醒)

示例:线程1去买包子，没有包子，则不再执行。线程-2生产出包子，通知线程-1继续执行。

suspend()与resume()

示例：

/** 包子店 */
public static Object baozidian = null;

/** 正常的suspend/resume */
public void suspendResumeTest() throws Exception {
    // 启动线程
    Thread consumerThread = new Thread(() -> {
        if (baozidian == null) { // 如果没包子，则进入等待
            System.out.println("1、进入等待");
            Thread.currentThread().suspend();
        }
        System.out.println("2、买到包子，回家");
    });
    consumerThread.start();
    // 3秒之后，生产一个包子
    Thread.sleep(3000L);
    baozidian = new Object();
    consumerThread.resume();
    System.out.println("3、通知消费者");
}

死锁实列：

/** 死锁的suspend/resume。 suspend并不会像wait一样释放锁，故此容易写出死锁代码 */
public void suspendResumeDeadLockTest() throws Exception {
    // 启动线程
    Thread consumerThread = new Thread(() -> {
        if (baozidian == null) { // 如果没包子，则进入等待
            System.out.println("1、进入等待");
            // 当前线程拿到锁，然后挂起
            synchronized (this) {
                Thread.currentThread().suspend();
            }
        }
        System.out.println("2、买到包子，回家");
    });
    consumerThread.start();
    // 3秒之后，生产一个包子
    Thread.sleep(3000L);
    baozidian = new Object();
    // 争取到锁以后，再恢复consumerThread
    synchronized (this) {
        consumerThread.resume();
    }
    System.out.println("3、通知消费者");
}

说明：

消费者拿到当前锁this后，处于挂起状态，其他线程想抢到锁后才能唤醒，这种业务逻辑就会出现死锁情况，因为线程 suspend()的时候是不会释放当前的锁的。

通知的先后顺序也会使得线程进入死锁状态：

/** 导致程序永久挂起的suspend/resume */
public void suspendResumeDeadLockTest2() throws Exception {
    // 启动线程
    Thread consumerThread = new Thread(() -> {
        if (baozidian == null) {
            System.out.println("1、没包子，进入等待");
            try { // 为这个线程加上一点延时
                Thread.sleep(5000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 这里的挂起执行在resume后面
            Thread.currentThread().suspend();
        }
        System.out.println("2、买到包子，回家");
    });
    consumerThread.start();
    // 3秒之后，生产一个包子
    Thread.sleep(3000L);
    baozidian = new Object();
    consumerThread.resume();
    System.out.println("3、通知消费者");
    consumerThread.join();
}

运行结果

consumerThread执行的时候，main线程先处于暂停3秒状态，consumerThread线程判断没有包子，等待5秒，在consumerThread暂停5秒的时候，这个时候在主线程结束暂停后，通知consumerThread线程唤醒，但是consumerThread线程还在暂停时间里面，没有进入休眠，所以不会被唤醒，等consumerThread线程停止5秒时间过后，进入休眠，这个时候main线程已经唤醒过了。所以consumerThread线程会一直处于休眠状态。

wait()与notify()

这些方法只能由同一对象锁的持有者线程调用，也就是写在同步块里面，否则会抛出lllegalMonitorStateException异常。

wait方法导致当前线程等待，加入该对象的等待集合中，并且放弃当前持有的对象锁。

notify/notifyAll方法唤醒一个或所有正在等待这个对象锁的线程。

注意∶虽然会wait自动解锁，但是对顺序有要求，如果在notify被调用之后，才开始wait方法的调用，线程会永远处于WAITING状态。

示例：

 /** 正常的wait/notify */
public void waitNotifyTest() throws Exception {
    // 启动线程
    new Thread(() -> {
        if (baozidian == null) { // 如果没包子，则进入等待
            synchronized (this) {
                try {
                    System.out.println("1、进入等待");
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("2、买到包子，回家");
    }).start();
    // 3秒之后，生产一个包子
    Thread.sleep(3000L);
    baozidian = new Object();
    synchronized (this) {
        this.notifyAll();
        System.out.println("3、通知消费者");
    }
}

需要明白的是使用wait的时候，线程会把锁释放

先后顺序造成死锁的问题

/** 会导致程序永久等待的wait/notify */
public void waitNotifyDeadLockTest() throws Exception {
    // 启动线程
    new Thread(() -> {
        if (baozidian == null) { // 如果没包子，则进入等待
            try {
                Thread.sleep(5000L);
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
            synchronized (this) {
                try {
                    System.out.println("1、进入等待");
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("2、买到包子，回家");
    }).start();
    // 3秒之后，生产一个包子
    Thread.sleep(3000L);
    baozidian = new Object();
    synchronized (this) {
        this.notifyAll();
        System.out.println("3、通知消费者");
    }
}

说明

这种问题的死锁是因为先后调用顺序

park()与unpark()

不要求park和unpark方法的调用顺序。

多次调用unpark之后，再调用park，线程会直接运行。但不会叠加，也就是说，连续多次调用park方法，第一次会拿到“许可”直接运行，后续调用会进入等待。

线程调用park则等待“许可”,unpark方法为指定线程提供“许可(permit)”。

示例：

/** 正常的park/unpark */
public void parkUnparkTest() throws Exception {
    // 启动线程
    Thread consumerThread = new Thread(() -> {
        if (baozidian == null) { // 如果没包子，则进入等待
            System.out.println("1、进入等待");
            LockSupport.park();
        }
        System.out.println("2、买到包子，回家");
    });
    consumerThread.start();
    // 3秒之后，生产一个包子
    Thread.sleep(3000L);
    baozidian = new Object();
    LockSupport.unpark(consumerThread);
    System.out.println("3、通知消费者");
}

运行结果

死锁示例：

/** 死锁的park/unpark */
public void parkUnparkDeadLockTest() throws Exception {
    // 启动线程
    Thread consumerThread = new Thread(() -> {
        if (baozidian == null) { // 如果没包子，则进入等待
            System.out.println("1、进入等待");
            // 当前线程拿到锁，然后挂起
            synchronized (this) {
                LockSupport.park();
            }
        }
        System.out.println("2、买到包子，回家");
    });
    consumerThread.start();
    // 3秒之后，生产一个包子
    Thread.sleep(3000L);
    baozidian = new Object();
    // 争取到锁以后，再恢复consumerThread
    synchronized (this) {
        LockSupport.unpark(consumerThread);
    }
    System.out.println("3、通知消费者");
}

运行结果：

这种死锁的问题是因为线程在park()的时候，不会释放当前的锁。

伪唤醒

警告!之前代码中用if语句来判断，是否进入等待状态，是错误的!

官方建议应该在循环中检查等待条件，原因是处于等待状态的线程可能会收到错误警报和伪唤醒，如果不在循环中检查等待条件，程序就会在没有满足结束条件的情况下退出。

伪唤醒是指线程并非因为notify、notifyall、unpark等api调用而唤醒，是更底层原因导致的。

// wait
synchronized (obj){
    while (<条件判断>){
        obj.wait();
        //执行后续操作
    }
}
// park
while(<条件判断>){
    LockSupport.park();
    //执行后续操作
}