1.初識多執行緒

1.概述

? 多執行緒（multithreading），是指從軟體或者硬體上實作多個執行緒并發執行的技術，具有多執行緒能力的計算機因有硬體支持而能夠在同一時間執行多于一個執行緒，進而提升整體處理性能，具有這種能力的系統包括對稱多處理機、多核心處理器以及芯片級多處理或同時多執行緒處理器，在一個程式中，這些獨立運行的程式片段叫作“執行緒”（Thread），利用它編程的概念就叫作“多執行緒處理” ，

2.原理

實作多執行緒是采用一種并發執行機制
并發執行機制原理：簡單地說就是把一個處理器劃分為若干個短的時間片，每個時間片依次輪流地執行處理各個應用程式，由于一個時間片很短，相對于一個應用程式來說，就好像是處理器在為自己單獨服務一樣，從而達到多個應用程式在同時進行的效果
多執行緒就是把作業系統中的這種并發執行機制原理運用在一個程式中，把一個程式劃分為若干個子任務，多個子任務并發執行，每一個任務就是一個執行緒，這就是多執行緒程式

3.優缺點

優點

使用執行緒可以把占據時間長的程式中的任務放到后臺去處理，
用戶界面可以更加吸引人，這樣比如用戶點擊了一個按鈕去觸發某些事件的處理，可以彈出一個進度條來顯示處理的進度，
程式的運行速度可能加快，
在一些等待的任務實作上如用戶輸入、檔案讀寫和網路收發資料等，執行緒就比較有用了，在這種情況下可以釋放一些珍貴的資源如記憶體占用等，
多執行緒技術在IOS軟體開發中也有舉足輕重的作用，

缺點

如果有大量的執行緒，會影響性能，因為作業系統需要在它們之間切換，
更多的執行緒需要更多的記憶體空間，
執行緒可能會給程式帶來更多“bug”，因此要小心使用，
執行緒的中止需要考慮其對程式運行的影響，
通常塊模型資料是在多個執行緒間共享的，需要防止執行緒死鎖情況的發生，

4.優勢

? 多行程程式結構和多執行緒程式結構有很大的不同，多執行緒程式結構相對于多行程程式結構有以下的優勢：

方便的通信和資料交換

? 執行緒間有方便的通信和資料交換機制，對于不同行程來說，它們具有獨立的資料空間，要進行資料的傳遞只能通過通信的方式進行，這種方式不僅費時，而且很不方便，執行緒則不然，由于同一行程下的執行緒之間共享資料空間，所以一個執行緒的資料可以直接為其他執行緒所用，這不僅快捷，而且方便，

更高效地利用CPU

? 使用多執行緒可以加快應用程式的回應，這對圖形界面的程式尤其有意義，當一個操作耗時很長時，整個系統都會等待這個操作，此時程式不會回應鍵盤、滑鼠、選單的操作，而使用多執行緒技術，將耗時長的操作置于一個新的執行緒，就可以避免這種尷尬的情況，

同時，多執行緒使多CPU系統更加有效，作業系統會保證當執行緒數不大于CPU數目時，不同的執行緒運行于不同的CPU上，

5.應用

? 無論是過去還是現在，世界上大多數計算機仍然采用的是馮·諾依曼結構，這種結構的特點就是順序處理，一個處理器在同個時刻只能處理一件事情， Windows 95/NT采用一種全新的任務調度策略，它把一個行程劃分為多個執行緒，每個執行緒輪流占用CPU的運算時間，作業系統不斷地把執行緒掛起、喚醒、再掛起、再喚程，如此反復，由于現在CPU的速度比較快，給人的感覺是多個執行緒在同時執行，就好像有多個CPU存在于計算機中一樣，

? 多執行緒的一個典型例子是：用資源管理器復制檔案時，一方面在進行磁盤讀寫操作，同時一張紙不停地從一個檔案夾飄到另一個檔案夾，這個飄的動作實際上是一段視頻剪輯，也就是說，資源管理器能夠同時進行磁盤讀寫和播放視頻剪輯，

2.執行緒與多執行緒

? 執行緒是系統對代碼的執行行程，如果將系統當做一個員工，被安排執行某個任務的時候，他不會對任何其他的任務作出回應，只有當這個任務執行完畢，才可以重新給他分配任務，縛一個程式都有一個主執行緒，負責執行程式必要的任務，

? 當我們處理一個消耗大的任務（如上傳或下載圖片），如果讓主執行緒執行這個任務，它會等到動作完成，才繼續后面的代碼，在這段時間之內，主執行緒處于“忙碌”狀態，也就是無法執行任何其他功能，體現在界面上就是，用戶的界面完全“卡死” ，

? 多執行緒是指，將原本線性執行的任務分開成若干個子任務同步執行，這樣做的優點是防止執行緒“堵塞”，增強用戶體驗和程式的效率，缺點是代碼的復雜程度會大大提高，而且對于硬體的要求也相應地提高，

