2. 程式人生 > >JAVA執行緒間通訊的幾種方式

JAVA執行緒間通訊的幾種方式

阿新 • • 發佈：2018-12-22

先抄錄下來慢慢看吧
今天在群裡面看到一個很有意思的面試題：
“編寫兩個執行緒，一個執行緒列印125，另一個執行緒列印字母AZ，列印順序為12A34B56C……5152Z，要求使用執行緒間的通訊。”
這是一道非常好的面試題，非常能彰顯被面者關於多執行緒的功力，一下子就勾起了我的興趣。這裡拋磚引玉，給出7種想到的解法。

通用程式碼：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**

  • Created by Edison Xu on 2017/3/2.
    */
    public enum Helper {

    instance;

    private static final ExecutorService tPool = Executors.newFixedThreadPool(2);

    public static String[] buildNoArr(int max) {
    String[] noArr = new String[max];
    for(int i=0;i<max;i++){
    noArr[i] = Integer.toString(i+1);
    }
    return noArr;
    }

    public static String[] buildCharArr(int max) {
    String[] charArr = new String[max];
    int tmp = 65;
    for(int i=0;i<max;i++){
    charArr[i] = String.valueOf((char)(tmp+i));
    }
    return charArr;
    }

    public static void print(String… input){
    if(input==null)
    return;
    for(String each:input){
    System.out.print(each);
    }
    }

    public void run(Runnable r){
    tPool.submit®;
    }

    public void shutdown(){
    tPool.shutdown();
    }

}

  1. 第一種解法，包含多種小的不同實現方式，但一個共同點就是靠一個共享變數來做控制；
    a. 利用最基本的synchronized、notify、wait：
    public class MethodOne {
    private final ThreadToGo threadToGo = new ThreadToGo();
    public Runnable newThreadOne() {
    final String[] inputArr = Helper.buildNoArr(52);
    return new Runnable() {
    private String[] arr = inputArr;
    public void run() {
    try {
    for (int i = 0; i < arr.length; i=i+2) {
    synchronized (threadToGo) {
    while (threadToGo.value == 2)
    threadToGo.wait();
    Helper.print(arr[i], arr[i + 1]);
    threadToGo.value = 2;
    threadToGo.notify();
    }
    }
    } catch (InterruptedException e) {
    System.out.println(“Oops…”);
    }
    }
    };
    }
    public Runnable newThreadTwo() {
    final String[] inputArr = Helper.buildCharArr(26);
    return new Runnable() {
    private String[] arr = inputArr;
    public void run() {
    try {
    for (int i = 0; i < arr.length; i++) {
    synchronized (threadToGo) {
    while (threadToGo.value == 1)
    threadToGo.wait();
    Helper.print(arr[i]);
    threadToGo.value = 1;
    threadToGo.notify();
    }
    }
    } catch (InterruptedException e) {
    System.out.println(“Oops…”);
    }
    }
    };
    }
    class ThreadToGo {
    int value = 1;
    }
    public static void main(String args[]) throws InterruptedException {
    MethodOne one = new MethodOne();
    Helper.instance.run(one.newThreadOne());
    Helper.instance.run(one.newThreadTwo());
    Helper.instance.shutdown();
    }
    }
    b. 利用Lock和Condition：
    public class MethodTwo {
    private Lock lock = new ReentrantLock(true);
    private Condition condition = lock.newCondition();
    private final ThreadToGo threadToGo = new ThreadToGo();
    public Runnable newThreadOne() {
    final String[] inputArr = Helper.buildNoArr(52);
    return new Runnable() {
    private String[] arr = inputArr;
    public void run() {
    for (int i = 0; i < arr.length; i=i+2) {
    try {
    lock.lock();
    while(threadToGo.value == 2)
    condition.await();
    Helper.print(arr[i], arr[i + 1]);
    threadToGo.value = 2;
    condition.signal();
    } catch (InterruptedException e) {
    e.printStackTrace();
    } finally {
    lock.unlock();
    }
    }
    }
    };
    }
    public Runnable newThreadTwo() {
    final String[] inputArr = Helper.buildCharArr(26);
    return new Runnable() {
    private String[] arr = inputArr;
    public void run() {
    for (int i = 0; i < arr.length; i++) {
    try {
    lock.lock();
    while(threadToGo.value == 1)
    condition.await();
    Helper.print(arr[i]);
    threadToGo.value = 1;
    condition.signal();
    } catch (Exception e) {
    e.printStackTrace();
    } finally {
    lock.unlock();
    }
    }
    }
    };
    }
    class ThreadToGo {
    int value = 1;
    }
    public static void main(String args[]) throws InterruptedException {
    MethodTwo two = new MethodTwo();
    Helper.instance.run(two.newThreadOne());
    Helper.instance.run(two.newThreadTwo());
    Helper.instance.shutdown();
    }
    }
    c. 利用volatile：
    volatile修飾的變數值直接存在main memory裡面，子執行緒對該變數的讀寫直接寫入main memory，而不是像其它變數一樣在local thread裡面產生一份copy。volatile能保證所修飾的變數對於多個執行緒可見性，即只要被修改，其它執行緒讀到的一定是最新的值。
    public class MethodThree {
    private volatile ThreadToGo threadToGo = new ThreadToGo();
    class ThreadToGo {
    int value = 1;
    }
    public Runnable newThreadOne() {
    final String[] inputArr = Helper.buildNoArr(52);
    return new Runnable() {
    private String[] arr = inputArr;
    public void run() {
    for (int i = 0; i < arr.length; i=i+2) {
    while(threadToGo.value2){}
    Helper.print(arr[i], arr[i + 1]);
    threadToGo.value=2;
    }
    }
    };
    }
    public Runnable newThreadTwo() {
    final String[] inputArr = Helper.buildCharArr(26);
    return new Runnable() {
    private String[] arr = inputArr;
    public void run() {
    for (int i = 0; i < arr.length; i++) {
    while(threadToGo.value
    1){}
    Helper.print(arr[i]);
    threadToGo.value=1;
    }
    }
    };
    }
    public static void main(String args[]) throws InterruptedException {
    MethodThree three = new MethodThree();
    Helper.instance.run(three.newThreadOne());
    Helper.instance.run(three.newThreadTwo());
    Helper.instance.shutdown();
    }
    }

