多執行緒

執行緒簡介

Process程式與Thread執行緒：

• 程式是指令和資料的有序集合，其本身沒有任何執行的含義，是一個靜態的概念
• 程式是執行程式的一次執行過程，是一個動態的概念。是系統資源分配的單位
• 通常在一個程式中可以包含若干個執行緒，當然一個程式中至少有一個執行緒，不然沒有任何存在的意義。執行緒是CPU排程和執行的單位

**注意：**很多多執行緒是模擬出來的，正在的多執行緒是指由多個CPU，即多核，如伺服器。如果是模擬出來的多執行緒，即在一個CPU的情況下，在同一個時間點，CPU只能執行一個程式碼，因為切換得很快，所以有了同時執行的錯覺

• 執行緒就是獨立的執行路徑
• 在程式執行時，即使沒有自己建立執行緒，後臺也會有多個執行緒，如主執行緒，gc執行緒
• main（）稱之為主執行緒，為系統的入口，用於執行整個程式
• 在一個程式中，如果開闢了多個執行緒，執行緒的執行由排程器安排排程，排程器是與作業系統緊密相關的，先後順序是不能人為干預的
• 對同一份資源操作時，會存在資源搶奪的問題，需要加入併發控制
• 執行緒會帶來額外的開銷，如CPU排程時間，併發控制開銷
• 每個執行緒在自己跌的工作記憶體互動，記憶體控制不當會造成資料不一致

執行緒實現【重點】

• 三種建立方式：繼承Threda類【重點】，實現Runnable介面【重點，核心】，實現Callable介面【瞭解即可】

Thread類

• 自定義執行緒繼承Thread類
• 重寫run()方法，編寫執行緒執行體
• 建立執行緒物件，呼叫start()方法啟動執行緒

//建立執行緒方式1：繼承Thread類，重寫run()方法，呼叫start（）方法開啟執行緒
//總結：執行緒開啟不一定立即執行，由CPU排程執行
public class TestThread01 extends Thread{
    public void run(){
        //run方法執行緒體
        for (int i = 0; i <200 ; i++) {
            System.out.println("我在學java***"+i);
        }
    }

    public static void main(String[] args) {
        //main執行緒，主執行緒

        //建立一個執行緒物件
        TestThread01 t1 = new TestThread01();					//輸出結果是run方法執行緒與住執行緒交替執行
        //呼叫start方法，開啟執行緒-----------------注意，開啟執行緒不是呼叫重寫的run方法，是呼叫start方法
        t1.start();

        for (int i = 0; i <200 ; i++) {
            System.out.println("我在學多執行緒---"+i);				//但是如果將主執行緒的方法放在start之前執行，就需要主執行緒的執行完了再能輪到run線																//程，因為主執行緒自身沒有開啟多執行緒執行
        }
    }
}

使用多執行緒同時下載多張圖片

//聯絡Thread，實現多執行緒同步下載圖片
public class TestThread02 extends Thread{
    private String url;     //網路圖片地址
    private String name;    //儲存的檔名

    public TestThread02(String url,String name){    //構造器方法
        this.url=url;
        this.name=name;
    }

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

    }

    public static void main(String[] args) {
        TestThread02 t1 = new TestThread02("https://ss0.bdstatic.com/70cFvHSh_Q1YnxGkpoWK1HF6hhy/it/u=137628589,3436980029&fm=26&gp=0.jpg","皮卡丘");
        TestThread02 t2 = new TestThread02("https://ss1.bdstatic.com/70cFvXSh_Q1YnxGkpoWK1HF6hhy/it/u=3363295869,2467511306&fm=26&gp=0.jpg","貓");
        TestThread02 t3 = new TestThread02("https://ss0.bdstatic.com/70cFuHSh_Q1YnxGkpoWK1HF6hhy/it/u=1819216937,2118754409&fm=26&gp=0.jpg","哈士奇");
        TestThread02 t4 = new TestThread02("https://ss0.bdstatic.com/70cFuHSh_Q1YnxGkpoWK1HF6hhy/it/u=2956370624,4180433682&fm=26&gp=0.jpg","鬥魚");

        t1.start();
        t2.start();
        t3.start();					//列印輸出的結果順序與前面傳入的順序不一致，且多次執行順序也都不一樣
        t4.start();
    }
}

//下載器					//在配置檔案中匯入相應maven依賴（工具包），此處選擇commons-io，2.6版本
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方法出現問題");
        }
    }
}

Runnable

由於java單繼承的侷限性，推薦使用Runnable物件

• 定義MyRunnable類實現Runnable介面
• 實現run()方法，編寫執行緒執行體
• 建立執行緒物件，呼叫start()方法啟動執行緒