3.執行緒的創建

1.繼承Thread類

/**
 * 創建執行緒方式一：
 * 1.繼承Thread類  
 * 2.重寫run方法  
 * 3.呼叫start開啟執行緒
 * 注意：執行緒不一定開啟就立即執行，有cpu調度執行
 */
public class TestThread1 extends Thread{
    @Override
    public void run() {
        //run方法執行緒體
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代碼"+i);
        }
    }

    public static void main(String[] args) {

        //創建一個執行緒物件，并呼叫start()方法開啟執行緒
        TestThread1 testThread1 = new TestThread1();
        testThread1.start();

        //main執行緒，主執行緒
        for (int i = 0; i < 2000; i++) {
            System.out.println("我在學習多執行緒"+i);
        }
    }
}

練習Thread,實作多執行緒同步下載圖片

import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;

//練習Thread,實作多執行緒同步下載圖片
public class TestThread2 extends Thread {

    private String url;
    private String name;

    public TestThread2(String url,String name){
        this.url = url;
        this.name = name;
    }

    //下載圖片執行緒的執行體
    @Override
    public void run() {
        WebDownLoader webDownLoader = new WebDownLoader();
        webDownLoader.downloader(url,name);
        System.out.println("下載了檔案名為："+name);
    }

    public static void main(String[] args) {
        TestThread2 t1 = new TestThread2("https://img2.baidu.com/it/u=2299066483,869409599&fm=253&fmt=auto&app=120&f=JPEG?w=1000&h=500","1.jpeg");
        TestThread2 t2 = new TestThread2("https://img2.baidu.com/it/u=2299066483,869409599&fm=253&fmt=auto&app=120&f=JPEG?w=1000&h=500","2.jpeg");
        TestThread2 t3 = new TestThread2("https://img2.baidu.com/it/u=2299066483,869409599&fm=253&fmt=auto&app=120&f=JPEG?w=1000&h=500","3.jpeg");
        //多執行緒的執行不一定按順序，順序由cpu調度
        t1.start();
        t2.start();
        t3.start();
    }
}

class WebDownLoader{
    //下載方法
    public void downloader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO例外，Downloader方法出現問題");
        }
    }
}

2.實作Runnable介面，重寫run()方法

/**
 * 創建執行緒方式二: 
 * 1.實作Runnable介面 
 * 2.重寫run()方法  
 * 3.執行執行緒需要丟入runnable介面實作類，呼叫start()方法開啟執行緒
 */

public class TestTheadRunnable1 implements Runnable {

    public void run() {
        //執行緒執行體
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代碼-----"+i);
        }
    }

    public static void main(String[] args) {
        TestTheadRunnable1 testTheadRunnable = new TestTheadRunnable1();
//        Thread thread = new Thread(testTheadRunnable);
//        thread.start();
        new Thread(testTheadRunnable).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("我在學習多執行緒*****"+i);
        }
    }
}

練習Thread，實作多執行緒同步下載圖片

import com.dzj.thread.TestThread2;
import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

//練習Thread,實作多執行緒同步下載圖片
public class TestThreadRunnable2 implements Runnable {

    private String url;
    private String name;

    public TestThreadRunnable2(String url,String name){
        this.url = url;
        this.name = name;
    }

    //下載圖片執行緒的執行體
    public void run() {
        WebDownLoader2 webDownLoader = new WebDownLoader2();
        webDownLoader.downloader(url,name);
        System.out.println("下載了檔案名為："+name);
    }

    public static void main(String[] args) {
        TestThread2 t1 = new TestThread2("https://img2.baidu.com/it/u=2299066483,869409599&fm=253&fmt=auto&app=120&f=JPEG?w=1000&h=500","1.jpeg");
        TestThread2 t2 = new TestThread2("https://img2.baidu.com/it/u=2299066483,869409599&fm=253&fmt=auto&app=120&f=JPEG?w=1000&h=500","2.jpeg");
        TestThread2 t3 = new TestThread2("https://img2.baidu.com/it/u=2299066483,869409599&fm=253&fmt=auto&app=120&f=JPEG?w=1000&h=500","3.jpeg");
        //多執行緒的執行不一定按順序，順序由cpu調度
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
    }
}

class WebDownLoader2{
    //下載方法
    public void downloader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO例外，Downloader方法出現問題");
        }
    }
}

3.實作Callable介面，重寫call()介面

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

/**
 * 創建執行緒方式三：
 *  1.實作Callable介面 
 *  2.重寫call方法 
 *  3.創建服務  
 *  4.提交執行 
 *  5.獲取結果 
 *  6.關閉服務
 * callable的好處
 *  1.可以定義回傳的值
 *  2.可以拋出例外
 */
