Java线程通信详解

2024-11-27 01:55:28

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

1、传统的线程通信

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

wait() 导致当前线程等待，并释放该同步监视器的锁定，直到其它线程调用该同步监视器的notify（）或者notifyAll（）方法唤醒线程。
notify（），唤醒在此同步监视器上等待的线程，如果有多个会任意选择一个唤醒
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线程同步当两个或两个以上的线程需要共享资源,它们需要某种方法来确定资源在某一刻仅被一个线程占用.达到此目的的过程叫做同步(synchronization).像你所看到的,Java为此提供了独特的,语言水平上的支持. 同步的关键是管程(也叫信号量semaphore)的概念.管程是一个互斥独占锁定的对象,或称互斥体(mutex).在给定的时间,仅有一个线程可以获得管程.当一个线程需要锁定,它必须进入管程.所有其他的试图进入已经锁定的管程的线程必须挂起直到第一个线程退出管程.这些其他的线程被
java多线程实现服务器端与多客户端之间的通信

用java语言构建一个网络服务器,实现客户端和服务器之间通信,实现客户端拥有独立线程,互不干扰. 应用多线程来实现服务器与多线程之间的通信的基本步骤服务器端创建ServerSocket,循环调用accept()等待客户端链接客户端创建一个Socket并请求和服务器端链接服务器端接受客户端请求,创建socekt与该客户端建立专线链接建立链接的socket在一个单独的线程上对话服务器继续等待新的链接服务器端Server.java package test.concurrent.socke
java 多线程-线程通信实例讲解

线程通信的目标是使线程间能够互相发送信号.另一方面,线程通信使线程能够等待其他线程的信号. 通过共享对象通信忙等待 wait(),notify()和 notifyAll() 丢失的信号假唤醒多线程等待相同信号不要对常量字符串或全局对象调用 wait() 通过共享对象通信线程间发送信号的一个简单方式是在共享对象的变量里设置信号值.线程 A 在一个同步块里设置 boolean 型成员变量 hasDataToProcess 为 true,线程 B 也在同步块里读取 hasDataToProc
Java Web项目中使用Socket通信多线程、长连接的方法

很多时候在javaweb项目中我们需要用到Socket通信来实现功能,在web中使用Socket我们需要建立一个监听程序,在程序启动时,启动socket监听.我们的应用场景是在java项目中,需要外接如一个硬件设备,通过tcp通信,获取设备传上来的数据,并对数据做回应. 先看一下web的监听代码: import javax.servlet.ServletContextEvent; import javax.servlet.ServletContextListener; public class
深入理解JAVA多线程之线程间的通信方式

一,介绍本总结我对于JAVA多线程中线程之间的通信方式的理解,主要以代码结合文字的方式来讨论线程间的通信,故摘抄了书中的一些示例代码. 二,线程间的通信方式 ①同步这里讲的同步是指多个线程通过synchronized关键字这种方式来实现线程间的通信. 参考示例: public class MyObject { synchronized public void methodA() { //do something.... } synchronized public void methodB()
浅析Java中如何实现线程之间通信

正常情况下,每个子线程完成各自的任务就可以结束了.不过有的时候,我们希望多个线程协同工作来完成某个任务,这时就涉及到了线程间通信了. 本文涉及到的知识点:thread.join(), object.wait(), object.notify(), CountdownLatch, CyclicBarrier, FutureTask, Callable 等. 下面我从几个例子作为切入点来讲解下 Java 里有哪些方法来实现线程间通信. 如何让两个线程依次执行? 那如何让两个线程按照指定方式有序交叉运
举例讲解Java中Piped管道输入输出流的线程通信控制

PipedOutputStream和PipedInputStream 在java中,PipedOutputStream和PipedInputStream分别是管道输出流和管道输入流. 它们的作用是让多线程可以通过管道进行线程间的通讯.在使用管道通信时,必须将PipedOutputStream和PipedInputStream配套使用. 使用管道通信时,大致的流程是:我们在线程A中向PipedOutputStream中写入数据,这些数据会自动的发送到与PipedOutputStream对应的Pip
Java线程间的通信方式详解

本总结我对于JAVA多线程中线程之间的通信方式的理解,主要以代码结合文字的方式来讨论线程间的通信,故摘抄了书中的一些示例代码,具体内容如下 ①同步这里讲的同步是指多个线程通过synchronized关键字这种方式来实现线程间的通信. 参考示例: public class MyObject { synchronized public void methodA() { //do something.... } synchronized public void methodB() { //do so
详谈java线程与线程、进程与进程间通信

线程与线程间通信一.基本概念以及线程与进程之间的区别联系: 关于进程和线程,首先从定义上理解就有所不同 1.进程是什么? 是具有一定独立功能的程序.它是系统进行资源分配和调度的一个独立单位,重点在系统调度和单独的单位,也就是说进程是可以独立运行的一段程序. 2.线程又是什么? 线程进程的一个实体,是CPU调度和分派的基本单位,他是比进程更小的能独立运行的基本单位,线程自己基本上不拥有系统资源. 在运行时,只是暂用一些计数器.寄存器和栈 . 他们之间的关系 1.一个线程只能属于一个进程,而一个
Java通过wait()和notifyAll()方法实现线程间通信

本文实例为大家分享了Java实现线程间通信的具体代码,供大家参考,具体内容如下 Java代码(使用了2个内部类): package Threads; import java.util.LinkedList; /** * Created by Frank */ public class ProdCons { protected LinkedList<Object> list = new LinkedList<>(); protected int max; protected bool

Java线程通信详解

相关推荐

随机推荐