//建立執行緒方式2：實現Runnable介面,重寫run（）方法，執行執行緒需要丟入Runnable介面的實現類 ，呼叫start方法
public class TestThread03 implements Runnable{

    public void run(){
        //run方法執行緒體
        for (int i = 0; i <200 ; i++) {
            System.out.println("我在學java***"+i);
        }
    }
    public static void main(String[] args) {
        //建立runnable介面的實現類物件
        TestThread03 testThread03 = new TestThread03();
        //建立執行緒物件，通過執行緒物件來開啟執行緒
        //Thread thread = new Thread(testThread03);
        //thread.start();                           --------兩句可以簡寫為下面一句
        new Thread(testThread03).start();

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

//實現多執行緒同步下載圖片案例修改為實現Runnable介面
public class TestThread02 implements Runnable{
    private String url;     //網路圖片地址
    private String name;    //儲存的檔名

    public TestThread02(String url,String name){    //構造器方法
        this.url=url;
        this.name=name;
    }

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

    }

    public static void main(String[] args) {
        TestThread02 t1 = new TestThread02("https://ss0.bdstatic.com/70cFvHSh_Q1YnxGkpoWK1HF6hhy/it/u=137628589,3436980029&fm=26&gp=0.jpg","皮卡丘.jpg");
        TestThread02 t2 = new TestThread02("https://ss1.bdstatic.com/70cFvXSh_Q1YnxGkpoWK1HF6hhy/it/u=3363295869,2467511306&fm=26&gp=0.jpg","貓.jpg");
        TestThread02 t3 = new TestThread02("https://ss0.bdstatic.com/70cFuHSh_Q1YnxGkpoWK1HF6hhy/it/u=1819216937,2118754409&fm=26&gp=0.jpg","哈士奇.jpg");
        TestThread02 t4 = new TestThread02("https://ss0.bdstatic.com/70cFuHSh_Q1YnxGkpoWK1HF6hhy/it/u=2956370624,4180433682&fm=26&gp=0.jpg","鬥魚.jpg");
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
        new Thread(t4).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方法出現問題");
        }
    }
}

實現Callable介面

• 1.實現Callable介面，需要返回值型別
• 2.重寫call方法，需要丟擲異常
• 3.建立目標物件
• 4.建立執行服務：ExecutorService ser=Executors.newFixedThreadPool(1);
• 5.提交執行：Futureresult1=ser.submit(t1);
• 6.獲取結果：boolean r1=result1.get();
• 7.關閉服務：ser.shutdownNow();

示例：利用callable改造下載圖片案例

//執行緒建立方式3：實現callable介面
/*
*callable的好處
* 1.可以定義返回值
* 2.可以跑出異常
* 缺點：
* 執行比較複雜
* */
public class TestCallable implements Callable<Boolean>{

    private String url;     //網路圖片地址
    private String name;    //儲存的檔名

    public TestCallable(String url,String name){    //構造器方法
        this.url=url;
        this.name=name;
    }

    //下載圖片執行緒的執行體
    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 {
        TestCallable t1 = new TestCallable("https://ss0.bdstatic.com/70cFvHSh_Q1YnxGkpoWK1HF6hhy/it/u=137628589,3436980029&fm=26&gp=0.jpg","皮卡丘.jpg");
        TestCallable t2 = new TestCallable("https://ss1.bdstatic.com/70cFvXSh_Q1YnxGkpoWK1HF6hhy/it/u=3363295869,2467511306&fm=26&gp=0.jpg","貓.jpg");
        TestCallable t3 = new TestCallable("https://ss0.bdstatic.com/70cFuHSh_Q1YnxGkpoWK1HF6hhy/it/u=1819216937,2118754409&fm=26&gp=0.jpg","哈士奇.jpg");
        TestCallable t4 = new TestCallable("https://ss0.bdstatic.com/70cFuHSh_Q1YnxGkpoWK1HF6hhy/it/u=2956370624,4180433682&fm=26&gp=0.jpg","鬥魚.jpg");

        //建立執行任務
        ExecutorService ser= Executors.newFixedThreadPool(4);       //新建一個執行緒池，池子裡面有4個任務
        //提交執行
        Future<Boolean> r1=ser.submit(t1);
        Future<Boolean> r2=ser.submit(t2);
        Future<Boolean> r3=ser.submit(t3);
        Future<Boolean> r4=ser.submit(t4);
        //獲取執行結果
        boolean rs1=r1.get();
        boolean rs2=r2.get();
        boolean rs3=r3.get();
        boolean rs4=r4.get();
                //列印返回值
        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);
        System.out.println(rs4);

        //關閉服務
        ser.shutdownNow();
    }
}

//下載器
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方法出現問題");
        }
    }
}

小結