//利用callable下載圖片案例
public class ThreadCallable implements Callable<Boolean> {
    private String url;
    private String name;

    public ThreadCallable(String url,String name){
        this.url = url;
        this.name = name;
    }

    //下載圖片執行緒的執行體
    @Override
    public Boolean call() {
        WebDownLoader webDownLoader = new WebDownLoader();
        webDownLoader.downloader(url,name);
        System.out.println("下載了檔案名為："+name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ThreadCallable t1 = new ThreadCallable("https://img2.baidu.com/it/u=2299066483,869409599&fm=253&fmt=auto&app=120&f=JPEG?w=1000&h=500","1.jpeg");
        ThreadCallable t2 = new ThreadCallable("https://img2.baidu.com/it/u=2299066483,869409599&fm=253&fmt=auto&app=120&f=JPEG?w=1000&h=500","2.jpeg");
        ThreadCallable t3 = new ThreadCallable("https://img2.baidu.com/it/u=2299066483,869409599&fm=253&fmt=auto&app=120&f=JPEG?w=1000&h=500","3.jpeg");
        //多執行緒的執行不一定按順序，順序由cpu調度
        //創建執行服務
        ExecutorService service = Executors.newFixedThreadPool(3);

        //提交執行
        Future<Boolean> r1 = service.submit(t1);
        Future<Boolean> r2 = service.submit(t2);
        Future<Boolean> r3 = service.submit(t3);

        //獲取結果
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();

        //關閉服務
        service.shutdownNow();

        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);
    }
}

class WebDownLoader{
    //下載方法
    public void downloader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO例外，Downloader方法出現問題");
        }
    }
}

4.多執行緒案例

1.模擬購票

//發現問題，多個執行緒操作同一個資源的情況下，執行緒不安全，資料紊亂，這就是執行緒的并發問題？
public class TestThreadTicket implements Runnable {
    private int ticket = 10;
    public void run() {
        while(true){

            if(ticket<=0)
                break;

            //模擬延時，放大問題的發生性
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+"拿到了第"+ticket--+"張票");
        }
    }

    public static void main(String[] args) {
        TestThreadTicket ticket = new TestThreadTicket();
        new Thread(ticket,"小明").start();
        new Thread(ticket,"小江").start();
        new Thread(ticket,"小紅").start();
    }
}

2.模擬龜兔賽跑

//模擬龜兔賽跑
public class Race implements Runnable {

    private static String winner;
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if(Thread.currentThread().getName().equals("兔子") && i%10==1){
                try {
                    Thread.sleep(1);//兔子正在睡覺
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //判斷比賽是否結束
            boolean flag = gameOver(i);
            if(flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
        }
    }
    private boolean gameOver(int steps){
        if(winner!=null){//已經存在勝利者了
            return true;
        }{
            if(steps>=100){
                winner = Thread.currentThread().getName();
                System.out.println("winner is "+winner);
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        Race race = new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"烏龜").start();
    }
}

5.介面實作類（lambda）

1.實作類的多種寫法

package com.dzj.lambda;

public class TestLambda1 {
    //3.寫法二：靜態內部類
    static class Like2 implements ILike{
        public void lambda() {
            System.out.println("I like lambda2");
        }
    }
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();
        System.out.println("方式1："+like.getClass().getClassLoader());

        like = new Like2();
        like.lambda();
        System.out.println("方式2："+like.getClass().getClassLoader());

        //4.寫法三：區域內部類
        class Like3 implements ILike{
            public void lambda() {
                System.out.println("I like lambda3");
            }
        }
        like = new Like3();
        like.lambda();
        System.out.println("方式3："+like.getClass().getClassLoader());

        //5.寫法四：匿名內部類,沒有類的名稱，必須借助介面或者父類
        like = new ILike(){
            @Override
            public void lambda() {
                System.out.println("I like lambda4");
            }
        };
        like.lambda();
        System.out.println("方式4："+like.getClass().getClassLoader());

        //6.寫法五：用lambda簡化
        like = ()-> System.out.println("I like lambda5");
        like.lambda();
        System.out.println("方式5："+like.getClass().getClassLoader());
    }
}

//1.定義一個函式式介面
interface ILike{
    void lambda();
}

//2.寫法一：實作類
class Like implements ILike{
    public void lambda() {
        System.out.println("I like lambda1");
    }
}

2.帶參的實作類寫法

package com.dzj.lambda;

public class TestLambda2 {
    //3.靜態內部類
    static class Love2 implements ILove{
        //注意：這里加上static修飾Love2是因為main是靜態方法，它不能訪問類中得非靜態方法、變數
        @Override
        public void love(int a) {
            System.out.println("i love you -->"+a);
        }
    }

