如何在Java中創建線程通信的四種方式

這期內容當中小編將會給大家帶來有關如何在Java中創建線程通信的四種方式，文章內容豐富且以專業的角度為大家分析和敘述，閱讀完這篇文章希望大家可以有所收獲。

目錄

• 1.1 創建線程

• 1.1.1 創建線程的四種方式

• 1.1.2 Thread類與Runnable接口的比較

• 1.1.3 Callable、Future與FutureTask

• 1.2 線程組和線程優先級

• 1.3 Java線程的狀態及主要轉化方法

• 1.4 Java線程間的通信

• 1.4.1 等待/通知機制

• 1.4.2 信號量

• 1.4.3 管道

• 總結

1.1 創建線程

1.1.1 創建線程的四種方式

【1】繼承Thread類

【2】實現Runnable接口

【3】實現Callable，獲取返回值

【4】實現FutureTask類

Thread類是一個Runnable接口的實現類，Thread類中通過調用私有的init來實現初始化。

g：線程組

target：實現Runnable接口的線程處理類

name：線程名稱，如果沒有指定則默認Thread-隨機數

stackSize：線程初始棧大小

1.1.2 Thread類與Runnable接口的比較

1：由于Java“單繼承，多實現”的特性，Runnable接口使用起來比Thread更靈活。

2：Runnable接口出現更符合面向對象，將線程單獨進行對象的封裝。

3：Runnable接口出現，降低了線程對象和線程任務的耦合性。

4：如果使用線程時不需要使用Thread類的諸多方法，顯然使用Runnable接口更為輕量。Thread是擴展了Runnable接口的對象。

1.1.3 Callable、Future與FutureTask

使用Runnable和Thread來創建一個新的線程。但是它們有一個弊端，就是run方法是沒有返回值的。而有時候我們希望開啟一個線程去執行一個任務，并且這個任務執行完成后有一個返回值。