• 繼承Thread類：
  • 子類繼承Thread類具備多執行緒能力
  • 啟動執行緒：子類物件.start()
  • 不建議使用：避免OOP單繼承侷限性
• 實現Runnable介面
  • 實現介面Runnable具備多執行緒能力
  • 啟動執行緒：傳入目標物件+Thread物件.start new Thread(Runnable介面實現類物件).start()
  • 推薦使用：避免單繼承侷限性，方便靈活，方便同一個物件被多個執行緒呼叫

併發問題

//多個執行緒同時操作同一個物件
//買火車票的例子
//多個執行緒操作同一個資源的情況下，執行緒不安全，資料紊亂
public class TestThread04 implements Runnable{
    //票數
    private int tickerNums=10;

    public void run(){
        while (true){
            if (tickerNums<=0){
                break;
            }
            //sleep() 休眠，模擬延時
            try {
                Thread.sleep(200);              //延時後出現了兩人拿到同一張，或者拿的總票數超過10
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"買到了第"+tickerNums--+"張票");
            //currentThread()返回當前執行的執行緒物件
        }
    }

    public static void main(String[] args) {
        TestThread04  testThread04= new TestThread04();
        new Thread(testThread04,"果果").start();
        new Thread(testThread04,"黃牛").start();
        new Thread(testThread04,"攜程").start();
    }
}

//模擬龜兔賽跑
//Runnable多個執行緒共享一個資源
public class Race implements Runnable {
    private static String winner;

    public void run() {
        for (int i = 1; i <= 100; i++) {
            //判斷比賽是否結束
            boolean flag=gameOver(i);
            //如果比賽結束，就停止程式
            if (flag){
                break;
            }
            System.out.println(Thread.currentThread().getName() + "---跑了" + i + "步");
            if(Thread.currentThread().getName().equals("兔子")& i%10==0){//模擬兔子睡覺，每10步休息一次
                try {
                    Thread.sleep(1);				//sleep()  執行緒休眠
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //判斷是否完成比賽
    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();
    }
}

靜態代理模式

執行緒的底層實現實際也是靜態代理模式

/*
* 靜態代理模式
* 真實物件和代理物件都要實現同一介面
* 代理角色要代理真實角色
* 好處：
*       代理角色可以做很多真實物件做不了的事情
*       真實物件只需要專注做自己的事情
* */
public class StaticProxy {
    public static void main(String[] args) {
        Groom groom = new Groom();
        WeddingCompany weddingCompany = new WeddingCompany(groom);
        weddingCompany.HappyMarry();
    }
}

interface Marry{
    void HappyMarry();
}

//真實角色，要結婚的物件
class Groom implements Marry{
    public void HappyMarry(){
        System.out.println("guoguo要結婚");
    }
}

//代理角色，幫忙處理結婚的瑣事
class WeddingCompany implements Marry{
    //代理真實目標角色
    private Marry target;

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

    public void HappyMarry(){
        before();
        this.target.HappyMarry();//此處target就是真實物件
        after();
    }

    private void before() {
        System.out.println("結婚前準備工作");
    }
    private void after() {
        System.out.println("結婚後收拾會場");
    }
}

λ 表示式（Lambda）

1.λ 希臘字母表中排序第十一位的字母，英語名稱為 Lambda

2.避免匿名內部類定義過多

3.其實質屬於函數語言程式設計的概念

為什麼使用λ表示式：

• • 避免匿名內部類定義過多
  • 讓程式碼看起來更簡潔
  • 去掉了一堆沒用意義的程式碼，只留下核心的邏輯

• 理解**Functional Interface(函式式介面)**是學習lambda表示式的關鍵所在

• 函式式介面定義：

  • 任何介面，如果只包含唯一一個抽象方法，那麼它就是一個函式式介面

    public interface Runnable{
    	public abstract void run();			//該介面只包含了一個抽象方法run()
    }
    

  • 對於函式式介面，可以通過lambda表示式來建立該介面的物件

/*
* 推導Lambda表示式
* */
public class TestLambda {
    //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();

        like=new Like2();
        like.lambda();

        //4.區域性內部類
        class Like3 implements ILike{
            public void lambda() {
                System.out.println("i like lambda3");
            }
        }
        like=new Like3();
        like.lambda();

        //5.匿名內部類,沒有類的名字，必須藉助介面或者父類
        like =new ILike(){
            public void lambda() {
                System.out.println("i like lambda4");
            }
        };
        like.lambda();

        //6.用lambda表示式簡化
        like=()-> {
            System.out.println("i like lambda5");
        };
        like.lambda();

    }
}

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

//2.實現類
class Like implements ILike{
    public void lambda() {
        System.out.println("i like lambda");
    }
}

//有參的lambda表示式及持續簡化
public class TestLambda2 {
    public static void main(String[] args) {
        ILove lo=null;
        //已經簡化為lambda表示式==================
        lo=(int a)->{
            System.out.println("I love Lambda"+a);
        };
        lo.love(0);

        //簡化1.掉引數型別int=====================
        lo=(a)->{
            System.out.println("I love Lambda"+a);
        };
        lo.love(1);

        //簡化2.簡化掉括號()======================
        lo=a->{
            System.out.println("I love Lambda"+a);
            System.out.println("此時有多行程式碼，必須用程式碼塊包裹");
        };
        lo.love(2);

        //簡化3.簡化掉大括號{}=====================
                //lambda表示式只有一行程式碼的情況下可以簡化掉{}
        lo=a->
            System.out.println("I love Lambda"+a);
        lo.love(3);
        /*總結   1.lambda表示式只有一行程式碼的情況下才能簡化成一行，如果有多行，name用程式碼塊包裹----用{}包裹
                2.前提是介面必須為函式式介面
                3.多個引數也可以去掉引數型別，且去掉就是所有引數型別同時去掉；
                4.同時存在多個引數時，引數型別可以去掉，但是多個引數必須用()括起來，()不能去掉
                */
    }
}

interface ILove{
    void love(int a);
}

lambda表示式總結

​ 1.lambda表示式只有一行程式碼的情況下才能簡化成一行，如果有多行，name用程式碼塊包裹----即用{}包裹
​ 2.前提是介面必須為函式式介面
​ 3.多個引數也可以去掉引數型別，且去掉就是所有引數型別同時去掉；
​ 4.同時存在多個引數時，引數型別可以去掉，但是多個引數必須用()括起來，()不能去掉

Runnable介面也是一個函式式介面 ，如果重寫的run()足夠簡單，也可以考慮使用lambda表示式

執行緒狀態

五大狀態：建立狀態，就緒狀態，阻塞狀態，執行狀態，死亡狀態

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-QjQtBS2l-1608933595159)(C:\Xiang\圖片\1608899784(1)].png)

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-EkOHX1W0-1608933595167)(C:\Xiang\圖片\1608899835(1)].png)