    public static void main(String[] args) {
        ILove like= new Love();
        like.love(1);

        like = new Love2();
        like.love(2);

        //4.區域內部類
        class Love3 implements ILove{
            @Override
            public void love(int a) {
                System.out.println("i love you -->"+a);
            }
        }
        like = new Love3();
        like.love(4);

        //5.匿名內部類
        like = new ILove() {
            @Override
            public void love(int a) {
                System.out.println("i love you -->"+a);
            }
        };
        like.love(5);

        //6.lambda簡化
        like = a -> System.out.println("i love you -->"+a);
        like.love(6);
    }
}

//1.定義一個函式式介面
interface ILove{
    void love(int a);
}

//2.實作類
class Love implements ILove{
    @Override
    public void love(int a) {
        System.out.println("i love you -->"+a);
    }
}

3.lambda運算式實作介面

前提：

JDK8的新特性
必須為函式式介面：介面中只有一個方法

package com.dzj.lambda;

public class TestLambda3 {
    public static void main(String[] args) {
        ILoveU like = null;
        //使用lambda運算式
//        like = (int a) ->{
//            System.out.println("i love you-->"+a);
//        };
//        like.Love(520);

        /**
         * lambda的簡化
         * 1.引數型別可以簡化
         * 2.只有一個引數的時，()也可以省略
         * 3.方法體里只有一條陳述句時，{}也可以省略
         */
        like = (a,b,c) ->{
            System.out.println("i love you-->"+a+b+c);
        };
        like.Love(520,502,"dengzhijiang");

    }

}

//1.定義一個函式式介面
interface ILoveU{
    void Love(int a,int b,String c);
}

6.靜態代理模式

/**
 * 靜態代理模式
 *      真實物件和代理物件都要實作同一個介面，
 *      代理物件要代理真實物件
 * 好處：
 *      真實物件只需專注自己要干的事情
 *      代理物件可以幫助處理一些雜事，比如布置現場、主持婚禮等
 */
public class StaticProxy {

    public static void main(String[] args) {
        //真實角色
        You you = new You();

        //把需要代理的真實角色傳給代理物件
        WeddingCompany weddingCompany = new WeddingCompany(you);

        //代理物件執行業務
        weddingCompany.HappyMarry();

        //使用lambda運算式實作執行緒
        new WeddingCompany(new You()).HappyMarry();
        new Thread(()-> System.out.println("nihao")).start();

    }
}

//真實物件要干的事情
interface Marry{
    void HappyMarry();
}

//真實角色
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("朋友結婚了...");
    }
}

//代理角色
class WeddingCompany implements Marry{

    //定義一個要被代理的目標物件（真實角色）
    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        BeforeMarry();//結婚前
        this.target.HappyMarry();//結婚，真正的執行物件其實還是真實角色
        AfterMarry();//結婚后
    }

    private void AfterMarry() {
        System.out.println("結婚之后，洞房花燭夜");
    }

    private void BeforeMarry() {
        System.out.println("結婚之前，布置現場");
    }
    
}

7.執行緒的狀態

1.執行緒的五大狀態

1. 新建狀態(New): 執行緒物件被創建后，就進入了新建狀態，

例如，Thread thread = new Thread()，

2. 就緒狀態(Runnable): 也被稱為“可執行狀態”，執行緒物件被創建后，其它執行緒呼叫了該物件的start()方法，從而來啟動該執行緒，

例如，thread.start()，處于就緒狀態的執行緒，隨時可能被CPU調度執行，
不允許對一個執行緒多次使用start，
執行緒執行完成之后，不能試圖用start將其喚醒，

其他狀態 ---> 就緒
執行緒呼叫start()，新建狀態轉化為就緒狀態，
執行緒sleep(long)時間到，等待狀態轉化為就緒狀態，
阻塞式IO操作結果回傳，執行緒變為就緒狀態，
其他執行緒呼叫join()方法，結束之后轉化為就緒狀態，
執行緒物件拿到物件鎖之后，也會進入就緒狀態，

3. 運行狀態(Running): 執行緒獲取CPU權限進行執行，需要注意的是，執行緒只能從就緒狀態進入到運行狀態，

處于就緒狀態的執行緒獲得了CPU之后，真正開始執行run()方法的執行緒執行體時，意味著該執行緒就已經處于運行狀態，需要注意的是，對于單處理器，一個時刻只能有一個執行緒處于運行狀態，對于搶占式策略的系統來說，系統會給每個執行緒一小段時間處理各自的任務，時間用完之后，系統負責奪回執行緒占用的資源，下一段時間里，系統會根據一定規則，再次進行調度，

運行狀態 ---> 就緒狀態
執行緒失去處理器資源，執行緒不一定完整執行的，執行到一半，說不定就被別的執行緒搶走了，
呼叫yield()靜態方法，暫時暫停當前執行緒，讓系統的執行緒調度器重新調度一次，它自己完全有可能再次運行，
提示調度程式，當前執行緒愿意放棄當前對處理器的使用，這時，當前執行緒將會被置為就緒狀態，和其他執行緒一樣等待調度，這時候根據不同優先級決定的概率，當前執行緒完全有可能再次搶到處理器資源，