@FunctionalInterface
public interface Callable<V> {
    /**
     * 處理任務并返回一個結果
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

Callable一般是配合線程池工具ExecutorService來使用的。ExecutorService可以使用submit方法來讓一個Callable接口執行。它會返回一個Future，我們通過

Future.get()就可以獲取線程執行的返回結果了。

1.2 線程組和線程優先級

Java中用ThreadGroup來表示線程組，我們可以使用線程組對線程進行批量控制。

ThreadGroup和Thread的關系就如同他們的字面意思一樣簡單粗暴，每個Thread必然存在于一個ThreadGroup中，Thread不能獨立于ThreadGroup存在。執行main()方法線程的名字是main，如果在new Thread時沒有顯式指定，那么默認將父線程（當前執行new Thread的線程）線程組設置為自己的線程組。

ThreadGroup管理著它下面的Thread，ThreadGroup是一個標準的向下引用的樹狀結構，這樣設計的原因是防止”上級”線程被”下級”線程引用而無法有效地被GC回收。

Java中線程優先級可以指定，范圍是1~10。但是并不是所有的操作系統都支持10級優先級的劃分（比如有些操作系統只支持3級劃分：低，中，高），Java只是給操作系統一個優先級的參考值，線程最終在操作系統的優先級是多少還是由操作系統決定。

Java默認的線程優先級為5，線程的執行順序由調度程序來決定，線程的優先級會在線程被調用之前設定。

通常情況下，高優先級的線程將會比低優先級的線程有更高的幾率得到執行。我們使用方法Thread類的setPriority()實例方法來設定線程的優先級。

Java中的優先級來說不是特別的可靠，Java程序中對線程所設置的優先級只是給操作系統一個建議，操作系統不一定會采納。而真正的調用順序，是由操作系統的線程調度算法決定的。

Java提供一個線程調度器來監視和控制處于RUNNABLE狀態的線程。線程的調度策略采用搶占式，優先級高的線程比優先級低的線程會有更大的幾率優先執行。在優先級相同的情況下，按照“先到先得”的原則。每個Java程序都有一個默認的主線程，就是通過JVM啟動的第一個線程main線程。

還有一種線程稱為守護線程（Daemon），守護線程默認的優先級比較低。

如果某線程是守護線程，那如果所有的非守護線程結束，這個守護線程也會自動結束。

應用場景是：當所有非守護線程結束時，結束其余的子線程（守護線程）自動關閉，就免去了還要繼續關閉子線程的麻煩。

一個線程默認是非守護線程，可以通過Thread類的setDaemon(boolean on)來設置。

【一個線程必然存在于一個線程組中，那么當線程和線程組的優先級不一致的時候將會怎樣呢？】

public static void main(String[] args) {
    ThreadGroup threadGroup = new ThreadGroup("t1");
    threadGroup.setMaxPriority(6);
    Thread thread = new Thread(threadGroup,"thread");
    thread.setPriority(9);
    System.out.println("我是線程組的優先級"+threadGroup.getMaxPriority());
    System.out.println("我是線程的優先級"+thread.getPriority());
}

所以，如果某個線程優先級大于線程所在線程組的最大優先級，那么該線程的優先級將會失效，取而代之的是線程組的最大優先級。

1.3 Java線程的狀態及主要轉化方法

Enum Thread.State

【1】反復調用同一個線程的start()方法是否可行？

【2】假如一個線程執行完畢（此時處于TERMINATED狀態），再次調用這個線程的start()方法是否可行？

查看Thread類中start()方法源碼，代碼如下

 public synchronized void start() {
		//threadStatus表示處于NEW狀態的線程
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
		 //通知當前線程的線程組這個線程將要啟動，并添加當前線程到線程組中
		 //當前線程組未啟動線程數減少
        group.add(this);
        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
				//處理啟動失敗的線程
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }
    //本地方法執行線程的實際啟動流程
    private native void start0();

在start()內部，這里有一個threadStatus的變量。如果它不等于0，調用start()是會直接拋出異常的。

我是在start()方法內部的最開始打的斷點，敘述下在我這里打斷點看到的結果：

測試代碼如下

 @Test
    public  void testThreadState(){
        Thread thread = new Thread(()->{
            System.out.println("Thread Run...");
        });
        thread.start();
        thread.start();
    }

第一個 thread.start();執行情況如下

第二個 thread.start();執行情況如下

兩個問題的答案都是不可行，在調用一次start()之后，threadStatus的值會改變（threadStatus !=0），此時再次調用start()方法會拋出IllegalThreadStateException異常。

比如，threadStatus為2代表當前線程狀態為TERMINATED。

1.4 Java線程間的通信

線程同步是線程之間按照一定的順序執行。

1.4.1 等待/通知機制

Java多線程的等待/通知機制是基于Object類的wait()方法和notify(), notifyAll()方法來實現的。

notify()方法會隨機叫醒一個正在等待的線程，而notifyAll()會叫醒所有正在等待的線程。

1.4.2 信號量

JDK提供了一個類似于“信號量”功能的類Semaphore。但本文不是要介紹這個類，而是介紹一種基于volatile關鍵字的自己實現的信號量通信。

volitile關鍵字能夠保證內存的可見性，如果用volitile關鍵字聲明了一個變量，在一個線程里面改變了這個變量的值，那其它線程是立馬可見更改后的值的。

【需求】讓線程1輸出0，然后線程2輸出1，再然后線程A輸出2…以此類推。我應該怎樣實現呢？

 private static Object lock=new Object();
    private static volatile  int sign=0;
    static class MyThread1 implements  Runnable{
        @SneakyThrows
        @Override
        public void run() {
            while (sign<5){
                if (sign%2==0){
                    System.out.println("線程1--->"+sign);
                    synchronized (lock){
                        sign++;
                    }
                }
            }
        }
    }
    static class MyThread2 implements  Runnable{
        @Override
        public void run() {
            while (sign<5){
                if (sign%2!=0){
                    System.out.println("線程2--->"+sign);
                    synchronized (lock){
                        sign++;
                    }
                }
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread threadA = new Thread(new MyThread1());
        Thread threadB = new Thread(new MyThread2());
        threadA.start();
        threadB.start();
        Thread.sleep(4000);
    }

注意：

上面使用了一個volatile變量signal來實現了“信號量”的模型。但是volatile僅僅只線程可見的，signal++并不是一個原子操作，所以我們需要使用synchronized給它“上鎖”

1.4.3 管道

管道是基于“管道流”的通信方式。JDK提供了PipedWriter、 PipedReader、 PipedOutputStream、 PipedInputStream。其中，前面兩個是基于字符的，后面兩個是基于字節流的。

public class PipeExample {
    /**
     * 構建一個管道讀的線程
     */
    static class ReaderThread implements  Runnable{
        private  PipedReader pipedReader;
        public ReaderThread(PipedReader pipedReader) {
            this.pipedReader = pipedReader;
        }
        @Override
        public void run() {
            int count=0;
            try
            {//接收并輸出流
                while ((count= pipedReader.read())!=-1){
                    System.out.println((char)count);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 構建一個寫入管道流的線程
     */
    static class WriterThread implements Runnable {
        private PipedWriter writer;
        public WriterThread(PipedWriter writer) {
            this.writer = writer;
        }
        @SneakyThrows
        @Override
        public void run() {
            try {
                writer.write("qwertyui");
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                //寫入管道的流必須關閉
                writer.close();
            }
        }
    }
    public static void main(String[] args) throws IOException, InterruptedException {
        PipedWriter writer = new PipedWriter();
        PipedReader reader = new PipedReader();
        // 這里注意一定要連接，才能通信
        writer.connect(reader);
        new Thread(new ReaderThread(reader)).start();
        Thread.sleep(1000);
        new Thread(new WriterThread(writer)).start();
    }
}

我們通過線程的構造函數，傳入了PipedWrite和PipedReader對象。可以簡單分析一下這個示例代碼的執行流程：

1：線程ReaderThread開始執行

2：線程ReaderThread使用管道reader.read()進入”阻塞“

3：線程WriterThread開始執行

4：線程WriterThread用writer.write(“XXXX”)往管道寫入字符串

5：線程WriterThread使用writer.close()結束管道寫入，并執行完畢

6：線程ReaderThread接受到管道輸出的字符串并打印

7：線程ReaderThread執行完畢

管道通信的應用場景：使用管道多半與I/O流相關。當我們一個線程需要先另一個線程發送一個信息（比如字符串）或者文件等等時，就需要使用管道通信了。

上述就是小編為大家分享的如何在Java中創建線程通信的四種方式了，如果剛好有類似的疑惑，不妨參照上述分析進行理解。如果想知道更多相關知識，歡迎關注億速云行業資訊頻道。