java线程间通讯的一些方法总结

前言

并发编程中，我们可能会遇到这样一个场景

a、b两个线程并行，但是我希望保证b线程在a线程执行完了后再执行

这个时候就需要线程间进行通讯

a执行完了后对b说一声，喂b，我执行完了

来康康用java怎么实现

1、基于synchronized

2、基于reentrantlock

3、基于volatile

4、基于countdownlatch

我目前就知道这四种

1、synchronized+wait() 和 notify()

wait() 和 notify()都是object类的通讯方法，注意一点，wait和 notify必须搭配synchronized使用，并且wait()会释放锁，notify()不会释放锁

public class synchronizedtest {

 //定义个year，用来记录某明星的练习年数
 private static double year;

 public void run() {
  //线程a，练习唱跳rap
  thread threada = new thread(() -> {
   synchronized (this) {
    for (year = 0.5; year <= 5; year += 0.5) {
     system.out.println("蔡徐鸡开始练习唱跳rap：已练习" + year + "年");
     try {
      thread.sleep(288);
     } catch (interruptedexception e) {
      e.printstacktrace();
     }
     //众所周知，练习两年半即可出道
     if (year == 2.5) {
      system.out.println("===========================>成功练习两年半，出道！！！");
      this.notify();
     }
    }
   }
  });
  //线程b，练习打篮球
  thread threadb = new thread(() -> {
   while (true) {
    synchronized (this) {
     try {
      this.wait();
     } catch (interruptedexception e) {
      e.printstacktrace();
     }
     system.out.println("蔡徐鸡开始练习打篮球");
    }
   }
  });
  //注意，一定要先启动b，不然会导致b永远拿不到锁
  threadb.start();
  threada.start();
 }

 public static void main(string[] args) {
  synchronizedtest test = new synchronizedtest();
  test.run();
 }
}

运行结果：

蔡徐鸡开始练习唱跳rap：已练习0.5年
蔡徐鸡开始练习唱跳rap：已练习1.0年
蔡徐鸡开始练习唱跳rap：已练习1.5年
蔡徐鸡开始练习唱跳rap：已练习2.0年
蔡徐鸡开始练习唱跳rap：已练习2.5年
===========================>成功练习两年半，出道！！！
蔡徐鸡开始练习唱跳rap：已练习3.0年
蔡徐鸡开始练习唱跳rap：已练习3.5年
蔡徐鸡开始练习唱跳rap：已练习4.0年
蔡徐鸡开始练习唱跳rap：已练习4.5年
蔡徐鸡开始练习唱跳rap：已练习5.0年
蔡徐鸡开始练习打篮球

注意看运行结果，线程a在执行notify后并没有释放锁，而是执行完当前任务才开始执行线程b的任务

2、基于reentrantlock

reentrantlock也能实现线程间通讯，不过有点麻烦，需要结合reentrantlock的condition

public class locktest {
  //定义个year，用来记录某明星练习打篮球的年数
  private static double year;

  public static void main(string[] args) {
   reentrantlock lock = new reentrantlock();
   condition condition = lock.newcondition();
   //线程a，练习唱跳rap
   thread threada = new thread(() -> {
    //执行业务代码前上锁
    lock.lock();
    for (year = 0.5; year <= 5; year += 0.5) {
     system.out.println("蔡徐鸡开始练习唱跳rap：已练习" + year + "年");
     try {
      thread.sleep(288);
     } catch (interruptedexception e) {
      e.printstacktrace();
     }
     //众所周知，练习两年半即可出道
     if (year == 2.5) {
      system.out.println("===========================>成功练习两年半，出道！！！");
      //唤醒等待中的线程
      condition.signal();
     }
    }
    //业务代码执行完后解锁
    lock.unlock();
   });
   //线程b，练习打篮球
   thread threadb = new thread(() -> {
    //执行业务代码前上锁
    lock.lock();
    while (true) {
     try {
      //让线程等待，如果计数器为0的话，则立即执行
      condition.await();
     } catch (interruptedexception e) {
      e.printstacktrace();
     }
     system.out.println("蔡徐老母鸡开始练习打篮球");
     break;
    }
    //业务代码执行完后解锁
    lock.unlock();
   });
   //注意，一定要先启动b，不然会导致b永远拿不到锁
   threadb.start();
   threada.start();
  }
 }

运行结果：

蔡徐鸡开始练习唱跳rap：已练习0.5年
蔡徐鸡开始练习唱跳rap：已练习1.0年
蔡徐鸡开始练习唱跳rap：已练习1.5年
蔡徐鸡开始练习唱跳rap：已练习2.0年
蔡徐鸡开始练习唱跳rap：已练习2.5年
===========================>成功练习两年半，出道！！！
蔡徐鸡开始练习唱跳rap：已练习3.0年
蔡徐鸡开始练习唱跳rap：已练习3.5年
蔡徐鸡开始练习唱跳rap：已练习4.0年
蔡徐鸡开始练习唱跳rap：已练习4.5年
蔡徐鸡开始练习唱跳rap：已练习5.0年
蔡徐老母鸡开始练习打篮球

