脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Java线程通信

Java线程通信详解

 更新时间：2016年10月26日 17:15:39   作者：赵杰A-124  
本篇文章主要介绍了Java线程通信问题，线程通信用来保证线程协调运行，有需要的朋友可以了解一下。

线程通信用来保证线程协调运行，一般在做线程同步的时候才需要考虑线程通信的问题。

1、传统的线程通信

通常利用Objeclt类提供的三个方法：

  1. wait() 导致当前线程等待，并释放该同步监视器的锁定，直到其它线程调用该同步监视器的notify（）或者notifyAll（）方法唤醒线程。
  2. notify（），唤醒在此同步监视器上等待的线程，如果有多个会任意选择一个唤醒
  3. notifyAll（） 唤醒在此同步监视器上等待的所有线程，这些线程通过调度竞争资源后，某个线程获取此同步监视器的锁，然后得以运行。

这三个方法必须由同步监视器对象调用，分为两张情况：

同步方法时，由于同步监视器为this对象，所以可以直接调用这三个方法。

示例如下：

public class SyncMethodThreadCommunication {
  static class DataWrap{
    int data = 0;
    boolean flag = false;
    
    public synchronized void addThreadA(){
      if (flag) {
        try {
          wait();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      } 
      
      data++;
      System.out.println(Thread.currentThread().getName() + " " + data);
      flag = true;
      notify();
    }
    
    public synchronized void addThreadB() {
      if (!flag) {
        try {
          wait();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      } 
      
      data++;
      System.out.println(Thread.currentThread().getName() + " " + data);
      flag = false;
      notify();
    }
  }
  
  static class ThreadA extends Thread {
    private DataWrap data;
    
    public ThreadA(DataWrap dataWrap) {
      this.data = dataWrap;
    }
    
    @Override
    public void run() {
      for (int i = 0; i < 10; i++) {
        data.addThreadA();
      }
    }
  }
  
  static class ThreadB extends Thread {
    private DataWrap data;
    
    public ThreadB(DataWrap dataWrap) {
      this.data = dataWrap;
    }
    
    @Override
    public void run() {
      for (int i = 0; i < 10; i++) {
        data.addThreadB();
      }
    }
  }
  
  public static void main(String[] args) {
    //实现两个线程轮流对数据进行加一操作
    DataWrap dataWrap = new DataWrap();
    
    new ThreadA(dataWrap).start();
    new ThreadB(dataWrap).start();
  }

}

同步代码块时，需要使用监视器对象调用这三个方法。

示例如下：

public class SyncBlockThreadComminication {
  static class DataWrap{
    boolean flag;
    int data;
  }
  
  static class ThreadA extends Thread{
    DataWrap dataWrap;
    
    public ThreadA(DataWrap dataWrap){
      this.dataWrap = dataWrap;
    }
    
    @Override
    public void run() {
      for(int i = 0 ; i < 10; i++) {
        synchronized (dataWrap) {
          if (dataWrap.flag) {
            try {
              dataWrap.wait();
            } catch (InterruptedException e) {
              e.printStackTrace();
            }
          }
          
          dataWrap.data++;
          System.out.println(getName() + " " + dataWrap.data);
          dataWrap.flag = true;
          dataWrap.notify();
        }  
      }
    }
  }
  
  static class ThreadB extends Thread{
    DataWrap dataWrap;
    
    public ThreadB(DataWrap dataWrap){
      this.dataWrap = dataWrap;
    }
    