4. 阻塞狀態(Blocked): 阻塞狀態是執行緒因為某種原因放棄CPU使用權，暫時停止運行，直到執行緒進入就緒狀態，才有機會轉到運行狀態，阻塞的情況分三種：

(01) 等待阻塞 -- 通過呼叫執行緒的wait()方法，讓執行緒等待某作業的完成，
(02) 同步阻塞 -- 執行緒在獲取synchronized同步鎖失敗(因為鎖被其它執行緒所占用)，它會進入同步阻塞狀態，
(03) 其他阻塞 -- 通過呼叫執行緒的sleep()或join()或發出了I/O請求時，執行緒會進入到阻塞狀態，當sleep()狀態超時、join()等待執行緒終止或者超時、或者I/O處理完畢時，執行緒重新轉入就緒狀態，

5. 死亡狀態(Dead): 執行緒執行完了或者因例外退出了run()方法，該執行緒結束生命周期，

run()和call()執行緒執行體中順利執行完畢，執行緒正常終止，
執行緒拋出一個沒有捕獲的Exception或Error，
需要注意的是：主線成和子執行緒互不影響，子執行緒并不會因為主執行緒結束就結束，

2.狀態案例說明

1.觀察執行緒狀態

public class ThreadState{

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("執行緒結束了");
        });

        //觀察狀態
        Thread.State state = thread.getState();
        System.out.println(state);//new

        //觀察啟動后
        thread.start();//run
        state = thread.getState();
        System.out.println(state);

        while(state != Thread.State.TERMINATED){//只要執行緒不終止，就一直輸出狀態
            Thread.sleep(100);
            state = thread.getState();
            System.out.println(state);
        }

//        thread.start();
        //執行緒中斷或者結束，一旦進入死亡狀態，就不能再次啟動
    }
}

2.模擬網路延時（sleep）

//模擬網路延時，放大問題的發生性
public class ThreadSleep implements Runnable {
    private int ticket = 10;
    public void run() {
        while(true){

            if(ticket<=0)
                break;

            //模擬延時
            try {
                Thread.sleep(100);//執行緒就如阻塞狀態
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+"拿到了第"+ticket--+"張票");
        }
    }

    public static void main(String[] args) {
        ThreadSleep ticket = new ThreadSleep();
        new Thread(ticket,"小明-->").start();
        new Thread(ticket,"老師-->").start();
        new Thread(ticket,"黃牛黨-->").start();
    }
}

3.模擬倒計時

import java.text.SimpleDateFormat;
import java.util.Date;

public class ThreadSleep2 {

    public static void main(String[] args) throws InterruptedException {
        tenDown();

        Date date = new Date(System.currentTimeMillis());//獲取系統當前時間

        while(true){
            Thread.sleep(1000);//執行緒就如阻塞狀態
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
            date = new Date(System.currentTimeMillis());//更新系統時間
        }

    }


    //模擬倒計時
    public static void tenDown() throws InterruptedException {
        int num = 10;
        while(true){
            Thread.sleep(1000);
            System.out.println(num--);
            if(num<=0)
                break;
        }
    }
}

4.測驗執行緒終止

/**
 * 測驗執行緒停止
 * 1.建議執行緒正常停止--->利用次數，不建議死回圈
 * 2.建議使用標志位--->設定一個標志位
 * 3.不要使用stop和destroy等過時或者JDK不建議使用的方法
 */
public class ThreadStop implements Runnable {

    //定義一個標志位
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("run......Thread-->"+i++);
        }

    }

    //設定一個公開的方法，停止執行緒，轉換標志位
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {

        ThreadStop threadStop = new ThreadStop();
        new Thread(threadStop).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main"+i);
            if(i==500){  //呼叫方法，裝換標志位，終止執行緒
                threadStop.stop();
                System.out.println("該執行緒停止了...");
            }
        }
    }
}

8.執行緒的方法

1.執行緒休眠（sleep）

? 執行緒暫緩執行，等到預計時間再執行，執行緒休眠會交出CPU，讓CPU去執行其他的任務，但是有一點要非常注意，sleep方法不會釋放鎖，也就是說如果當前執行緒持有對某個物件的鎖，則即使呼叫sleep方法，其他執行緒也無法訪問這個物件，

public class ThreadSleep2 {

    public static void main(String[] args) throws InterruptedException {
        tenDown();

        Date date = new Date(System.currentTimeMillis());//獲取系統當前時間

        while(true){
            Thread.sleep(1000);//執行緒休眠
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
            date = new Date(System.currentTimeMillis());//更新系統時間
        }

    }
    
