詳解Java實現多執行緒的三種方式

2022-03-23 13:03:10

並行與並行

並行：在作業系統中，是指一個時間段中有幾個程式都處於已啟動執行到執行完畢之間，且這幾個程式都是在同一個處理機上執行，但任一個時刻點上只有一個程式在處理機上執行

並行：一組程式按獨立非同步的速度執行，無論從微觀還是宏觀，程式都是一起執行的。

對比：並行是指:在同一個時間段內，兩個或多個程式執行，有時間上的重疊(宏觀上是同時,微觀上仍是順序執行)

程序與執行緒

程序（Process）是計算機中的程式關於某資料集合上的一次執行活動，是系統進行資源分配和排程的基本單位，是作業系統結構的基礎

執行緒（英語：thread）是作業系統能夠進行運算排程的最小單位。它被包含在程序之中，是程序中的實際運作單位。一條執行緒指的是程序中一個單一順序的控制流，一個程序中可以並行多個執行緒，每條執行緒並行執行不同的任務。

java的執行緒

java多執行緒機制

多執行緒是指一個應用程式同時存在幾個執行體，按照幾條不同的執行線索共同工作的情況。java多執行緒機制，它使得程式設計人員可以很方便的開發出具有多執行緒功能、能同時處理多個任務的強大應用程式。java內建對多執行緒的支援，java虛擬機器器可以快速的從一個執行緒切換到另一個執行緒。這些執行緒的輪流執行使得每個執行緒都有機會使用cpu資源。

java的主執行緒

每個java程式都含有一個執行緒，那就是主執行緒（main執行緒）。Java應用程式都是從主類main方法執行的，當jvm載入程式碼，發現賣弄方法之後，就會啟動一個執行緒，這個執行緒就是主執行緒，負責執行main方法。如果在主執行緒裡面建立其他執行緒，就會在主執行緒和其他執行緒來回切換，直到其他所有執行緒結束才會結束主執行緒

執行緒的生命週期

執行

執行緒建立之後只佔有了記憶體資源，在JVM管理的執行緒中並沒有剛剛建立的這個執行緒，只有這個執行緒呼叫start（）方法後，JVM才知道有一個新執行緒進入佇列等待cpu呼叫。

中斷原因（4種）

jVM把cpu資源切換給其他執行緒。

執行緒使用cpu期間，執行了sleep(int millsecond)方法，使當前執行緒進入休眠狀態，呼叫該方法之後會立即讓出cpu，經過引數millsecond指定的毫秒後，重新加入佇列等待cpu。

-使用cpu期間，執行了wait()方法，使得當前程序進入等待狀態，這個等待個sleep()不同，這個等待需要其他執行緒呼叫notify()方法喚醒該執行緒，此執行緒才會重新進入佇列，等待cpu。

執行緒使用cpu期間，執行了某個操作進入阻塞狀態，例如（讀、寫、列印等），只有這些造成阻塞的原因完成，這個執行緒才會進入佇列，等待cpu。

建立執行緒（3種）

繼承Thread類實現執行緒建立

一種是建立一個類繼承Thread類，這種繼承可以重複使用！
一種是直接使用匿名內部類繼承，這種型別只能使用一次，每次使用都要重新建立
不論哪種都需要重寫run()方法，並且在定義之後呼叫start()方法，把這個執行緒調入執行緒佇列等待呼叫。

下面我們使用匿名內部類建立一個列印100以內的奇數執行緒，使用類繼承Thread類列印100內的偶數執行緒。

package hello;

public class Hello {
    public static void main(String[] args) {
        Thread1 thread1 = new Thread1();
        Thread thread = new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if (i % 2 == 1) {
                    //列印執行緒名，執行緒名是從0開始的
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        };

        thread1.start();
        thread.start();


    }
}