d. 利用AtomicInteger：
public class MethodFive {
private AtomicInteger threadToGo = new AtomicInteger(1);
public Runnable newThreadOne() {
final String[] inputArr = Helper.buildNoArr(52);
return new Runnable() {
private String[] arr = inputArr;
public void run() {
for (int i = 0; i < arr.length; i=i+2) {
while(threadToGo.get()==2){}
Helper.print(arr[i], arr[i + 1]);
threadToGo.set(2);
}
}
};
}
public Runnable newThreadTwo() {
final String[] inputArr = Helper.buildCharArr(26);
return new Runnable() {
private String[] arr = inputArr;
public void run() {
for (int i = 0; i < arr.length; i++) {
while(threadToGo.get()==1){}
Helper.print(arr[i]);
threadToGo.set(1);
}
}
};
}
public static void main(String args[]) throws InterruptedException {
MethodFive five = new MethodFive();
Helper.instance.run(five.newThreadOne());
Helper.instance.run(five.newThreadTwo());
Helper.instance.shutdown();
}
}

  1. 第二種解法，是利用CyclicBarrierAPI；
    CyclicBarrier可以實現讓一組執行緒在全部到達Barrier時(執行await())，再一起同時執行，並且所有執行緒釋放後，還能複用它,即為Cyclic。
    CyclicBarrier類提供兩個構造器：