    //模擬倒計時
    public static void tenDown() throws InterruptedException {
        int num = 10;
        while(true){
            Thread.sleep(1000);
            System.out.println(num--);
            if(num<=0)
                break;
        }
    }
}

2.執行緒讓步（yield）

? 暫停當前正在執行的執行緒物件，并執行其它執行緒，就是當前執行緒交出cpu權限，讓cpu執行其他執行緒，

yield()和sleep()的比較

相同點
- 交出CPU，但是不會交出鎖
不同點
- yield不能控制具體的交出cpu時間，并且yield()只能讓相同優先級的執行緒有獲取cpu執行的機會，
- yield()不會進入阻塞，直接進入就緒狀態，

/**
 * 測驗執行緒禮讓
 * 禮讓不一定成功，看CPU調度
 */
public class ThreadYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }
}

class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"執行緒開始執行");
        if(Thread.currentThread().getName().equals("a"))
            Thread.yield();//執行緒禮讓，禮讓不一定成功
        System.out.println(Thread.currentThread().getName()+"執行緒停止執行");
    }
}

3.執行緒插隊（join）

? 如果在當前執行緒（main或其他執行緒）中呼叫執行緒物件join,當前執行緒阻塞，直到執行緒物件的run執行完畢，當前執行緒阻塞才結束，繼續執行，

public class ThreadJoin implements Runnable{

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

    public static void main(String[] args) throws InterruptedException {
        ThreadJoin threadJoin = new ThreadJoin();
        Thread thread = new Thread(threadJoin);
//        thread.start();
        for (int i = 0; i < 20; i++) {
            if (i==5){
                thread.start();//開啟執行緒
                thread.join();//插隊,但是如果“thread.start()”放在回圈體的外部，在插隊之前的200次里，兩個執行緒還是并發的
            }

            System.out.println("main"+i);
        }
    }
}

9.執行緒優先級

/**
 * 執行緒優先級  1-10
 * 優先級低并意味著不會執行，只是先執行的概率低，
 * 優先級高也并不一定就優先執行，只是優先執行的概率高，這都是看CPU調度的
 */
public class ThreadPriority {
    public static void main(String[] args) {
        //主執行緒默認優先級
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();
        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);
        Thread t6 = new Thread(myPriority);

        //先設定優先級，再啟動
        t1.start();

        t2.setPriority(1);
        t2.start();

        t3.setPriority(4);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);
        t4.start();

        t5.setPriority(7);
        t5.start();

        t6.setPriority(8);
        t6.start();
    }
}


class MyPriority implements Runnable{
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

10.守護執行緒

/**
 * 測驗守護執行緒
 * 上帝守護你
 */
public class ThreadDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);
        thread.setDaemon(true);//設定為守護執行緒，默認false表示是用戶執行緒，正常的執行緒都是用戶執行緒
        thread.start();//上帝守護執行緒啟動，虛擬機不會等待守護執行緒執行完畢

        new Thread(you).start();// 你(默認用戶執行緒)  用戶執行緒啟動
    }

}

//上帝
class God implements Runnable{

    @Override
    public void run() {
        while(true){
            System.out.println("上帝一直守護著你");
        }
    }
}

//你
class You implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {  //人生不過三萬天
            System.out.println("你一生都開心的活著...");
        }
        System.out.println("=====GoodBey!World!=====");
    }
}

11.鎖機制

1.不安全的買票

/**
 * 不安全的買票
 * 執行緒不安全，有負數
 * 解決方法：加鎖，實作執行緒同步
 */
public class UnsafeBuyTicket {
    public static void main(String[] args) {

        BuyTicket station = new BuyTicket();
        new Thread(station,"你們").start();
        new Thread(station,"我").start();
        new Thread(station,"黃牛黨").start();
    }
}

class BuyTicket implements Runnable{

    //票
    private int ticketNum = 10;
    boolean flag = true;