class Thread1 extends Thread{
    @Override
    public void run() {
        super.run();
        for(int i=0;i<100;i++){
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

方法說明

start()啟動當前執行緒；呼叫當前執行緒的run()方法

run()：需要重寫Thread類中的此方法，將建立執行緒需要執行的操作宣告在此方法中

currentThread()：返回執行當前程式碼的執行緒

getName()：獲取當前執行緒的名字

setName(String name)：設定當前執行緒的名字

yield()：釋放當前CPU的執行權

join()：線上程a中呼叫執行緒b的join()，此時執行緒a就進入阻塞狀態，直到執行緒b完全執行完之後，執行緒a在結束阻塞狀態

sleep(int millitime)：讓當前執行緒“睡眠”指定的millitime毫秒。在指定的millitime毫秒時間內，當前程序是阻塞狀態

isAlive()：判斷當前執行緒是否存活（執行緒執行完之前都是存活的）

實現Runnable介面

我們還是建立兩個執行緒，一個列印奇數，一個列印偶數，但是有一個執行緒每次呼叫會睡眠（阻塞）10ms。

使用實現介面Runnable方法，必須重寫run()方法。

package hello;

public class Hello {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyThread1());
        /*
        Thread thread = new Thread(new MyThread1());
        就相當於 ,就是建立實現類的物件，再把這個物件用Thread()構造器的方法建立
        MyThread1 myThread1 = new MyThread1();
        Thread thread = new Thread(myThread1);
         */
        Thread thread1 = new Thread(new MyThread2());
        thread.start();
        thread1.start();

    }
}


class MyThread1 implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<100;i++) {
            if (i % 2 == 1) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }
    }
}

class MyThread2 implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<100;i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);

            }
        }
    }
}

開發中，優先選擇實現Runnable介面的方式建立執行緒

原因：

實現Runnable介面的方式沒有類的單繼承性的侷限性（一個類只能繼承一個父類別，繼承了Thread類就不能在繼承其他類了）

實現Runnable介面的方式更適合來處理多個執行緒之間有共用資料的情況

實現Callable介面

Runnable介面是沒有返回值的 Callable有返回值，可以丟擲異常

Thread類並不接受Callable物件。可以使用FutureTask類實現Runnable介面和Future介面

Future就是對於具體的Runnable或者Callable任務的執行結果進行取消、查詢是否完成、獲取結果。必要時可以通過get方法獲取執行結果，該方法會阻塞直到任務返回結果。

Java的類是單繼承的設計，如果採用繼承Thread的方式實現多執行緒，則不能繼承其他的類，採用介面能夠更好的實現資料共用

FutureTask有兩個建構函式，一個以Callable為引數，另外一個以Runnable為引數。

我理解的就是通過FutureTask把Callable變成通過Runnable介面建立的，因為FutureTask繼承了Runnable介面。主要原因是Thread類不接受Callable建立，但是接受Runnable建立的執行緒。

package hello;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class Hello {
    public static void main(String[] args) throws Exception {

        MyThread1 myThread1 = new MyThread1();
        FutureTask<Integer> futureTask = new FutureTask<>(new MyThread1());
        new Thread(futureTask).start();//開啟執行緒
        System.out.println(futureTask.get());//獲取返回值

    }
}


class  MyThread1 implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        int count = 0;
        for (int i = 1;i<100;i++){
            if (i%3==0){
                count++;
            }
        }
        return count;
    }
}

執行緒池

執行緒池的執行過程

範例

package hello;


import java.util.concurrent.*;

public class Hello {
    public static void main(String[] args) throws Exception {

        //建立執行緒池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 4, 5, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<>(2),
                new ThreadFactory() {
                    @Override
                    public Thread newThread(Runnable r) {
                        Thread thread = new Thread(r);
                        thread.setName("myThread");
                        return thread;
                    }
                },
                new ThreadPoolExecutor.AbortPolicy());

        //threadPoolExecutor.submit();
        threadPoolExecutor.execute(new MyThread());//提交任務
        threadPoolExecutor.shutdown();//關閉執行緒池


    }
}

class MyThread implements Runnable{

    @Override
    public void run() {
        for (int i=0;i<10;i++){
            System.out.println(i);
        }
    }
}

以上就是詳解Java實現多執行緒的三種方式的詳細內容，更多關於Java多執行緒的資料請關注it145.com其它相關文章！