亚洲乱码中文字幕综合,中国熟女仑乱hd,亚洲精品乱拍国产一区二区三区,一本大道卡一卡二卡三乱码全集资源,又粗又黄又硬又爽的免费视频

Java線程通信詳解

 更新時間：2016年10月26日 17:15:39   作者：趙杰A-124  
本篇文章主要介紹了Java線程通信問題，線程通信用來保證線程協(xié)調運行，有需要的朋友可以了解一下。

線程通信用來保證線程協(xié)調運行，一般在做線程同步的時候才需要考慮線程通信的問題。

1、傳統(tǒng)的線程通信

通常利用Objeclt類提供的三個方法：

  1. wait() 導致當前線程等待，并釋放該同步監(jiān)視器的鎖定，直到其它線程調用該同步監(jiān)視器的notify（）或者notifyAll（）方法喚醒線程。
  2. notify（），喚醒在此同步監(jiān)視器上等待的線程，如果有多個會任意選擇一個喚醒
  3. notifyAll（） 喚醒在此同步監(jiān)視器上等待的所有線程，這些線程通過調度競爭資源后，某個線程獲取此同步監(jiān)視器的鎖，然后得以運行。

這三個方法必須由同步監(jiān)視器對象調用，分為兩張情況：

同步方法時，由于同步監(jiān)視器為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();
  }

}

同步代碼塊時，需要使用監(jiān)視器對象調用這三個方法。

示例如下：

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對象來保證協(xié)調。

示例如下：

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基礎之方法詳解,文中有非常詳細的代碼示例,對正在學習java基礎的小伙伴們有非常好的幫助,需要的朋友可以參考下
    2021-07-07
  • 那些年用httpclient時踩過的一些坑

    那些年用httpclient時踩過的一些坑

    這篇文章主要給大家介紹了關于那些年用httpclient時踩過的一些坑，文中通過示例代碼介紹的非常詳細，對大家學習或者使用httpclient具有一定的參考學習價值，需要的朋友們下面來一起學習學習吧
    2019-05-05
  • mybatis創(chuàng)建項目報Invalid?bound?statement?(not?found)錯誤解決方法

    mybatis創(chuàng)建項目報Invalid?bound?statement?(not?found)錯誤解決方法

    使用MyBatis能夠幫助我們將SQL語句和Java代碼分離,這篇文章主要給大家介紹了關于mybatis創(chuàng)建項目報Invalid?bound?statement?(not?found)錯誤的解決方法,文中通過實例代碼介紹的非常詳細,需要的朋友可以參考下
    2023-05-05
  • springboot啟動時運行代碼詳解

    springboot啟動時運行代碼詳解

    在本篇內容中我們給大家整理了關于在springboot啟動時運行代碼的詳細圖文步驟以及需要注意的地方講解，有興趣的朋友們學習下。
    2019-06-06
  • java URL 獲取PHP JSON 數據

    java URL 獲取PHP JSON 數據

    這篇文章主要介紹了java URL 獲取PHP JSON 數據,需要的朋友可以參考下
    2016-04-04
  • Java8如何從一個Stream中過濾null值

    Java8如何從一個Stream中過濾null值

    這篇文章主要介紹了Java8如何從一個Stream中過濾null值，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教
    2022-05-05
  • SystemServer進程啟動過程解析

    SystemServer進程啟動過程解析

    這篇文章主要為大家介紹了SystemServer進程啟動過程解析，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪
    2023-07-07
  • 一文快速掌握Spring?Cloud?Stream

    一文快速掌握Spring?Cloud?Stream

    這篇文章主要介紹了Spring?Cloud?Stream詳解,本篇文章所涉及到的demo練習使用的cloud?2021.0.3+?springboot2.6.8，通過實例代碼給大家介紹的非常詳細，需要的朋友可以參考下
    2022-08-08
  • java實用小技巧之判斷l(xiāng)ist是否有重復項簡單例子

    java實用小技巧之判斷l(xiāng)ist是否有重復項簡單例子

    這篇文章主要給大家介紹了關于java實用小技巧之判斷l(xiāng)ist是否有重復項的相關資料,在開發(fā)工作中我們有時需要去判斷List集合中是否含有重復的元素,需要的朋友可以參考下
    2023-10-10
  • 淺析Java語言中狀態(tài)模式的優(yōu)點

    淺析Java語言中狀態(tài)模式的優(yōu)點

    狀態(tài)模式允許對象在內部狀態(tài)改變時改變它的行為，對象看起來好像修改了它的類。這個模式將狀態(tài)封裝成獨立的類，并將動作委托到 代表當前狀態(tài)的對象，我們知道行為會隨著內部狀態(tài)而改變
    2023-02-02

最新評論