2. 程式人生 > >java實現執行緒間通訊的四種方式

java實現執行緒間通訊的四種方式

阿新 • • 發佈：2019-01-31

本文主要針對JAVA多執行緒中執行緒之間的通訊方式進行分析解釋，主要以程式碼結合文字的方式來討論執行緒間的通訊。

synchronized同步

public class MyObject {

    synchronized public void methodA() {
        //do something....
    }

    synchronized public void methodB() {
        //do some other thing
    }
}

public class ThreadA extends Thread {

    private
 
 MyObject object;
//省略構造方法
    @Override
    public void run() {
        super.run();
        object.methodA();
    }
}

public class ThreadB extends Thread {

    private MyObject object;
//省略構造方法
    @Override
    public void run() {
        super.run();
        object.methodB();
    }
}

public class
 
 Run {
    public static void main(String[] args) {
        MyObject object = new MyObject();

        //執行緒A與執行緒B 持有的是同一個物件:object
        ThreadA a = new ThreadA(object);
        ThreadB b = new ThreadB(object);
        a.start();
        b.start();
    }
}

由於執行緒A和執行緒B持有同一個MyObject類的物件object，儘管這兩個執行緒需要呼叫不同的方法，但是它們是同步執行的，比如：執行緒B需要等待執行緒A執行完了methodA()方法之後，它才能執行methodB()方法。這樣，執行緒A和執行緒B就實現了通訊。

這種方式，本質上就是“共享記憶體”式的通訊。多個執行緒需要訪問同一個共享變數，誰拿到了鎖（獲得了訪問許可權），誰就可以執行。

while輪詢

其實就是多執行緒同時執行，會犧牲部分CPU效能。

在這種方式下，執行緒A不斷地改變條件，執行緒ThreadB不停地通過while語句檢測這個條件(list.size()==5)是否成立 ，從而實現了執行緒間的通訊。但是這種方式會浪費CPU資源。之所以說它浪費資源，是因為JVM排程器將CPU交給執行緒B執行時，它沒做啥“有用”的工作，只是在不斷地測試 某個條件是否成立。就類似於現實生活中，某個人一直看著手機螢幕是否有電話來了，而不是： 在幹別的事情，當有電話來時，響鈴通知TA電話來了。

import java.util.ArrayList;
import java.util.List;

public class MyList {

    private List<String> list = new ArrayList<String>();
    public void add() {
        list.add("elements");
    }
    public int size() {
        return list.size();
    }
}

import mylist.MyList;

public class ThreadA extends Thread {

    private MyList list;

    public ThreadA(MyList list) {
        super();
        this.list = list;
    }

    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                list.add();
                System.out.println("添加了" + (i + 1) + "個元素");
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

import mylist.MyList;

public class ThreadB extends Thread {

    private MyList list;

    public ThreadB(MyList list) {
        super();
        this.list = list;
    }