效果和synchronized+wait() 和 notify()一样一样的

3、基于volatile

使用共享变量也能实现，用volatile即可，原理就是多个线程共同监听同个变量，根据变量的值变化来执行对应的任务，此处volatile的作用就是让其它线程能即时感知变量值的改变

public class volatiletest {
 //定义一个共享变量，注意，必须用volatile修饰
 static volatile boolean flag = false;
 //定义个year，用来记录某明星练习打篮球的年数
 private static double year;

 public static void main(string[] args) {
  //线程a，练习唱跳rap
  thread threada = new thread(() -> {
   while (true) {
    if (!flag) {
     for (year = 0.5; year <= 5; year += 0.5) {
      system.out.println("蔡徐鸡开始练习唱跳rap：已练习" + year + "年");
      try {
       thread.sleep(288);
      } catch (interruptedexception e) {
       e.printstacktrace();
      }
      //众所周知，练习两年半即可出道
      if (year == 2.5) {
       system.out.println("===========================>成功练习两年半，出道！！！");
       year = 0.5;
       flag = true;
       break;
      }
     }
    }
   }
  });
  //线程b，练习打篮球
  thread threadb = new thread(() -> {
   while (true) {
    if (flag) {
     system.out.println("蔡徐老母鸡开始练习打篮球");
     break;
    }
   }
  });
  //　启动线程
  threada.start();
  threadb.start();
 }
}

运行结果：

蔡徐鸡开始练习唱跳rap：已练习0.5年
蔡徐鸡开始练习唱跳rap：已练习1.0年
蔡徐鸡开始练习唱跳rap：已练习1.5年
蔡徐鸡开始练习唱跳rap：已练习2.0年
蔡徐鸡开始练习唱跳rap：已练习2.5年
===========================>成功练习两年半，出道！！！
蔡徐老母鸡开始练习打篮球

基于countdownlatch

countdownlatch是juc包下的一个并发编程工具，主要有两个方法，countdown和await，countdownlatch底层维护了一个计数器，在实例化的时候设置，当调用countdown方法时，计数器减一，如果计数器在减一前已经为0，那么什么都不会发生，如果减一后变成0，则唤醒所有等待的线程；await方法会使当前线程等待，直到计数器为0

public class countdownlatchtest {
 //定义个year，用来记录某明星练习打篮球的年数
 private static double year;

 public static void main(string[] args) {
  countdownlatch latch = new countdownlatch(1);
  //线程a，练习唱跳rap
  thread threada = new thread(() -> {
   for (year = 0.5; year <= 5; year += 0.5) {
    system.out.println("蔡徐鸡开始练习唱跳rap：已练习" + year + "年");
    try {
     thread.sleep(288);
    } catch (interruptedexception e) {
     e.printstacktrace();
    }
    //众所周知，练习两年半即可出道
    if (year == 2.5) {
     system.out.println("===========================>成功练习两年半，出道！！！");
     //计数器减一
     latch.countdown();
    }
   }
  });
  //线程b，练习打篮球
  thread threadb = new thread(() -> {
   while (true) {
    try {
     //让线程等待，如果计数器为0的话，则立即执行
     latch.await();
    } catch (interruptedexception e) {
     e.printstacktrace();
    }
    system.out.println("蔡徐老母鸡开始练习打篮球");
    break;
   }
  });
  //　启动线程
  threada.start();
  threadb.start();
 }
}

运行结果：

蔡徐鸡开始练习唱跳rap：已练习0.5年
蔡徐鸡开始练习唱跳rap：已练习1.0年
蔡徐鸡开始练习唱跳rap：已练习1.5年
蔡徐鸡开始练习唱跳rap：已练习2.0年
蔡徐鸡开始练习唱跳rap：已练习2.5年
===========================>成功练习两年半，出道！！！
蔡徐鸡开始练习唱跳rap：已练习3.0年
蔡徐老母鸡开始练习打篮球
蔡徐鸡开始练习唱跳rap：已练习3.5年
蔡徐鸡开始练习唱跳rap：已练习4.0年
蔡徐鸡开始练习唱跳rap：已练习4.5年
蔡徐鸡开始练习唱跳rap：已练习5.0年

如果你多运行几次，你会发现线程b执行的时机是随机的，但永远在计数器为0后才开始执行，也就是说计数器为0后，线程a和线程b谁抢到锁就谁执行

文中所有demo都是复制即可运行，大家还是要多动手，家里有条件的都用idea跑一跑，没条件的可以用手抄

总结

到此这篇关于java线程间通讯的文章就介绍到这了,更多相关java线程间通讯内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com！

黄山市民网：https://www.huangshanshimin.com/