執行緒方法：

方法	說明
setPriority(int newPriority)	更改執行緒的優先順序
static void sleep(long millis)	在指定的毫秒數內讓當前正在執行的執行緒休眠
void join()	等待該執行緒終止
static void yield()	暫停當前正在執行的執行緒物件，並執行其他執行緒
void interrupt()	中斷執行緒，別用這個方式
boolean isAlive()	測試執行緒是否處於活動狀態

停止執行緒

• 不推薦使用JDK提供的stop()、destroy()方法【已廢棄】
• 推薦執行緒自己停下來
• 建議使用一個標誌位進行終止變數 當flag=false，則終止執行緒執行

//測試stop
//1.建議執行緒正常停止--->利用次數，不建議死迴圈
//2.建議使用標誌位--->設定一個標誌位
//3.不要使用stop或者destroy等過時或者JDK不建議使用的方法
public class TestStop implements Runnable{
    //設定一個標誌位
    private boolean flag=true;

    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) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();
        
        for (int i = 0; i <1000 ; i++) {
            System.out.println("main---"+i);		
            //main方法中主執行緒是跑到999會停止，迴圈的時候設定了次數；另一個執行緒獨立執行，沒有設定迴圈次數，但是在主執行緒main執行到900時改變了標誌位flag，另一個執行緒停止
            if(i==900){
                //呼叫自己寫的stop()方法，切換標誌位，讓執行緒停止
                testStop.stop();					
                System.out.println("執行緒該停止了");
            }
        }
    }
}

執行緒休眠

• sleep(時間)指定當前執行緒阻塞的毫秒數 1000ms=1s
• sleep存在異常InterruptedException
• sleep時間達到後執行緒進入就緒狀態
• sleep可以模擬網路延時，倒數計時等
• 每一個物件都有一個鎖，sleep不會釋放鎖