    @Override
    public void run() {
        try {
            while (true) {
                if (list.size() == 5) {
                    System.out.println("==5, 執行緒b準備退出了");
                    throw new InterruptedException();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

import mylist.MyList;
import extthread.ThreadA;
import extthread.ThreadB;

public class Test {

    public static void main(String[] args) {
        MyList service = new MyList();

        ThreadA a = new ThreadA(service);
        a.setName("A");
        a.start();

        ThreadB b = new ThreadB(service);
        b.setName("B");
        b.start();
    }
}

wait/notify機制

public class MyList {
    private static List<String> list = new ArrayList<String>();

    public static void add() {
        list.add("anyString");
    }

    public static int size() {
        return list.size();
    }
}


public class ThreadA extends Thread {

    private Object lock;

    public ThreadA(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            synchronized (lock) {
                if (MyList.size() != 5) {
                    System.out.println("wait begin " + System.currentTimeMillis());
                    lock.wait();
                    System.out.println("Interruption!!!");
                    //lock.wait();
                    lock.notify();
                    lock.wait();
                    System.out.println("wait end  " + System.currentTimeMillis());
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


public class ThreadB extends Thread {

    private Object lock;

    public ThreadB(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            synchronized (lock) {
                for (int i = 0; i < 10; i++) {
                    MyList.add();
                    if (MyList.size() == 5) {
                        lock.notify();
                        System.out.println("已經發出了通知");
                        lock.wait();
                    }
                    System.out.println("添加了" + (i + 1) + "個元素!");
                    Thread.sleep(1000);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Test {
    public static void main(String[] args) {
        try {
            Object lock = new Object();

            ThreadA a = new ThreadA(lock);
            a.start();

            Thread.sleep(50);

            ThreadB b = new ThreadB(lock);
            b.start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}
wait begin 1498007974397
添加了1個元素!
添加了2個元素!
添加了3個元素!
添加了4個元素!
已經發出了通知
Interruption!!!
添加了5個元素!
添加了6個元素!
添加了7個元素!
添加了8個元素!
添加了9個元素!
添加了10個元素!

執行緒A要等待某個條件滿足時(list.size()==5)，才執行操作。執行緒B則向list中新增元素，改變list 的size。

A,B之間如何通訊的呢？也就是說，執行緒A如何知道 list.size() 已經為5了呢？

這裡用到了Object類的 wait() 和 notify() 方法。

當條件未滿足時(list.size() !=5)，執行緒A呼叫wait() 放棄CPU，並進入阻塞狀態。—不像②while輪詢那樣佔用CPU

當條件滿足時，執行緒B呼叫 notify()通知 執行緒A，所謂通知執行緒A，就是喚醒執行緒A，並讓它進入可執行狀態。

這種方式的一個好處就是CPU的利用率提高了。

這裡寫圖片描述

管道通訊

管道流主要用來實現兩個執行緒之間的二進位制資料的傳播，下面以PipedInputStream類和PipedOutputStream類為例，實現生產者-消費者：

package test.pipe;  

import java.io.IOException;  
import java.io.PipedInputStream;  
import java.io.PipedOutputStream;  

/** 
 * 我們以數字替代產品 生產者每5秒提供5個產品，放入管道 
 */  
class MyProducer extends Thread {  

    private PipedOutputStream outputStream;  

    private int index = 0;  

    public MyProducer(PipedOutputStream outputStream) {  
        this.outputStream = outputStream;  
    }  

    @Override  
    public void run() {  
        while (true) {  
            try {  
                for (int i = 0; i < 5; i++) {  
                    outputStream.write(index++);  
                }  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  

            try {  
                Thread.sleep(5000);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
}  

/** 
 * 消費者每0.5秒從管道中取1件產品，並列印剩餘產品數量，並列印產品資訊（以數字替代） 
 */  
class MyConsumer extends Thread {  

    private PipedInputStream inputStream;  

    public MyConsumer(PipedInputStream inputStream) {  
        this.inputStream = inputStream;  
    }  

    @Override  
    public void run() {  
        while (true) {  
            try {  
                Thread.sleep(500);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
            try {  
                int count = inputStream.available();  
                if (count > 0) {  
                    System.out.println("rest product count: " + count);  
                    System.out.println("get product: " + inputStream.read());  
                }  
            } catch (IOException e1) {  
                e1.printStackTrace();  
            }  
        }  
    }  
}  

public class PipeTest1 {  

    public static void main(String[] args) {  

        PipedOutputStream pos = new PipedOutputStream();  
        PipedInputStream pis = new PipedInputStream();  
        try {  
            pis.connect(pos);  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  

        new MyProducer(pos).start();  
        new MyConsumer(pis).start();  

    }  
}

相關推薦

java實現執行緒間通訊的四種方式

本文主要針對JAVA多執行緒中執行緒之間的通訊方式進行分析解釋，主要以程式碼結合文字的方式來討論執行緒間的通訊。 synchronized同步 public class MyObject { synchronized public void m

java實現執行緒間通訊

正常情況下，每個子執行緒完成各自的任務就可以結束了。不過有的時候，我們希望多個執行緒協同工作來完成某個任務，這時就涉及到了執行緒間通訊了。 本文涉及到的知識點： thread.join(), object.wait(), object.notify(),

Java利用wait和notify實現執行緒間通訊

       Java的Object類提供了wait和notify方法用於實現執行緒間通訊(因為所有的java類都繼承了Object類，所以所有的java類都有這兩個方法)。這兩個方法在Object類中籤名如下： pu

Java併發程式設計（10）:使用wait/notify/notifyAll實現執行緒間通訊的幾點重要說明

在Java中，可以通過配合呼叫Object物件的wait（）方法和notify（）方法或notifyAll（）方法來實現執行緒間的通訊。線上程中呼叫wait（）方法，將阻塞等待其他執行緒的通知（其他執行緒呼叫notify（）方法或notifyAll（）方法），線上程中呼叫notify（）方法或notifyAl

java實現執行緒間的通訊

本文章旨在記錄java執行緒之間通訊的使用方法（學習為主），文中涉及的程式碼非原創。 來源：http://wingjay.com 如何讓兩個執行緒同時執行？ public class threadTest { public static void main(String

Java 如何實現執行緒間通訊？

正常情況下，每個子執行緒完成各自的任務就可以結束了。不過有的時候，我們希望多個執行緒協同工作來完成某個任務，這時就涉及到了執行緒間通訊了。 本文涉及到的知識點： thread.join(), object.wait(), object.notify(), Countdown

Java 裡實現執行緒間通訊

正常情況下，每個子執行緒完成各自的任務就可以結束了。不過有的時候，我們希望多個執行緒協同工作來完成某個任務，這時就涉及到了執行緒間通訊了。 本文涉及到的知識點：thread.join(), object.wait(), object.notify(), C

Java 如何實現執行緒間通訊？（notify、join、CountdownLatch、CyclicBarrier、FutureTask、Callable ）

  轉自：https://mp.weixin.qq.com/s?__biz=MzI4Njc5NjM1NQ==&mid=2247486499&idx=1&sn=d3f2d6959df7299bfbe2d663f6c4d353&chksm=ebd6330fdca1ba1

【Java併發程式設計】之十：使用wait/notify/notifyAll實現執行緒間通訊的幾點重要說明

在Java中，可以通過配合呼叫Object物件的wait（）方法和notify（）方法或notifyAll（）方法來實現執行緒間的通訊。線上程中呼叫wait（）方法，將阻塞等待其他執行緒的通知（其

Java 裡如何實現執行緒間通訊？

正常情況下，每個子執行緒完成各自的任務就可以結束了。不過有的時候，我們希望多個執行緒協同工作來完成某個任務，這時就涉及到了執行緒間通訊了。本文涉及到的知識點：thread.join(), object.wait(), object.notify(), CountdownLat

[one_demo_17]使用傳統方式實現執行緒間通訊的例子

題目： 子執行緒迴圈10次，接著到主執行緒迴圈10次；接著又回到子執行緒迴圈10次，接著又到主執行緒迴圈10次，如此迴圈50次。 使用Object的wait()和notify()方法實現。 Java程式碼 第一種，不使用面向物件的思想實現 /** * 練習執行緒間通訊 *

java之執行緒建立的兩種方式，六種狀態和匿名內部類建立子類或實現類物件

一.匿名內部類建立子類或實現類物件 new Test(){} 相當於建立了Test類的子類物件 並且沒有類名 建立介面實現類 new 介面名() {};介面實現類的物件 注意 : new 後邊是類或者介面名 大括號內是類或者介面中的方法 public

Java 建立執行緒池的四種方法

Java通過Executors提供四種執行緒池，分別為：newCachedThreadPool建立一個可快取執行緒池，如果執行緒池長度超過處理需要，可靈活回收空閒執行緒，若無可回收，則新建執行緒。newFixedThreadPool 建立一個定長執行緒池，可控制執行緒最大併發

juc包：使用 juc 包下的顯式 Lock 實現執行緒間通訊

# 一、前置知識 執行緒間通訊三要素： 多執行緒+**判斷**+操作+**通知**+資源類。 上面的五個要素，其他三個要素就是普通的多執行緒程式問題，那麼通訊就需要執行緒間的互相通知，往往伴隨著何時通訊的判斷邏輯。 在 java 的 Object 類裡就提供了對應的方法來進行通知，同樣的，保證

實現執行緒的第三種方式 實現Callable介面

package com.juc; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; /**

Java多執行緒建立的三種方式與對比

一、繼承Thread類建立執行緒類 1、定義Thread類的子類，並重寫該類的run()方法，該run()方法的方法體代表了執行緒需要完成的任務，即執行緒的執行體。 2、建立Thread子類的例項，即建立執行緒物件。 3、呼叫執行緒物件的start()方法來啟動該執行緒

執行緒間通訊與協作方式之——wait-notify機制

大家好，上篇文章為大家介紹了執行緒間通訊和協作的一些基本方式，那這篇文章就來介紹一下經典的wait-notify機制吧。 什麼是wait-notify機制？ 想象一下有兩個執行緒A、B，如果業務場景中需要這兩個執行緒交替執行任務（比如A執行完一次任務後換B執行，B執行

匿名內部類實現執行緒程式的三種方式

/* * 使用匿名內部類，實現多執行緒程式 * 匿名內部類的前提：繼承或者介面實現 * new 父類或者介面(){ *         重寫抽象方法 * } */public class ThreadDemo {    public static void main(Stri

C++執行緒同步的四種方式（Windows）

為什麼要進行執行緒同步？ 　　在程式中使用多執行緒時，一般很少有多個執行緒能在其生命期內進行完全獨立的操作。更多的情況是一些執行緒進行某些處理操作，而其他的執行緒必須對其處理結果進行了解。正常情況下對這種處理結果的瞭解應當在其處理任務完成後進行。 　　如果不

實現執行緒同步的幾種方式總結

在多執行緒中執行緒的執行順序是依靠哪個執行緒先獲得到CUP的執行權誰就先執行，雖然說可以通過執行緒的優先權進行設定，但是他只是獲取CUP執行權的概率高點，但是也不一定必須先執行。在這種情況下如何保證執行緒按照一定的順序進行執行，今天就來一個大總結，分別介紹一下幾種方式。 通