java ：多執行緒實作的三種方式

一、并行、串行、并發

在了解java中多執行緒的三種實作方式之前，我們首先需要明白并行、串行、并發三個概念，

1.并行：多個CPU同時處理多個任務；

2.串行：單個CPU處理多個任務，當一個任務執行完成之后下一個任務才能夠執行；

3.并發：單個CPU處理多個任務，每個任務都會被分一定的時間片，一個任務執行一段時間無論完成與否都要切換另一個任務執行，

在java中多執行緒其實就是并發的一種模式，

二、java實作多執行緒的三種方式

我們以買咖啡為例，現在咖啡店只有一個視窗，將每一個人買咖啡的程序視為一個任務，

1.實作Runnable介面

package multithreading;

public class LRunnableOne {

    public static void buyCoffee(String name) {
        System.out.println(name + "開始買咖啡");
        System.out.println(name + "正在買咖啡");
        System.out.println(name + "買完了");
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(new lr("張三"));
        Thread t2 = new Thread(new lr("李四"));
        Thread t3 = new Thread(new lr("王五"));
        System.out.println("run方法并不會啟動新的執行緒，只是執行執行緒中run內的方法，仍然是在主執行緒上依次上進行");
        t1.run();
        t2.run();
        t3.run();
        System.out.println("start方法會啟動新的執行緒，并發執行");
        t1.start();
        t2.start();
        t3.start();
    }
}
class lr implements Runnable{

    String name;

    public lr(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        LRunnableOne.buyCoffee(name);
    }
}

 這里我們先是直接呼叫了run方法，又呼叫了start方法，這樣做是為了說明start方法與run方法的不同，start方法是啟動就緒的執行緒，然后呼叫執行緒內的run方法；run并不會啟動執行緒，只是執行其中的方法體，start方法只能呼叫一次，但是run方法可以呼叫多次，

2.繼承Thread類

package multithreading;

public class LThreadOne {

    public static void buyCoffee(String name) {
        System.out.println(name + "開始買咖啡");
        System.out.println(name + "正在買咖啡");
        System.out.println(name + "買完了");
    }

    public static void main(String[] args) {
        th th1 = new th("張三");
        th th2 = new th("李四");
        th th3 = new th("王五");
        th1.start();
        th2.start();
        th3.start();
    }
}

class th extends Thread {

    String name;

    public th(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        LThreadOne.buyCoffee(name);
    }
}

3.實作Callable介面

package multithreading;

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

public class LCallable {

    public static void buyCoffee(String name) {
        System.out.println(name + "開始買咖啡");
        System.out.println(name + "正在買咖啡");
        System.out.println(name + "買完了");
    }

    public static void main(String[] args) {
        lca l1 = new lca("張三");
        lca l2 = new lca("李四");
        lca l3 = new lca("王五");
        FutureTask futureTask1 = new FutureTask<>(l1);
        FutureTask futureTask2 = new FutureTask<>(l2);
        FutureTask futureTask3 = new FutureTask<>(l3);
        Thread thread1 = new Thread(futureTask1);
        Thread thread2 = new Thread(futureTask2);
        Thread thread3 = new Thread(futureTask3);
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

class lca implements Callable {

    String name;

    public lca(String name) {
        this.name = name;
    }

    @Override
    public String call() throws Exception {
        LCallable.buyCoffee(name);
        return null;
    }
}

以上就是java中三種實作多執行緒的方式，但是觀察以上結果我們也不難發現一個問題，一個視窗售賣咖啡，應該是一個人買完了另一個人才能開始買，還好這里僅僅是售賣咖啡，如果是銀行的存取款，就可能會出現一筆存款被取多次的問題，這就是執行緒的安全問題，

執行緒安全問題：當多個執行緒操作同一個資料時，可能會出現資料的例外，

具體解決執行緒安全問題就需要用到同步和互斥的概念了，

互斥：一個共享資源，A訪問時，其它的都被阻塞（不能訪問），當A訪問完成時另一個才能訪問；

同步：A的結果是B的前提，也就是A、B不能同時運行，

互斥是一種特殊的同步，而同步是更為復雜的互斥，

（本文僅作個人學習記錄用，如有紕漏敬請指正）

標籤：Java

上一篇：SpringCloud(九) - Nginx

下一篇：記一次多個Java Agent同時使用的類增強沖突問題及分析