//sleep常用作用
//模擬倒數計時
//列印當前系統時間
public class TestSleep02 {
    public static void main(String[] args)  {
        Date startTime=new Date(System.currentTimeMillis());//獲取系統當前時間

        while(true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                startTime=new Date(System.currentTimeMillis());//更新當前時間
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }

    //模擬倒數計時
    public static void tenDown() throws InterruptedException {  //方法靜態修飾後，可以直接呼叫方法名，不需要先建立物件
        int num=10;
        System.out.println("10秒倒數計時開始");
        while(true){
            Thread.sleep(1000);
            System.out.println(num--);
            if(num==0){
                break;
            }
        }
        System.out.println("倒數計時結束");
    }
}

執行緒禮讓 yield()

• 禮讓執行緒，讓當前正在執行的執行緒暫停，但不阻塞
• 將執行緒從執行狀態轉為就緒狀態
• 讓cpu重新排程，禮讓不一定成功！看cpu心情

//測試禮讓執行緒
//禮讓不一定成功，看CPU心情
public class TestYield {
    public static void main(String[] args) {
        Myyield myyield = new Myyield();
        new Thread(myyield,"a").start();
        new Thread(myyield,"b").start();  //如果沒有禮讓，執行結果就是aabb或者bbaa；禮讓成功的話就是abab或baba或abba或baab
    }
}
class Myyield implements Runnable{
    public void run(){
        System.out.println(Thread.currentThread().getName()+"執行緒開始執行");
        Thread.yield();//執行緒禮讓
        System.out.println(Thread.currentThread().getName()+"執行緒停止執行");
    }
}

執行緒強制執行 join()

• Join合併執行緒，待此執行緒執行完成後，再執行其他執行緒，其他執行緒先阻塞
• 可認為就是插隊

//測試join方法，插隊
public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <1000 ; i++) {
            System.out.println("插隊的來了"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //啟動要插隊的執行緒
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();

        //主執行緒
        for (int i = 0; i <1000 ; i++) {
            if(i==200){
                thread.join();//插隊進來
                //在主執行緒i=200時插隊，200前主執行緒與插隊執行緒正常交替進行，到200時插隊以後，要等插隊的執行緒跑完了，再跑主執行緒
            }
            System.out.println("苦逼兮兮正常排隊的main"+i);
        }
    }
}

執行緒狀態觀測

Thread.State

執行緒狀態：執行緒可以處於一下狀態之一

• • NEW 尚未啟動的執行緒處於此狀態
  • RUNNABLE 在Java虛擬機器中執行的執行緒處於此狀態
  • BLOCKED 被阻塞等待監視器鎖定的執行緒處於此狀態
  • WAITING 正在等待另一個執行緒執行特定動作的執行緒處於此狀態
  • TIMED_WAITING 正在等待另一個執行緒執行動作達到等待時間的執行緒處於此狀態
  • TERMINATED 已退出的執行緒處於此狀態

public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i <5; i++) {
                try {
                    Thread.sleep(1000);
                    System.out.println(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("");
        });
        //觀測狀態
        Thread.State state = thread.getState();
        System.out.println(state);      //此時建立了執行緒，但還沒呼叫start，應該是NEW

        thread.start();
        state = thread.getState();//更新執行緒狀態
        System.out.println(state);     //呼叫了start，執行緒處於執行中，RUNNABLE

        while(state!=Thread.State.TERMINATED){//只要執行緒不終止，就一直輸出狀態         //Thread.State.TERMINATED 執行緒終止
            Thread.sleep(100);
            state=thread.getState();//更新執行緒狀態
            System.out.println(state);			//TIMED_WAITING		該執行緒執行完畢，等待主執行緒進入5秒的sleep
        }
        //thread.start();//此處線上程死亡後再次呼叫start會報異常；死亡後的執行緒不能再次啟動
    }
}

執行緒優先順序 priority

• Java提供一個執行緒排程器來監控程式中啟動後進入就緒狀態的所有執行緒，執行緒排程器按照優先順序決定蓋排程哪個執行緒來執行
• 執行緒的優先順序用數字來表示範圍從1~10（優先順序數字越大，優先順序越高）
  • Thread.MIN_PRIORITY=1;
  • Thread.MAX_PRIORITY=10;
  • Thread.NORM_PRIORITY=5; 預設為5
• 獲取和改變優先順序的方法
  • getPriority()
  • setPriority(int xxx)

不是優先順序高的一定先跑，但優先順序高的先跑的機率更大

要先設定優先順序，再跑；跑起來之後再設定優先順序沒用

