线程通信

是Nicole呀
142 阅读5分钟

这是我参与11月更文挑战的第17天，活动详情查看：2021最后一次更文挑战

通信的方式

  1. 文件共享

  2. 网络共享

  3. 共享变量

  4. jdk提供的线程协调API 细分为 suspend/resume（弃用） 、wait/notify、park/unpark  JDK中对于需要多线程协作完成某一任务的场景，提供了对应API支持。多线程协作的典型场景是：生产者-消费者模型（线程阻塞，线程唤醒）

三种通信方式实现场景

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

被弃用的suspend和resume

作用：调用suspend挂起目标线程，通过resume可以恢复线程执行。被弃用的主要原因是，容易写出死锁的代码。所以用wait/notify和park/unpark机制对它进行替代。

    public void demo1() throws InterruptedException {
        Thread myThread =  new Thread(()->{
            if(baozidian == null){
                System.out.println("没买到包子，等待");
                Thread.currentThread().suspend();
            }
            System.out.println("买到包子回家");
        });
        myThread.start();
        // 3秒之后，生产一个包子
        Thread.sleep(3000L);
        baozidian = new Object();
        myThread.resume();
        System.out.println("通知消费者");
    }
//控制台输出
没买到包子，等待
通知消费者
买到包子回家

suspend和resume死锁示例

  1. 同步代码中使用

       public void demo2() throws InterruptedException {
        Thread myThread =  new Thread(()->{
            if(baozidian == null){
                System.out.println("没买到包子，等待");
                synchronized (this){
                    Thread.currentThread().suspend();
                }
            }
            System.out.println("买到包子回家");
        });
        myThread.start();
        // 3秒之后，生产一个包子
        Thread.sleep(3000L);
        baozidian = new Object();
        synchronized (this){
            myThread.resume();
        }
        System.out.println("通知消费者");
    }
//控制台输出
没买到包子，等待

  2. suspend比resume后执行,导致程序永久挂起

    public void demo3() throws InterruptedException {
    Thread myThread =  new Thread(()->{
        if(baozidian == null){
            System.out.println("没买到包子，等待");
	try { // 为这个线程加上一点延时
	    Thread.sleep(5000L);
	} catch (InterruptedException e) {
	    e.printStackTrace();
	}
                Thread.currentThread().suspend();
            }
        }
        System.out.println("买到包子回家");
    });
    myThread.start();
    // 3秒之后，生产一个包子
    Thread.sleep(3000L);
    baozidian = new Object();
    myThread.resume();
    System.out.println("通知消费者");
}

    //控制台输出 没买到包子，等待 通知消费者

wait/notify 机制

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

 public void demo4() throws InterruptedException {
        Thread myThread =  new Thread(()->{
            if(baozidian == null){
                System.out.println("没买到包子，等待");
                try {
                    Thread.currentThread().wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("买到包子回家");
        });
        myThread.start();
        // 3秒之后，生产一个包子
        Thread.sleep(3000L);
        baozidian = new Object();
        myThread.notify();
        System.out.println("通知消费者");
    }
//控制台输出
没买到包子，等待
Exception in thread "Thread-0" java.lang.IllegalMonitorStateException
	at java.lang.Object.wait(Native Method)
	at java.lang.Object.wait(Object.java:502)
	at Demo3.lambda$demo1$0(Demo3.java:19)
	at java.lang.Thread.run(Thread.java:745)

wait方法导致当前线程等待，加入该对象的等待集合中，并且放弃当前持有的对象锁。notify/notifyAll方法唤醒一个或所有正在等待这个对象锁的线程。

    public void demo5() throws InterruptedException {
        Thread myThread =  new Thread(()->{
            if(baozidian == null){
                System.out.println("没买到包子，等待");
                synchronized (this){
                    try {
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            System.out.println("买到包子回家");
        });
        myThread.start();
        // 3秒之后，生产一个包子
        Thread.sleep(3000L);
        baozidian = new Object();
        synchronized (this){
            this.notify();
        }
        System.out.println("通知消费者");
    }
//控制台输出
没买到包子，等待
通知消费者
买到包子回家

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

park/unpark机制

线程调用park则等待“许可”，unpark方法为指定线程提供 “许可（permit）”

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

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

伪唤醒

警告！之前代码中用if语句来判断，是否进行等待状态，是错误的！官方建议应该在循环中检查等待条件，原因是处于等待状态的线程可能会受到错误警报和伪唤醒，如果不在循环中检查等待条件，程序就会在没有满足结束条件的情况下退出 。

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

//错误做法
 if(baozidian == null){
    //后续操作
 }

//正确做法 while(baozidian == null){    //后续操作 }

线程封闭概念

多线程访问共享可变数据时，涉及到线程间数据同步的问题，并不是所有时候，都要用到共享数据，所以线程封闭概念就提出来了。

数据都被封闭在各自的线程之中，就不需要同步，这种通过将数据封闭在线程中而避免使用同步的技术成为线程封闭。

线程封闭具体的体现有：ThreadLocal、局部变量

ThreadLocal

ThreadLocal是Java里一种特殊的变量

它是一个线程级别变量，每个线程都有一个ThreadLoacl就是每个线程都拥有了自己独立的一个变量。竞争条件被彻底消除了，在并发模式下是绝对安全的变量。

用法：ThreadLocal var = new ThreadLocal();

会自动在每一个线程上创建一个T的副本，副本之间彼此独立，互不影响。可以用ThreadLoacl存储一些参数，以便在线程中多个方法中使用，用来代替方法传参的做法。

/** 线程封闭示例 */
public class Demo6 {
	/** threadLocal变量，每个线程都有一个副本，互不干扰 */
	public static ThreadLocal<String> value = new ThreadLocal<>();

	/**
	 * threadlocal测试
	 * 
	 * @throws Exception
	 */
	public void threadLocalTest() throws Exception {

		// threadlocal线程封闭示例
		value.set("这是主线程设置的123"); // 主线程设置值
		String v = value.get();
		System.out.println("线程1执行之前，主线程取到的值：" + v);

		new Thread(new Runnable() {
			@Override
			public void run() {
				String v = value.get();
				System.out.println("线程1取到的值：" + v);
				// 设置 threadLocal
				value.set("这是线程1设置的456");

				v = value.get();
				System.out.println("重新设置之后，线程1取到的值：" + v);
				System.out.println("线程1执行结束");
			}
		}).start();

		Thread.sleep(5000L); // 等待所有线程执行结束

		v = value.get();
		System.out.println("线程1执行之后，主线程取到的值：" + v);

	}

	public static void main(String[] args) throws Exception {
		new Demo6().threadLocalTest();
	}
}

//控制台输出
线程1执行之前，主线程取到的值：这是主线程设置的123
线程1取到的值：null
重新设置之后，线程1取到的值：这是线程1设置的456
线程1执行结束
线程1执行之后，主线程取到的值：这是主线程设置的123

实在难以理解的，可以理解为，JVM维护了一个Map<Thread, T>每个线程要用这个T的时候，用当前的线程去Map里面取。仅作为一个概念理解。

栈封闭

局部变量的固有属性之一就是封闭在线程中。

它们位于执行线程的栈中，其他线程无法访问这个栈。

avatar
文章
阅读
粉丝