线程的通信和封闭

线程的通信和封闭

1.线程通信的方式

1.1实现方式

要想实现线程之间的协同, 如: 线程先后执行顺序, 获取某个线程的执行结果等, 涉及线程之间的相互通信, 分为下面四类:

  1. 文件共享
  2. 网络共享
  3. 变量共享
  4. JDK提供的线程协调API 细分为:suspend/resume, wait/notify, park/unpark

文件共享
在这里插入图片描述
变量共享
在这里插入图片描述
线程协作 - JDK API
在这里插入图片描述

1.2 API介绍

wait/notify机制

这些方法只能由同一对象锁的线程持有者调用,也就是写在同步代码块里面, 否则会抛出IllegalMonitorStateException异常。
wait方法导致当前线程等待, 加入该对象的等待集合中, 并且放弃当前持有的对象锁
notify/notifyAll唤醒一个/所有正在等待这个对象锁的线程。
注意: 虽然wait会自动解锁, 但对顺序有要求, 如果在notify被调用之后, 才开始wait方法的调用, 线程会永远处于WAINTING状态。
代码示例:

/** 正常的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/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方法为指定线程提供“许可”。 不要求park和unpark方法的调用顺序。 多次调用unpark后再调用park, 线程会直接运行, 但不会叠加, 也就是说, 连续多次调用park方法, 第一次会拿到“许可”直接运行, 后续调用会进入等待。
注意: park/unpark 对调用顺序没有要求, 但是并不会释放锁。
代码示例:

/** 正常的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、通知消费者");
      }

suspend和resume(已被弃用)
调用suspend挂起目标线程, 通过resume可以恢复线程执行, 对调用顺序有要求,也要开发者自己注意锁的释放。这个被弃用的API, 容易死锁,也容易导致永久挂起。
代码示例:

/** 正常的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、通知消费者");
  }

/** 先执行resume再执行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();
  }

伪唤醒
之前代码中用if语句来判断是否进入等待是错误的
官方建议应该在循环中检查条件,原因是处于等待状态的线程可能会收到错误警报和伪唤醒, 如果不在循环中检查等待条件, 程序就会在没有满足结束条件的情况下退出
伪唤醒 :指线程并非因为notify, notifyAll, unpark等API调用而唤醒, 是更底层的原因导致的。

2.线程封闭

多线程访问共享可变数据时,并不是所有的时候,都要用到共享数据, 所以线程封闭的概念就提了出来。
线程封闭就是指数据都封闭在各自的线程之中, 不需要同步的技术。
线程封闭的具体的实现主要有ThreadLocal和局部变量
在这里插入图片描述
代码示例:

/** 线程封闭示例 */
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

栈封闭

局部变量的固有属性之一就是封闭在线程中
它们位于执行线程的栈中, 其他线程无法访问这个栈

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值