    @Override
    public void run() {
      for (int i = 0; i < 10; i++) {
          synchronized (dataWrap) {
            if (!dataWrap.flag) {
              try {
                dataWrap.wait();
              } catch (InterruptedException e) {
                e.printStackTrace();
              }
            }
            
            dataWrap.data++;
            System.out.println(getName() + " " + dataWrap.data);
            dataWrap.flag = false;
            dataWrap.notify();
          }
        }  
      }
      
  }
  public static void main(String[] args) {
    //实现两个线程轮流对数据进行加一操作
    
    DataWrap dataWrap = new DataWrap();
    new ThreadA(dataWrap).start();
    new ThreadB(dataWrap).start();
  }

}

2、使用Condition控制线程通信

当使用Lock对象保证同步时，则使用Condition对象来保证协调。

示例如下：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import com.sun.media.sound.RIFFInvalidDataException;

import javafx.scene.chart.PieChart.Data;

public class SyncLockThreadCommunication {
  static class DataWrap {
    int data;
    boolean flag;
    
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    
    public void addThreadA() {
      lock.lock();
      try {
        if (flag) {
          try {
            condition.await();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
        
        data++;
        System.out.println(Thread.currentThread().getName() + " " + data);
        flag = true;
        condition.signal();
      } finally {
        lock.unlock();
      }
    }
    
    public void addThreadB() {
      lock.lock();
      try {
        if (!flag) {
          try {
            condition.await();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
        
        data++;
        System.out.println(Thread.currentThread().getName() + " " + data);
        flag = false;
        condition.signal();
      } finally {
        lock.unlock();
      }
    }
  }
  
  static class ThreadA extends Thread{
    DataWrap dataWrap;
    
    public ThreadA(DataWrap dataWrap) {
      this.dataWrap = dataWrap;
    }
    
    @Override
    public void run() {
      for (int i = 0; i < 10; i++) {
        dataWrap.addThreadA();
      }
    }
  }
  
  static class ThreadB extends Thread{
    DataWrap dataWrap;
    
    public ThreadB(DataWrap dataWrap) {
      this.dataWrap = dataWrap;
    }
    
    @Override
    public void run() {
      for (int i = 0; i < 10; i++) {
        dataWrap.addThreadB();
      }
    }
  }
  
  public static void main(String[] args) {
    //实现两个线程轮流对数据进行加一操作
    
    DataWrap dataWrap = new DataWrap();
    new ThreadA(dataWrap).start();
    new ThreadB(dataWrap).start();
  }

}

其中Condition对象的await(), singal(),singalAll()分别对应wait(),notify()和notifyAll()方法。

3、使用阻塞队列BlockingQueue控制线程通信

BlockingQueue是Queue接口的子接口，主要用来做线程通信使用，它具有一个特征：当生产者线程试图向BlockingQueue中放入元素时，如果队列已满，则该线程被阻塞；当消费者线程试图从BlockingQueue中取出元素时，如果队列已空，则该线程被阻塞。这两个特征分别对应两个支持阻塞的方法，put(E e)和take()

示例如下：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class BlockingQueueThreadComminication {
  static class DataWrap{
    int data;
  }
  
  static class ThreadA extends Thread{
    private BlockingQueue<DataWrap> blockingQueue;
    
    public ThreadA(BlockingQueue<DataWrap> blockingQueue, String name) {
      super(name);
      this.blockingQueue = blockingQueue;
    }
    
    @Override
    public void run() {
      for (int i = 0; i < 100; i++) {
        try {
          DataWrap dataWrap = blockingQueue.take();
          
          dataWrap.data++;
          System.out.println(getName() + " " + dataWrap.data);
          sleep(1000);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }
  }
  
  static class ThreadB extends Thread{
    private BlockingQueue<DataWrap> blockingQueue;
    private DataWrap dataWrap;
    
    public ThreadB(BlockingQueue<DataWrap> blockingQueue, DataWrap dataWrap, String name) {
      super(name);
      this.blockingQueue = blockingQueue;
      this.dataWrap = dataWrap;
    }
    
    @Override
    public void run() {
      for (int i = 0; i < 100; i++) {
        try {
          dataWrap.data++;
          System.out.println(getName() + " " + dataWrap.data);
          blockingQueue.put(dataWrap);
          sleep(1000);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }
  }
  
  public static void main(String[] args) {
    ///实现两个线程轮流对数据进行加一操作
    
    DataWrap dataWrap = new DataWrap();
    BlockingQueue<DataWrap> blockingQueue = new ArrayBlockingQueue<>(1);
    
    new ThreadA(blockingQueue, "Consumer").start();
    new ThreadB(blockingQueue, dataWrap, "Producer").start();
  }

}

BlockingQueue共有五个实现类：

ArrayBlockingQueue 基于数组实现的BlockingQueue队列

LinkedBlockingQueue 基于链表实现的BlockingQueue队列

PriorityBlockingQueue 中元素需实现Comparable接口，其中元素的排序是按照Comparator进行的定制排序。

SynchronousQueue 同步队列，要求对该队列的存取操作必须是交替进行。

DelayQueue 集合元素必须实现Delay接口，队列中元素排序按照Delay接口方法getDelay()的返回值进行排序。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

相关文章

  • Java中的动态绑定机制

    Java中的动态绑定机制

    这篇文章主要介绍了Java中的动态绑定机制，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2023-06-06
  • 浅谈java中静态方法的重写问题详解

    浅谈java中静态方法的重写问题详解

    本篇文章是对java中静态方法的重写问题进行了详细的分析介绍，需要的朋友参考下
    2013-06-06
  • Mybatis-plus和Mybatis出现版本不兼容的问题解决

    Mybatis-plus和Mybatis出现版本不兼容的问题解决

    MyBatis-Plus 与 MyBatis 之间的兼容性问题通常是由于版本不匹配引起的,本文主要介绍了Mybatis-plus和Mybatis出现版本不兼容的问题解决,具有一定的参考价值,感兴趣的可以了解一下
    2024-08-08
  • Spring 事务事件监控及实现原理解析

    Spring 事务事件监控及实现原理解析

    本文首先会使用实例进行讲解Spring事务事件是如何使用的，然后会讲解这种使用方式的实现原理。感兴趣的朋友跟随小编一起看看吧
    2018-09-09
  • Java如何通过反射机制获取数据类对象的属性及方法

    Java如何通过反射机制获取数据类对象的属性及方法

    文章介绍了如何使用Java反射机制获取类对象的所有属性及其对应的get、set方法,以及如何通过反射机制实现类对象的实例化,感兴趣的朋友跟随小编一起看看吧
    2025-01-01
  • Java实现SMS短信通发送手机验证码案例讲解

    Java实现SMS短信通发送手机验证码案例讲解

    这篇文章主要介绍了Java实现SMS短信通发送手机验证码案例讲解,本篇文章通过简要的案例,讲解了该项技术的了解与使用,以下就是详细内容,需要的朋友可以参考下
    2021-08-08
  • Spring Boot集成MinIO对象存储服务器操作步骤

    Spring Boot集成MinIO对象存储服务器操作步骤

    通过Spring Boot集成MinIO,你可以在应用中方便地进行文件的存储和管理,本文给大家分享Spring Boot集成MinIO对象存储服务器详细操作步骤,感兴趣的朋友一起看看吧
    2024-01-01
  • 如何在JAVA中使用Synchronized

    如何在JAVA中使用Synchronized

    这篇文章主要介绍了如何在JAVA中使用Synchronized，文中代码非常详细，对大家的学习有所帮助，感兴趣的朋友可以参考下
    2020-06-06
  • SpringBoot集成内存数据库Derby的实践

    SpringBoot集成内存数据库Derby的实践

    像H2、hsqldb、derby、sqlite这样的内存数据库，小巧可爱，做小型服务端演示程序，非常好用。最大特点就是不需要你另外安装一个数据库。本文主要介绍了SpringBoot集成内存数据库Derby，感兴趣的可以了解一下
    2021-09-09
  • Mybatis-Plus中Mapper的接口文件与xml文件相关的坑记录

    Mybatis-Plus中Mapper的接口文件与xml文件相关的坑记录

    这篇文章主要介绍了Mybatis-Plus中Mapper的接口文件与xml文件相关的坑记录,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2024-01-01

最新评论