//測試執行緒的優先順序
public class TestPriority  {
    public static void main(String[] args) {
        //列印當前執行緒（此處為主執行緒）名字和預設優先順序
        System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
        MyPriority myPriority = new MyPriority();

        //建立執行緒
        Thread t1 = new Thread(myPriority,"執行緒1");
        Thread t2 = new Thread(myPriority,"執行緒2");
        Thread t3 = new Thread(myPriority,"執行緒3");
        Thread t4 = new Thread(myPriority,"執行緒4");

        //設定優先順序,t1不設定，也就是預設   只能設定1-10之間，超出會報錯
        //先設定優先順序再啟動，啟動後再設定沒有用
        t2.setPriority(Thread.MIN_PRIORITY);
        t3.setPriority(6);
        t4.setPriority(Thread.MAX_PRIORITY);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

class MyPriority implements Runnable{
    @Override
    public void run() {
        //列印當前執行緒名字和優先順序
        System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
    }
}

守護執行緒（daemon）

• 執行緒分為使用者執行緒和守護執行緒
• 虛擬機器必須確保使用者執行緒執行完畢
• 虛擬機器不用等待守護執行緒執行完畢
• 守護執行緒如：後臺記錄操作日誌，監控記憶體，垃圾回收等

執行緒同步 synchronized

併發：多個執行緒操作同一個資源

• 處理多執行緒問題時，多個執行緒訪問同一個物件，並且某些執行緒還想修改這個物件**（併發問題）**，此時就需要執行緒同步
• 執行緒同步其實就是一種等待機制，多個需要同時訪問此物件的執行緒進入這個物件的等待池形成佇列，等待前面執行緒使用完畢，下一個執行緒再使用

執行緒同步的形成條件：佇列+鎖 保證執行緒安全性

• 由於同一程式的多個執行緒共享同一塊儲存空間，在帶來方便的同事，也帶來了訪問衝突問題，為了保證資料在方法中被訪問時的正確性，在訪問時加入鎖機制synchronized，當一個執行緒獲得物件的排它鎖，獨佔資源，其他執行緒必須等待，使用後釋放鎖即可，存在以下問題
  • 一個執行緒持有鎖會導致其他所有需要此鎖的執行緒掛起
  • 在多線競爭下，加鎖，釋放鎖會導致比較多的上下文切換和排程延時，會引起效能問題
  • 如果一個優先順序較高的執行緒等待一個優先順序較低的執行緒釋放鎖，會導致優先順序倒置，引起效能問題

不安全示例

//不安全的買票  前面寫過的示例；併發問題的第一個案例
===================================================
//不安全的取錢流程
//兩個人去銀行取同一張卡的錢,賬戶
public class UnsafeBank {
    public static void main(String[] args) {
        //賬戶
        Account account = new Account(100,"建行卡");
        Drawing guoguo = new Drawing(account, 60, "果果");
        Drawing huanhuan = new Drawing(account, 70, "歡歡");
        guoguo.start();
        huanhuan.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() {
        //判斷有沒有錢
        if((account.money-drawingMoney)<0){
            System.out.println(Thread.currentThread().getName()+"餘額不足,無法取出");
            return;
        }
        try {
            Thread.sleep(100);              //sleep，放大問題發生的可能性
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //卡內餘額=餘額-取的錢
        account.money=account.money-drawingMoney;
        //手中的錢=手中的錢+取的錢
        nowMoney=nowMoney+drawingMoney;

        System.out.println(account.name+"餘額為:"+account.money);
        //this.getName()==Thread.currentThread().getName()
        System.out.println(Thread.currentThread().getName()+"手裡的錢"+nowMoney);
    }
}

//不安全的集合
public class UnsafeList {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        for (int i = 0; i <10000 ; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());        //實際數字少於10000
        //建立10000個執行緒，將執行緒的名字存入集合；如果不存線上程不安全問題預估集合長度應該是10000
    }
}

同步方法

• 由於可以通過private關鍵字來保證資料物件只能被方法訪問，所有隻需要針對方法提出一套機制，這套機制即synchronized關鍵字，它包括兩種用法：synchronized方法和synchronized程式碼塊

同步方法：public sybchronized void method(int args){}

• synchronized方法控制對“物件”的訪問，每個物件對應一把鎖，每個synchronized方法都必須獲得呼叫該方法的物件的鎖才能執行，否則執行緒會阻塞，方法一旦執行，就獨佔該鎖，直到該方法返回才釋放鎖，後面被阻塞的執行緒才能獲得這個鎖，繼續執行
• 缺陷：如果將一個大的方法申明為synchronized，將會影響效率

同步方法弊端

• 方法裡面需要修改的內容才需要鎖，鎖的太多，浪費資源（只讀的程式碼不需要鎖）

//買票的例子中，給買票的方法加上synchronized程式設計同步方法即可
//加上synchronized的方法就是同步方法，鎖的是this
    private synchronized void buy() throws InterruptedException {
        //判斷是否有票
        if(ticketNums<=0){
            flag=false;     //此處不能遺漏，否則執行緒會無法停下來
            return;
        }
        //模擬延時，放大問題出現的可能性
        Thread.sleep(100);
        //還有票的情況下就買票
        System.out.println(Thread.currentThread().getName()+"買到了第"+ticketNums--+"張票");
    }

同步塊

• 同步塊：synchronize(Obj ){}

• Obj稱之為 同步監視器

  • Obj可以是任何物件，但是推薦使用共享資源作為同步監視器
  • 同步方法中無序指定同步監視器，因為同步方法的同步監視器就是this，就是這個物件本身，或者是class

• 同步監視器的執行過程：

  ​ 1.第一個執行緒訪問，鎖定同步監視器，執行其中程式碼

  ​ 2.第二個執行緒訪問，發現同步監視器被鎖定，無法訪問

  ​ 3.第一個執行緒訪問完畢，解鎖同步監視器

  ​ 4.第二個執行緒訪問，發現同步監視器沒有鎖，然後鎖定並訪問

鎖的物件（監視的物件），就是變化的量（需要增刪改操作的物件）

//取錢的例子，直接鎖整個方法沒用，使用同步程式碼塊，進行增刪改操作的物件account，將account作為監視器鎖起來
    //synchronized 預設鎖的是this
    @Override
    public void run() {
        synchronized(account){		//鎖的物件就是需要增刪改的物件，account
            //判斷有沒有錢
            if((account.money-drawingMoney)<0){
                System.out.println(Thread.currentThread().getName()+"餘額不足,無法取出");
                return;
            }
            try {
                Thread.sleep(100);              //sleep，放大問題發生的可能性
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //卡內餘額=餘額-取的錢
            account.money=account.money-drawingMoney;
            //手中的錢=手中的錢+取的錢
            nowMoney=nowMoney+drawingMoney;

            System.out.println(account.name+"餘額為:"+account.money);
            //this.getName()==Thread.currentThread().getName()
            System.out.println(Thread.currentThread().getName()+"手裡的錢"+nowMoney);
        }

    }

public class UnsafeList {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        for (int i = 0; i <10000 ; i++) {
            new Thread(()->{
                synchronized (list){			//鎖的物件就是需要增刪改的物件，list
                    list.add(Thread.currentThread().getName());//加了同步程式碼塊，此處不休眠或者休眠時間比較短，還是會出現問題
                }
            }).start();
        }
        try {
            Thread.sleep(1000);				//加了同步程式碼塊，此處不休眠或者休眠時間比較短，還是會出現問題
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());        //實際數字少於10000
        //建立10000個執行緒，將執行緒的名字存入集合；如果不存線上程不安全問題預估集合長度應該是10000
    }
}

//測試JUC安全型別的集合    CopyOnWriteArrayList這個集合本身就是執行緒安全的，不用加同步塊也沒問題
public class TestJuc {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list=new CopyOnWriteArrayList<String>();
        for (int i = 0; i <10000 ; i++) {
            new Thread(()->{
                    list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

死鎖

• 多個執行緒各自佔有一些共享資源，並且互相等待其他執行緒佔有的資源才能執行，而導致兩個或者多個執行緒都在等待對方釋放資源，都停止執行的情況。某一個同步塊同時擁有“兩個以上物件的鎖”時，就可能會發生“死鎖”的問題

//死鎖：多個執行緒互相抱著物件需要的資源，形成僵持
public class DeadLock {
    public static void main(String[] args) {
        Makeup m1 = new Makeup(0, "果果");
        Makeup m2 = new Makeup(1, "歡歡");
        m1.start();
        m2.start();
    }
    
}
//口紅
class Lipstick{
    
}

//鏡子
class Mirror{
    
}

//化妝
class Makeup extends Thread{
    //需要的資源只有一份，用static修飾來保證只有一份
    static Lipstick lipstick=new Lipstick();        
    static Mirror mirror=new Mirror();
    
    int choice;//選擇
    String grilName;//使用化妝品的人
    
    Makeup(int choice,String grilName){
        this.choice=choice;
        this.grilName=grilName;
    }
    
    
    @Override
    public void run() {
        //化妝
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //化妝,互相持有對方的鎖，也就是需要拿到對方的資源
    private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (lipstick) {    //第一個選擇的人，化妝品都沒有時，先獲得口紅的鎖
                System.out.println(this.grilName + "獲得口紅的鎖");
                Thread.sleep(1000);
                synchronized (mirror) {      //有了口紅後還要用鏡子
                    System.out.println(this.grilName + "獲得鏡子的鎖");
                }
                //synchronized (mirror) {      
                    //System.out.println(this.grilName + "獲得鏡子的鎖");
            }
        } else {
            synchronized (mirror) {    //第二個人一開始就沒有口紅，先拿了鏡子
                System.out.println(this.grilName + "獲得鏡子的鎖");
                Thread.sleep(1000);
                synchronized (lipstick) {      //有了鏡子後還要用口紅
                    System.out.println(this.grilName + "獲得口紅的鎖");
                }
                //synchronized (lipstick) {      
                    //System.out.println(this.grilName + "獲得口紅的鎖");
            }
        }
    }
}
//會輸出一人獲得一個鎖，然後程式卡死無法進入下一步；解決方法，將每個的第二把鎖拿出來放外面，也就是上面示例中的註釋程式碼處即可
//果果獲得口紅的鎖
//歡歡獲得鏡子的鎖

產生死鎖的四個必要條件（只要想辦法破壞其中任意一個或多個條件，就可以避免死鎖的發生）

• 互斥條件：一個資源每次只能被一個程式使用
• 請求與保持條件：一個程式因請求資源而阻塞時，對已經獲得的資源還保持不放
• 不剝奪條件：程式已獲得的資源，在未使用完之前，不能強行剝奪
• 迴圈等待條件：若干程式之間形成一種頭尾相接的迴圈等待資源關係

執行緒通訊問題

執行緒協作

生產者消費者問題

執行緒通訊

Java提供了幾個方法解決執行緒之間的通訊問題

方法名	作用
wait()	表示執行緒一直等待，直到其他執行緒通知，與sleep不同，會釋放鎖
wait(ling timeout)	指定等待的毫秒數
notify()	喚醒一個處於等待狀態的執行緒
notifyAll()	喚醒同一個物件上所有呼叫的wait()方法的執行緒，優先順序別高的執行緒優先排程

注意：以上都是Object類方法，都只能在同步方法或者同步程式碼塊中使用，否則會丟擲異常

解決方式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 = 1; 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.notify();
    }

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

        //資源被消費完後，通知生產者生產
        this.notifyAll();
        return chicken;
    }
}

解決方式1：訊號燈法

//測試生產者消費者問題2：訊號燈法，使用標誌位解決
public class TestPC2 {
    public static void main(String[] args) {
        TV tv=new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}

//生產者：演員
class Player extends Thread{
    TV tv;
    public Player(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{
    //演員表演時觀眾等待true；觀眾觀看時演員等待false
    String voice;//biaoyan de jiemu
    boolean flag=true;


    //演員表演
    public synchronized void play(String voice){
        if (!flag){      //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){      //flag為真，觀眾等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("觀眾觀看了"+voice);
        //觀眾看完，通知演員表演
        this.notifyAll();
        this.flag=!this.flag;
    }
}

高階主體

Lock（鎖）

• 從JDK5.0開始，Java提供了更強大的執行緒同步機制——通過顯式定義同步鎖物件來實現同步。同步鎖用Lock物件充當
• java.util.concurrent,locks,Lock介面是控制多個執行緒對共享資源進行訪問的工具。鎖提供了對共享資源的獨佔訪問，每次只能有一個執行緒對Lock物件加鎖，執行緒開始訪問共享資源之前應該先獲得Lock物件
• ReentrantLock（可重入鎖）類實現了Lock，它擁有與synchronized相同的併發性和記憶體語義，在實現執行緒安全的控制中，比較常用的是ReentrantLock，可以顯式加鎖、釋放鎖

//格式
class A{
    private final ReentrantLock lock=new ReentrantLock();
    public void m(){
        lock.lock();
        try {
            //需要保證執行緒安全的程式碼；
        }finally {
            lock.unlock();
            //如果同步程式碼塊存在異常，需要將unlock()寫入finally語句塊
        }
    }
}

Lock鎖示例

//測試Lock鎖  示例
public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}

class TestLock2 implements Runnable{
    int ticketNums=10;
    //定義Lock鎖
    private final ReentrantLock lock=new ReentrantLock();

    @Override
    public void run() {
        while (true){
            try {
                lock.lock();//加鎖
                if (ticketNums>0){      //將不安全的程式碼塊丟進lock鎖裡面
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                }else{
                    break;
                }
            }finally {
                lock.unlock();//解鎖
            }
        }
    }
}

synchronized與Lock的對比

• Lock是顯式鎖（需要手動開啟和關閉鎖，注意不要忘記關閉），synchronized是隱式鎖，出了作用域會自動釋放
• Lock只能鎖程式碼塊，synchronized可以鎖程式碼塊和方法
• 使用Lock鎖，JVM花在排程執行緒的時間更少，效能更好。且擴充套件性更好（提供更多的子類）
• 有限使用順序：Lock>同步程式碼塊（已經進入了方法體，分配了相應資源）>同步方法（在方法體之外）

執行緒池

背景：經常建立和銷燬量特別大的資源，如併發情況下的執行緒，對效能影響很大

提前建立好多個執行緒，放入執行緒池中，使用時直接獲取，使用完放回池中，可以避免頻繁建立銷燬，實現重複利用

好處：

• • 提高響應速度
  • 降低資源消耗
  • 便於執行緒管理（相關方法）
    • corePoolSize:核心池大小
    • maximumPoolSize:最大執行緒數
    • keepASliveTime:執行緒沒有任務時最多儲存多久終止

執行緒池相關API：ExecutorService、Executor