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

Posted on by

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流相關。當我們一個線程需要先另一個線程發送一個信息（比如字符串）或者文件等等時，就需要使用管道通信瞭。

總結

本篇文章就到這裡瞭，希望能夠給你帶來幫助，也希望您能夠多多關註WalkonNet的更多內容！

推薦閱讀：