public CyclicBarrier(int parties, Runnable barrierAction) {
}
public CyclicBarrier(int parties) {
}
public class MethodFour{
private final CyclicBarrier barrier;
private final List list;
public MethodFour() {
list = Collections.synchronizedList(new ArrayList());
barrier = new CyclicBarrier(2,newBarrierAction());
}
public Runnable newThreadOne() {
final String[] inputArr = Helper.buildNoArr(52);
return new Runnable() {
private String[] arr = inputArr;
public void run() {
for (int i = 0, j=0; i < arr.length; i=i+2,j++) {
try {
list.add(arr[i]);
list.add(arr[i+1]);
barrier.await();
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
}
}
};
}
public Runnable newThreadTwo() {
final String[] inputArr = Helper.buildCharArr(26);
return new Runnable() {
private String[] arr = inputArr;
public void run() {
for (int i = 0; i < arr.length; i++) {
try {
list.add(arr[i]);
barrier.await();
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
}
}
};
}
private Runnable newBarrierAction(){
return new Runnable() {
@Override
public void run() {
Collections.sort(list);
list.forEach(c->System.out.print©);
list.clear();
}
};
}
public static void main(String args[]){
MethodFour four = new MethodFour();
Helper.instance.run(four.newThreadOne());
Helper.instance.run(four.newThreadTwo());
Helper.instance.shutdown();
}
}
這裡多說一點，這個API其實還是利用lock和condition，無非是多個執行緒去爭搶CyclicBarrier的instance的lock罷了，最終barrierAction執行時，是在搶到CyclicBarrierinstance的那個執行緒上執行的。
3. 第三種解法，是利用PipedInputStreamAPI；
這裡用流在兩個執行緒間通訊，但是Java中的Stream是單向的，所以在兩個執行緒中分別建了一個input和output。這顯然是一種很搓的方式，不過也算是一種通訊方式吧……-_-T，執行的時候那種速度簡直。。。請不要BS我。
public class MethodSix {
private final PipedInputStream inputStream1;
private final PipedOutputStream outputStream1;
private final PipedInputStream inputStream2;
private final PipedOutputStream outputStream2;
private final byte[] MSG;
public MethodSix() {
inputStream1 = new PipedInputStream();
outputStream1 = new PipedOutputStream();
inputStream2 = new PipedInputStream();
outputStream2 = new PipedOutputStream();
MSG = “Go”.getBytes();
try {
inputStream1.connect(outputStream2);
inputStream2.connect(outputStream1);
} catch (IOException e) {
e.printStackTrace();
}
}
public void shutdown() throws IOException {
inputStream1.close();
inputStream2.close();
outputStream1.close();
outputStream2.close();
}
public Runnable newThreadOne() {
final String[] inputArr = Helper.buildNoArr(52);
return new Runnable() {
private String[] arr = inputArr;
private PipedInputStream in = inputStream1;
private PipedOutputStream out = outputStream1;
public void run() {
for (int i = 0; i < arr.length; i=i+2) {
Helper.print(arr[i], arr[i + 1]);
try {
out.write(MSG);
byte[] inArr = new byte[2];
in.read(inArr);
while(true){
if(“Go”.equals(new String(inArr)))
break;
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
};
}
public Runnable newThreadTwo() {
final String[] inputArr = Helper.buildCharArr(26);
return new Runnable() {
private String[] arr = inputArr;
private PipedInputStream in = inputStream2;
private PipedOutputStream out = outputStream2;
public void run() {
for (int i = 0; i < arr.length; i++) {
try {
byte[] inArr = new byte[2];
in.read(inArr);
while(true){
if(“Go”.equals(new String(inArr)))
break;
}
Helper.print(arr[i]);
out.write(MSG);
} catch (IOException e) {
e.printStackTrace();
}
}
}
};
}
public static void main(String args[]) throws IOException {
MethodSix six = new MethodSix();
Helper.instance.run(six.newThreadOne());
Helper.instance.run(six.newThreadTwo());
Helper.instance.shutdown();
six.shutdown();
}
4. 第四種解法，是利用BlockingQueue；
順便總結下BlockingQueue的一些內容。
BlockingQueue定義的常用方法如下:

add(Object)：把Object加到BlockingQueue裡，如果BlockingQueue可以容納，則返回true，否則丟擲異常。
offer(Object)：表示如果可能的話，將Object加到BlockingQueue裡，即如果BlockingQueue可以容納，則返回true，否則返回false。
put(Object)：把Object加到BlockingQueue裡，如果BlockingQueue沒有空間，則呼叫此方法的執行緒被阻斷直到BlockingQueue裡有空間再繼續。
poll(time)：獲取並刪除BlockingQueue裡排在首位的物件，若不能立即取出，則可以等time引數規定的時間，取不到時返回null。當不傳入time值時，立刻返回。
peek()：立刻獲取BlockingQueue裡排在首位的物件，但不從佇列裡刪除，如果佇列為空，則返回null。
take()：獲取並刪除BlockingQueue裡排在首位的物件，若BlockingQueue為空，阻斷進入等待狀態直到BlockingQueue有新的物件被加入為止。
BlockingQueue有四個具體的實現類：

ArrayBlockingQueue：規定大小的BlockingQueue，其建構函式必須帶一個int引數來指明其大小。其所含的物件是以FIFO（先入先出）順序排序的。
LinkedBlockingQueue：大小不定的BlockingQueue，若其建構函式帶一個規定大小的引數，生成的BlockingQueue有大小限制，若不帶大小引數，所生成的BlockingQueue的大小由Integer.MAX_VALUE來決定。其所含的物件是以FIFO順序排序的。
PriorityBlockingQueue：類似於LinkedBlockingQueue,但其所含物件的排序不是FIFO，而是依據物件的自然排序順序或者是建構函式所帶的Comparator決定的順序。
SynchronousQueue：特殊的BlockingQueue，對其的操作必須是放和取交替完成的。
這裡我用了兩種玩法：

一種是共享一個queue，根據peek和poll的不同來實現；
第二種是兩個queue，利用take()會自動阻塞來實現。
public class MethodSeven {
private final LinkedBlockingQueue queue = new LinkedBlockingQueue<>();
public Runnable newThreadOne() {
final String[] inputArr = Helper.buildNoArr(52);
return new Runnable() {
private String[] arr = inputArr;
public void run() {
for (int i = 0; i < arr.length; i=i+2) {
Helper.print(arr[i], arr[i + 1]);
queue.offer(“TwoToGo”);
while(!“OneToGo”.equals(queue.peek())){}
queue.poll();
}
}
};
}
public Runnable newThreadTwo() {
final String[] inputArr = Helper.buildCharArr(26);
return new Runnable() {
private String[] arr = inputArr;
public void run() {
for (int i = 0; i < arr.length; i++) {
while(!“TwoToGo”.equals(queue.peek())){}
queue.poll();
Helper.print(arr[i]);
queue.offer(“OneToGo”);
}
}
};
}
private final LinkedBlockingQueue queue1 = new LinkedBlockingQueue<>();
private final LinkedBlockingQueue queue2 = new LinkedBlockingQueue<>();
public Runnable newThreadThree() {
final String[] inputArr = Helper.buildNoArr(52);
return new Runnable() {
private String[] arr = inputArr;
public void run() {
for (int i = 0; i < arr.length; i=i+2) {
Helper.print(arr[i], arr[i + 1]);
try {
queue2.put(“TwoToGo”);
queue1.take();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
}
public Runnable newThreadFour() {
final String[] inputArr = Helper.buildCharArr(26);
return new Runnable() {
private String[] arr = inputArr;
public void run() {
for (int i = 0; i < arr.length; i++) {
try {
queue2.take();
Helper.print(arr[i]);
queue1.put(“OneToGo”);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
}
public static void main(String args[]) throws InterruptedException {
MethodSeven seven = new MethodSeven();
Helper.instance.run(seven.newThreadOne());
Helper.instance.run(seven.newThreadTwo());
Thread.sleep(2000);
System.out.println("");
Helper.instance.run(seven.newThreadThree());
Helper.instance.run(seven.newThreadFour());
Helper.instance.shutdown();
}

相關推薦

java執行緒同步的幾種方式

 1.使用synchronized關鍵字，多執行緒的同步依靠的是物件鎖機制，synchronized關鍵字的背後就是利用了封鎖來實現對共享資源的互斥訪問。 2.使用lock, Lock是java.util.concurrent.locks包下的介面，Lock 實現提供了

java 執行緒間通訊的幾種方式

1.如何讓兩個執行緒依次執行 假設有兩個執行緒，一個執行緒A,一個執行緒B，兩個執行緒分別依次列印 1-3 三個數字即可。 package Test;/** /** * @author Administrator * @createdate 2017-10-10 */ pu

JAVA執行緒間通訊的幾種方式

先抄錄下來慢慢看吧 今天在群裡面看到一個很有意思的面試題： “編寫兩個執行緒，一個執行緒列印125，另一個執行緒列印字母AZ，列印順序為12A34B56C……5152Z，要求使用執行緒間的通訊。” 這是一道非常好的面試題，非常能彰顯被面者關於多執行緒的功力，一下

程序、執行緒間的幾種通訊方式

一、程序通訊 幾種程序間的通訊方式 （1） 管道（pipe）：管道是一種半雙工的通訊方式，資料只能單向流動，而且只能在具有血緣關係的程序間使用。程序的血緣關係通常指父子程序關係。 （2）有名管道（named pipe）：有名管道也是半雙工的通訊方式，但是它允許無

java執行緒間通訊方式

1.同步 就是通過Synchronized關鍵字來進行同步訪問控制，確保誰拿到了相應的鎖才能執行相應的操作 本質上就是共享記憶體式的通訊，這個共享記憶體在java的記憶體模型中就是主記憶體，相當於通過主記憶體的資料進行執行緒通訊。因Synchronized解鎖時會將工作記

JAVA多執行緒實現的幾種方式及簡單示例

 JAVA多執行緒的實現方式是JAVA基礎的一個重點，看過好多次，但不經常用就容易忘記，今天做一個總結，算是把JAVA基礎再夯實一下。 Java多執行緒實現方式主要有四種：繼承Thread類、實現Runnable介面、實現Callable介面通過FutureTask包裝器來

Java中建立執行緒的幾種方式以及執行緒同步的幾種方式

執行緒同步自己及基本就用過Thread和Runnable這兩種方式，還有其他很多方式如下： Executor框架簡介 建立執行緒有幾種不同的方式？你喜歡哪一種？為什麼？ 而執行緒同步會用的方式就更少了，只會synchronized，其他方式如下： 關於執

Java多執行緒同步的幾種方式

當多個執行緒同時訪問一個資源時，非常容易出現安全問題。因此需要採用同步機制來解決這種問題。java主要提供了3種實現同步機制的方法： 1）、synchronized關鍵字 synchronized有兩種用法（synchronized方法和synchronized塊） syn

Android activity間通訊幾種方式

read flag 進程 destroy ads sage on() sting ogl Activity 通訊 Bundle 我們可以通過將數據封裝在Bundle對象中 ，然後在Intent跳轉的時候攜帶Bundle對象 bundle 本質上是使用 arrayMap實現

Java執行緒間通訊--管道

Java提供了多種輸入輸出流用於對資料進行操作，其中管道流pipeStream是一種特殊的流，用於在不同執行緒間直接傳送資料。 pis.read的時候，如果管道內沒有資料，會阻塞。 public class PipeStreamMain { public static voi

Android程序間通訊 - 幾種方式的對比總結

什麼是RPC RPC（Remote Procedure Call）即遠端過程呼叫，它是一種通過網路從遠端計算機程式上請求服務，在不需要了解底層網路技術的協議下，即可獲取計算機程序中的資料。RPC使得開發包括網路分散式多程式在內的應用程式更加容易。 RPC在OSI網路通訊7層模型中

Java執行緒建立的兩種方式

package test; /**  * 建立執行緒  *  */ public class Demo1 {      public static void main(String arg[]){

iOS中保證執行緒安全的幾種方式與效能對比

一、前言 前段時間看了幾個開源專案，發現他們保持執行緒同步的方式各不相同，有@synchronized、NSLock、dispatch_semaphore、NSCondition、pthread_mutex、OSSpinLock。後來網上查了一下，發現他們的實現機制各不相同，效能也各不一

Java執行緒間通訊的同步問題、wait/notify使用

Java執行緒間通訊簡單來說就是多個執行緒同時操作同一個資源，比如一個執行緒設定了姓名、性別，另一個執行緒讀取姓名、性別。 伴隨而來的就是同步問題：比如執行緒a先設定了張三、男，後設置了李四、女，執行緒b要列印這些資訊，由於多執行緒的隨機性，a設定張三、男後，然後a又設定了李四，還未設定性別時，

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

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

java 執行緒間通訊

1.使用join，執行緒同步 Object object； public static void TestJoin(){ object= new Object(); final Thread one =new Thread(new Runnable() {

執行緒和程序的關係 ----執行緒建立有幾種方式

程序是一個應用程式在處理機上的一次執行過程，他是一個動態的概念 ，執行緒是程序的一部分是程式執行的最小單元 一個程序中有多個執行緒 個人理解 ：             

Java執行Python指令碼的幾種方式

由於在專案需要執行Python，找尋相關資料，總結出以下幾種方式： 直接執行Python指令碼程式碼 　　　　引用 org.python包 1 PythonInterpreter interpreter = new PythonInterpreter(); 2 interpreter.

Linux多程序和執行緒同步的幾種方式

   引用：http://community.csdn.net/Expert/TopicView3.asp?id=4374496 linux下程序間通訊的幾種主要手段簡介：    1. 管道（Pipe）及有名管道（named pipe）：管道可用於具有親緣關係程序間的通訊，有名管道克服了管道沒有名字的

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

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