Java基礎鞏固(二)——多執行緒

1.基本概念

• 程式是指令和資料的有序集合，其本身沒有任何運行的含義，是一個靜態的概念，
• 行程是執行程式的一次執行程序，它是一個動態的概念，是系統資源分配的單位，
• 一個行程可以包含若干個執行緒，執行緒是cpu調度和執行的單位，
• 行程是資源分配的最小單位，執行緒是程式執行的最小單位；
• 在程式運行時，即使沒有自己創建執行緒，后臺也會有多個執行緒，如主執行緒、gc執行緒；
• 在一個行程中，如果開辟了多個執行緒，執行緒的運行由調度器安排調度，調度器是與作業系統緊密相關的，先后順序是不能認為干預的；

2.執行緒的創建方式

• 通過繼承Thread類來創建

//創建執行緒方式一：繼承Thread類，重寫run()方法
public class ThreadPractice extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("正在運行執行緒一__" + i);
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 200; i++) {
            System.out.println("正在運行       主執行緒__" + i);
        }
/* xx.start()和xx.run()是不同的，前者是創建行程，后者是運行任務，前者執行緒與主執行緒同時進行，后者根據主執行緒中的順序先后進行 */
        ThreadPractice thread1 = new ThreadPractice();
        thread1.start();        
//      thread1.run();
    }
}

• 通過實作Runnable介面來創建（可以實作多個執行緒對同一個物件的呼叫，避免了單繼承的局限性）

//創建執行緒方式二：實作Runnable介面
public class ThreadPractice3 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("正在運行執行緒一__" + i);
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 200; i++) {
            System.out.println("正在運行       主執行緒__" + i);
        }
        ThreadPractice3 thread1 = new ThreadPractice3();
        new Thread(thread1).start();
    }
}

• 通過實作Callable介面來創建（優點是可以定義回傳值型別，拋出例外）

public class ThreadPractice4 implements Callable<Boolean> {

    private String name;
    private int age;

    public ThreadPractice4(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public Boolean call() {
        test test1 = new test();
        test1.Show(name, age);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ThreadPractice4 thread1 = new ThreadPractice4("小白",15);
        ThreadPractice4 thread2 = new ThreadPractice4("小黑",20);
        ThreadPractice4 thread3 = new ThreadPractice4("小紅",30);

        //創建執行服務
        ExecutorService service = Executors.newFixedThreadPool(3);
        //提交執行
        Future<Boolean> r1 = service.submit(thread1);
        Future<Boolean> r2 = service.submit(thread2);
        Future<Boolean> r3 = service.submit(thread3);
        //獲取結果
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();
        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);
        //關閉服務
        service.shutdownNow();
    }
}


class test {
    public void Show(String name, int age) {
        System.out.println("這個人叫" + name + "，今年" + age + "歲，");
    }
}

此方法總結為以下幾步：

1. 實作Callable介面，需要回傳值型別，例如上訴例子的Boolean
2. 重寫call方法，需要拋出例外
3. 創建目標物件
4. 創建執行服務：ExecutorService service = Executors.newFixedThreadPool(1);
5. 提交執行：Future r1= service.submit(t1);
6. 獲取結果：boolean rs1 = r1.get();
7. 關閉服務：service.shutdownNow();

3.lambda運算式（包括五種類的演示）

interface Ilove{
    void love(int a);
}

//第一種，正常類
class Love implements Ilove {
    @Override
    public void love(int a) {
        System.out.println("i love  ->" + a);
    }
}


public class TestLambda {

    //第二種，靜態內部類
    static class Love2 implements Ilove {
        @Override
        public void love(int a) {
            System.out.println("i love2 ->" + a);
        }
    }

    public static void main(String[] args) {
        Ilove ilove = new Love();
        ilove.love(2);

        Ilove ilove2 = new Love2();
        ilove2.love(2);

        //第三種，區域內部類
        class Love3 implements Ilove {
            @Override
            public void love(int a) {
                System.out.println("i love3 ->" + a);
            }
        }

        Ilove ilove3 = new Love3();
        ilove3.love(2);

        //第四種，匿名內部類
        Ilove ilove4 = new Ilove() {
            @Override
            public void love(int a) {
                System.out.println("i love4 ->" + a);
            }
        };
        ilove4.love(2);

        //第五種，lambda運算式
        Ilove ilove5 = (int a) -> {
            System.out.println("i love5 ->" + a);
        };
        ilove5.love(2);

    }
}

4.執行緒狀態

創建、就緒、運行、阻塞、死亡

執行緒操作：

• 執行緒禮讓，Thread.yield()
• 執行緒插隊，Thread.join()
• 執行緒等待，Thread.sleep()
• 執行緒優先級，Thread.setPriority()、getPriority()
• 執行緒狀態，Thread.getState()
• 守護執行緒，Thread.setDaemon()

5.執行緒同步

synchronized

6.執行緒協作

標籤：其他

上一篇：Java后端開發——美團（牛客）

下一篇：記錄一下今天所學 9.22