    @Override
    public void run() {
        while(flag){
            try {
                Buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //買票,synchronized,同步方法，默認鎖的物件是this
    public synchronized void Buy() throws InterruptedException {

        //判斷是否有票
        if(ticketNum <= 0){
            this.flag = false;
            return;
        }
        Thread.sleep(1000);
        System.out.println(Thread.currentThread().getName()+"--->拿到了第"+ticketNum--+"票");
    }
}

2.不安全的取錢

/**
 * 不安全的取錢，同時對同一個賬戶取錢
 * 兩個人去銀行取錢，賬戶
 */
public class UnsafeBank {
    public static void main(String[] args) {
        //賬戶
        Account account = new Account(1000,"結婚基金");
        Drawing you = new Drawing(account,50, "You");
        Drawing girlFriend = new Drawing(account,100, "girlFriend");

        you.start();
        girlFriend.start();

    }
}

//賬戶
class Account{
    int money;//余額
    String name;//賬戶名

    public Account(int money,String name){
        this.money = money;
        this.name = name;
    }
}

//銀行：模擬取錢
class Drawing extends Thread{

    Account account;//賬戶
    int drawingMoney;//取了多少錢
    int nowMoney;//現在手里有多少錢

    public Drawing(Account account,int drawingMoney,String name){
        super(name);//執行緒的名字
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    //取錢
    @Override
    public void run() {
        /**
         * synchronized默認鎖的物件是this
         * 但是上鎖的物件不能一定就是this，
         * 上鎖的那個物件應該是變化的、需要修改的資料量、執行緒共同操作的資源、需要增刪改的物件
         */
        synchronized(account){
            //判斷有沒有錢
            if(account.money-drawingMoney < 0){
                System.out.println(Thread.currentThread().getName()+"-->錢不夠，取不了");
                return;
            }

            //模擬延時，放大問題的發生性
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //卡內余額 = 余額 - 你取的錢
            account.money = account.money - drawingMoney;
            //你手里的錢
            nowMoney = nowMoney + drawingMoney;

            System.out.println(account.name+"余額為："+account.money+"萬");
            //Thread.currentThread().getName() = this.getName(),因為這個類繼承了Thread，所以可以當前類呼叫Thread方法
            System.out.println(this.getName()+"手里的錢："+nowMoney+"萬");
        }
    }
}

3.執行緒不安全的集合

import java.util.ArrayList;
import java.util.List;

public class UnsafeList {

    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        Thread.sleep(150);
        //注意：這里sleep()時間太短的話，其他執行緒還沒執行完畢，執行緒里的add()還沒執行完畢，
        //很可能主執行緒已經執行完畢（回圈體），得到的size()就是主執行緒執行完畢那一瞬間的長度，
        //所以這里的sleep()要設定的大點，等其他執行緒執行完畢，再把size()輸出
        System.out.println(list.size());
    }
}

4.執行緒安全的 JUC

import java.util.concurrent.CopyOnWriteArrayList;
/**
 * 因為本身就是執行緒安全的，所以無需外部再提供安全機制
 */
public class TestJUC {
    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        Thread.sleep(100);
        System.out.println(list.size());
    }
}

5.死鎖

public class DeadLock {
    public static void main(String[] args) {

        MakeUp g1 = new MakeUp(0,"灰姑涼");
        MakeUp g2 = new MakeUp(1,"白雪公舉");
        g1.start();
        g2.start();
    }
}

//口紅
class LipStick{

}

//鏡子
class Mirror{

}

class MakeUp extends Thread{

    //需要的資源只有一分，用static保證只有一份
    static LipStick lipStick = new LipStick();
    static Mirror mirror = new Mirror();

    int choice;//選擇
    String girlName;//使用化妝品的女孩

    MakeUp(int choice,String girlName){
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {
        //化妝
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void makeup() throws InterruptedException {
        /**
         * 死鎖的產生：
         *     一個拿著lipStick鎖不松開，還要mirror鎖；
         *     另一個拿著mirror鎖不松開，還要lipStick，形成僵持狀態
         * 解決的方法：不能同時抱住多把鎖，用完要及時松開
         */
        if(choice==0){
            synchronized (lipStick){
                System.out.println(this.girlName+"獲得口紅的鎖");
                Thread.sleep(1000);
//                //一秒鐘后想獲得鏡子的鎖，此時g2中的mirror鎖還沒有釋放，所以獲取不到
//                synchronized (mirror){
//                    System.out.println(this.girlName+"獲得鏡子的鎖");
//                }
            }
            //一秒鐘后想獲得鏡子的鎖，此時lipStick鎖已釋放，等待g2釋放mirror鎖并獲取
            synchronized (mirror){
                System.out.println(this.girlName+"獲得鏡子的鎖");
            }
        }else{
            synchronized (mirror){
                System.out.println(this.girlName+"獲得鏡子的鎖");
                Thread.sleep(2000);
//                //兩秒鐘后想獲得鏡子的鎖，此時g1中的lipStick鎖還沒有釋放，所以獲取不到
//                synchronized (lipStick){
//                    System.out.println(this.girlName+"獲得口紅的鎖");
//                }
            }
            //兩秒鐘后想獲得鏡子的鎖，此時mirror鎖已釋放，等待g1釋放lipStick鎖并獲取
            synchronized (lipStick){
                System.out.println(this.girlName+"獲得口紅的鎖");
            }
        }
    }
}

6.測驗 lock

public class TestLock {

    public static void main(String[] args) {
        Buyticket buyticket = new Buyticket();
        new Thread(buyticket,"小明").start();
        new Thread(buyticket,"我").start();
        new Thread(buyticket,"黃牛黨").start();
    }
}

class Buyticket implements Runnable{

    private int ticketNum = 10;
    private final ReentrantLock lock = new ReentrantLock();//ReentrantLock可重用鎖

    @Override
    public void run() {
            while(true){
                try {
                    lock.lock();
                    if(ticketNum>0){
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNum--+"票");
                    }else{
                        break;
                    }
                }finally {
                    lock.unlock();//釋放鎖
                }
        }

    }
}

12.生產者消費者模型

1.管程法

/**
 * 測驗：生產者消費者模型-->利用緩沖區解決：管程法
 * 生產者、消費者、產品、緩沖區
 */

public class TestPC {

    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new Productor(container).start();
        new Consumer(container).start();
    }
}

//生產者
class Productor extends Thread{
    SynContainer container;

    public Productor(SynContainer container) {
        this.container = container;
    }

    //生產
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            container.push(new Chicken(i));
            System.out.println("生產了第"+i+"只雞");
        }
    }
}

