1.1 創(chuàng)建線程

1.1.1 創(chuàng)建線程的四種方式

【1】繼承Thread類

【2】實現(xiàn)Runnable接口

【3】實現(xiàn)Callable，獲取返回值

【4】實現(xiàn)FutureTask類

Thread類是一個Runnable接口的實現(xiàn)類，Thread類中通過調(diào)用私有的init來實現(xiàn)初始化。

g：線程組

target：實現(xiàn)Runnable接口的線程處理類

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

stackSize：線程初始棧大小

1.1.2 Thread類與Runnable接口的比較

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

2：Runnable接口出現(xiàn)更符合面向?qū)ο螅瑢⒕€程單獨進行對象的封裝。

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

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

1.1.3 Callable、Future與FutureTask

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

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

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

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

1.2 線程組和線程優(yōu)先級

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

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

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

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

Java默認的線程優(yōu)先級為5，線程的執(zhí)行順序由調(diào)度程序來決定，線程的優(yōu)先級會在線程被調(diào)用之前設(shè)定。

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

Java中的優(yōu)先級來說不是特別的可靠，Java程序中對線程所設(shè)置的優(yōu)先級只是給操作系統(tǒng)一個建議，操作系統(tǒng)不一定會采納。而真正的調(diào)用順序，是由操作系統(tǒng)的線程調(diào)度算法決定的。

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

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

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

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

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

【一個線程必然存在于一個線程組中，那么當線程和線程組的優(yōu)先級不一致的時候?qū)鯓幽兀俊?/p>

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("我是線程組的優(yōu)先級"+threadGroup.getMaxPriority());
    System.out.println("我是線程的優(yōu)先級"+thread.getPriority());
}

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

1.3 Java線程的狀態(tài)及主要轉(zhuǎn)化方法

Enum Thread.State

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

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

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

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

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

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

測試代碼如下

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

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

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

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

比如，threadStatus為2代表當前線程狀態(tài)為TERMINATED。

1.4 Java線程間的通信

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

1.4.1 等待/通知機制

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

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

1.4.2 信號量

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

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

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

 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來實現(xiàn)了“信號量”的模型。但是volatile僅僅只線程可見的，signal++并不是一個原子操作，所以我們需要使用synchronized給它“上鎖”

1.4.3 管道

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

public class PipeExample {
    /**
     * 構(gòu)建一個管道讀的線程
     */
    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();
            }
        }
    }
    /**
     * 構(gòu)建一個寫入管道流的線程
     */
    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 {
                //寫入管道的流必須關(guān)閉
                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();
    }
}

我們通過線程的構(gòu)造函數(shù)，傳入了PipedWrite和PipedReader對象?？梢院唵畏治鲆幌逻@個示例代碼的執(zhí)行流程：

1：線程ReaderThread開始執(zhí)行

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

3：線程WriterThread開始執(zhí)行

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

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

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

7：線程ReaderThread執(zhí)行完畢

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

總結(jié)

本篇文章就到這里了，希望能夠給你帶來幫助，也希望您能夠多多關(guān)注腳本之家的更多內(nèi)容！