//消費者
class Consumer extends Thread{
    SynContainer container;

    public Consumer(SynContainer container) {
        this.container = container;
    }

    //消費
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消費了-->第"+container.pop().id+"只雞");
        }
    }
}

//產品
class Chicken{
    int id;//產品編號

    public Chicken(int id) {
        this.id = id;
    }
}

//緩沖區
class SynContainer{

    Chicken[] chickens = new Chicken[10]; //需要一個容器大小
    int count = 0;//容器計數器

    //生產者放入產品
    public synchronized void push(Chicken chicken){
        //如果容器滿了，就需要等待消費者消費
        if(count==chickens.length){
            //通知消費者消費，生產等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果沒有滿，我們就需要就可以繼續丟進產品
        chickens[count] = chicken;
        count++;
        //通知消費者消費,喚醒等待的消費者？
        this.notifyAll();
    }

    //消費者消費產品
    public synchronized Chicken pop(){
        //判斷能否消費
        if(count==0){
            //等待生產者生產，消費者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果可以消費
        count--;
        Chicken chicken = chickens[count];
        //吃完了，通知生產者生產，喚醒等待生產的生產者
        this.notifyAll();
        return chicken;
    }

}

2.信號燈法

/**
 * 測驗生產者消費者問題2：信號燈法，標志位解決
 *
 */
public class TestPC2 {

    public static void main(String[] args) {

        TV tv = new TV();
        new Actor(tv).start();
        new Watcher(tv).start();
    }
}

//生產者-->演員
class Actor extends Thread{
    TV tv;
    public Actor(TV tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i%2==0){
                this.tv.play("厲害了了我的國播放中...");
            }else{
                this.tv.play("抖音：記錄美好生活");
            }
        }
    }
}

//消費者-->觀眾
class Watcher extends Thread{

    TV tv;
    public Watcher(TV tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}

//產品-->節目
class TV{
    //演員表演，觀眾等待 T
    //觀眾觀看，演員等待 F
    String voice;//表演的節目
    boolean flag = true;

    //表演
    public synchronized void play(String voice){
        if(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演員表演了："+voice);
        //通知觀眾觀看
        this.notifyAll();//通知喚醒
        this.voice = voice;
        this.flag = ! this.flag;
    }

    //觀看
    public synchronized void watch(){
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("觀看了："+voice);
        //通知演員表演
        this.notifyAll();
        this.flag = !this.flag;
    }
}

13.執行緒池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPool {
    public static void main(String[] args) {
        
        //1.創建服務，創建執行緒池,newFixedThreadPool()引數為執行緒池大小
        ExecutorService service = Executors.newFixedThreadPool(10);

        //執行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //2.關閉連接
        service.shutdown();

//        new Thread(new MyThread()).start();
//        new Thread(new MyThread()).start();
    }
}

class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

14.回顧

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

/**
 * 回顧執行緒的創建方式
 */
public class ThreadNew {
    public static void main(String[] args){

        new MyThread1().start();//方式一
        new Thread(new MyThread2()).start();//方式二

        //方式三
        FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyThread3());
        new Thread(futureTask).start();

        try {
            Integer integer = futureTask.get();
            System.out.println(integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

//1.繼承Thread
class MyThread1 extends Thread{

    @Override
    public void run() {
        System.out.println("MyThread1");
    }
}

//2.實作Runnable介面
class MyThread2 implements Runnable{

    @Override
    public void run() {
        System.out.println("MyThread2");
    }
}

//3.實作Callable介面
class MyThread3 implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        System.out.println("MyThread3");
        return 100;
    }
}

本文來自博客園，作者：小公羊，轉載請注明原文鏈接：https://www.cnblogs.com/aadzj/p/15313995.html

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/301637.html

標籤：Java

上一篇：Group By 深度優化，真是絕了！

下一篇：Spring Boot Actuator 健康檢查、度量、指標收集、監控，一文搞定！

Java多執行緒