JAVA多線程總結(筆記)

線程的特點

線程就是獨立的執行路徑；
線上程運作時，即使沒有自己建立線程，背景也會有多個線程，如主線程，gc線程；
main()稱之為主線程，為系統的入口，用于執行整個程式；
在一個程序中，如果開辟了多個線程，線程的運作由排程器安排排程，排程器是與作業系統緊密相關的，先後順序是不能人為的幹預的。
對同一份資源操作時，會存在資源搶奪的問題，需要加入并發控制；
線程會帶來額外的開銷，如cpu排程時間，并發控制開銷。
每個線程在自己的工作記憶體互動，記憶體控制不當會造成資料不一緻

程序和線程的差別

程序是作業系統資源配置設定的基本機關，而線程是處理器任務排程和執行的基本機關。還存在資源開銷、包含關系、記憶體配置設定、影響關系、執行過程等差別。同一程序的線程共享本程序的位址空間和資源，而程序之間的位址空間和資源互相獨立。

線程建立方式

[外鍊圖檔轉存失敗,源站可能有防盜鍊機制,建議将圖檔儲存下來直接上傳(img-i3ZOerjT-1608708490342)(C:\Users\王東梁\AppData\Roaming\Typora\typora-user-images\image-20201222233338560.png)]

1.Thread

[外鍊圖檔轉存失敗,源站可能有防盜鍊機制,建議将圖檔儲存下來直接上傳(img-oaYMfvFx-1608708490345)(C:\Users\王東梁\AppData\Roaming\Typora\typora-user-images\image-20201222234526548.png)]

自定義線程類繼承Thread類
重寫run（）方法，編寫線程執行體
建立線程對象，調用start（）方法啟動線程

//建立線程方式一：繼承thread類，重寫run（）方法，調用start開啟線程
    //總結：注意，線程開啟不一定立即執行，由CPU排程執行
public class ThreadDemo01 extends Thread {
    @Override
    public void run() {//run方法線程體
        for (int i = 0; i <100; i++) {
            System.out.println("多線程被執行了");
        }
    }

    public static void main(String[] args) {
        //main線程，主線程
        //建立一個線程對象
        ThreadDemo01 td1 = new ThreadDemo01();
        td1.start();//調用start方法開啟線程
        for (int i = 0; i <1000 ; i++) {
            System.out.println("每天都在學習java");
        }
    }
}

練習

[外鍊圖檔轉存失敗,源站可能有防盜鍊機制,建議将圖檔儲存下來直接上傳(img-eeB1nHR8-1608708490347)(C:\Users\王東梁\AppData\Roaming\Typora\typora-user-images\image-20201222235400735.png)]

package com.dong.thread;

import org.apache.commons.io.FileUtils;

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

/**
 * @author dong
 * @date 2020/5/24 - 8:39
 */
//
public class ThreadDemo02 extends Thread{
   private String url;//儲存網絡圖檔位址
   private String name;//儲存的檔案名

    public ThreadDemo02(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) {
        ThreadDemo02 t1 = new ThreadDemo02("https://dss0.baidu.com/73t1bjeh1BF3odCf/it/u=1561546013,1259770086&fm=85&s=1A21EC02EE337FAF0854119903001062","1.jpg");
        ThreadDemo02 t2 = new ThreadDemo02("https://dss0.baidu.com/73t1bjeh1BF3odCf/it/u=3506652242,2368086075&fm=85&s=8C9F875066675AAE078DE4D6030050F1","2.jpg");
        ThreadDemo02 t3 = new ThreadDemo02("https://dss0.baidu.com/73t1bjeh1BF3odCf/it/u=2623032014,2137091052&fm=85&s=F4C2BE56F74162EE0E5EEC7C03004071","3.jpg");
        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有問題");//檔案下載下傳失敗
        }
    }
}

2.Runnable接口

public class ThreadDemo03 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <200 ; i++) {
            System.out.println("多線程被執行了");
        }
    }

    public static void main(String[] args) {
        new Thread(new ThreadDemo03()).start();
        //ThreadDemo02 threadDemo02 = new ThreadDemo02();
        //Thread thread = new Thread(threadDemo02);代理
        //thread.start();
        for (int i = 0; i <1000 ; i++) {
            System.out.println("每天都在學習java");
        }
    }
}

小結

繼承Thread類
- 子類繼承Thread類具備多線程能力
- 啟動線程：子類對象.start（）
- 不建議使用：避免OOP單繼承局限性
實作Runnable接口

實作接口Runnable具有多線程能力

啟動線程：傳入目标對象+Thread對象.start ()

推薦使用：避免單繼承局限性，靈活友善，友善同一對象被多個線程使用

執行個體

public class ThreadDemo04 implements Runnable{
    private static String winner;//勝利者   static保證隻有一個勝利者
    @Override
    public void run() {
        for (int i = 0; i <=100 ; i++) {
            //模拟兔子休息
            if(Thread.currentThread().getName().equals("兔子")&& i%20==0){
                try {
                    Thread.sleep(10);
                } 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) {
        new Thread(new ThreadDemo04(),"兔子").start();
        new Thread(new ThreadDemo04(),"烏龜").start();
    }
}

3.實作Callable接口(了解)

實作Callable接口，需要傳回值類型
重寫call方法，需要抛出異常
建立目标對象
建立執行服務：ExecutorService=Executor.newFixedThreadPool(1);
送出執行：Futureresult1=ser.submit(t1);
擷取結果：boolean r1=result.get()
關閉服務：ser.shutdownNow();

package com.kuang.demo02;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;
public class TestCallable implements Callable<Boolean> {
    private String url;//儲存網絡圖檔位址
    private String name;//儲存的檔案名
    public TestCallable(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 {
     TestCallable t1 = new TestCallable("https://dss0.baidu.com/73t1bjeh1BF3odCf/it/u=1561546013,1259770086&fm=85&s=1A21EC02EE337FAF0854119903001062","1.jpg");
      TestCallable t2 = new TestCallable("https://dss0.baidu.com/73t1bjeh1BF3odCf/it/u=3506652242,2368086075&fm=85&s=8C9F875066675AAE078DE4D6030050F1","2.jpg");
    TestCallable t3 = new TestCallable("https://dss0.baidu.com/73t1bjeh1BF3odCf/it/u=2623032014,2137091052&fm=85&s=F4C2BE56F74162EE0E5EEC7C03004071","3.jpg");
      //建立執行服務
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //送出執行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);
        //擷取結果
        boolean rs1=r1.get();
        boolean rs2=r2.get();
        boolean rs3=r3.get();
        //關閉服務
        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有問題");//檔案下載下傳失敗
        }
    }
}

靜态代理

真實對象和代理對象都要實作同一個接口

代理對象要代理真實角色

好處：

代理對象可以做很多真實對象做不了的事情

真實對象專注做自己的事情

package com.kuang.demo03;
public class StacticProxy {
    public static void main(String[] args) {
//        WeddingCompany weddingCompany=new WeddingCompany(new You());
//        weddingCompany.HappyMarry();
        new WeddingCompany(new You()).HappyMarry();
    }
}
interface  Marry{
    void HappyMarry();
}
class You implements Marry{
    @Override
    public void HappyMarry(){
        System.out.println("afdas");
    }
}

class  WeddingCompany implements Marry{
    private  Marry target;
    public WeddingCompany(Marry target){
        this.target=target;
    }
    @Override
    public void HappyMarry(){
        before();
        this.target.HappyMarry();
        after();    }
    private void after() {
        System.out.println("asf");    }
    private void before() {
        System.out.println("asdfa");
    }
}

Lamda表達式

[外鍊圖檔轉存失敗,源站可能有防盜鍊機制,建議将圖檔儲存下來直接上傳(img-GmTxaGNR-1608708490355)(C:\Users\王東梁\AppData\Roaming\Typora\typora-user-images\image-20201223104552933.png)]

函數式接口

[外鍊圖檔轉存失敗,源站可能有防盜鍊機制,建議将圖檔儲存下來直接上傳(img-Ll6HAooJ-1608708490356)(C:\Users\王東梁\AppData\Roaming\Typora\typora-user-images\image-20201223104815076.png)]

[外鍊圖檔轉存失敗,源站可能有防盜鍊機制,建議将圖檔儲存下來直接上傳(img-OVOumEzH-1608708490359)(C:\Users\王東梁\AppData\Roaming\Typora\typora-user-images\image-20201223110252247.png)]

lamda表達式簡化

[外鍊圖檔轉存失敗,源站可能有防盜鍊機制,建議将圖檔儲存下來直接上傳(img-90qhdq24-1608708490360)(C:\Users\王東梁\AppData\Roaming\Typora\typora-user-images\image-20201223111844980.png)]

[外鍊圖檔轉存失敗,源站可能有防盜鍊機制,建議将圖檔儲存下來直接上傳(img-YxZohGaf-1608708490361)(C:\Users\王東梁\AppData\Roaming\Typora\typora-user-images\image-20201223112035798.png)]

public class TestLambda1 {
    //2.靜态内部類
    static class Love implements ILove {

        public void ILove(int a) {
            System.out.println("i like lambda" + a);
        }
    }
    public static void main(String[] args) {
      Love love=new Love();
      love.ILove(1);
      Love love1=new Love();
      love1.ILove(2);
        class Love implements ILove {
        //3.局部内部類
            public void ILove(int a) {
                System.out.println("i like lambda" + a);
            }
        }
        Love love2 = new Love();
        love2.ILove(3);
        //4.匿名内部類
        ILove iLove=new ILove() {
            @Override
            public void ILove(int a) {
                System.out.println("i like lambda" + a);
            }
        };
      iLove.ILove(4);
      //5.lambda表達式
        ILove iLove1=(int a)->{
            System.out.println("i like lambda" + a);
        };
        iLove1.ILove(5);
    }
}
//定義一個接口,隻有一個方法，函數式接口
interface ILove{
    void ILove(int a);
}
    //1.普通實作
class Love implements ILove {
        @Override
    public void ILove(int a) {
        System.out.println("i like lambda" + a);
    }
}
public class TestLambda2 {
    public static void main(String[] args) {
        YouLove youLove=(a,b)->{
            System.out.println("一句話你說:"+a+b);
        };
        youLove.youLove(10,20);
    }
}

interface YouLove{
    void youLove(int a,int b);
}

總結：

lambda表達式隻能有一行代碼的情況下才能簡化為一行，如果有多行，那麼就用代碼塊包裹
前提是接口為函數式接口
多個參數也可以去掉參數類型，要去掉就都去掉，必須加上括号。

線程狀态

[外鍊圖檔轉存失敗,源站可能有防盜鍊機制,建議将圖檔儲存下來直接上傳(img-DpOnjVPD-1608708490361)(C:\Users\王東梁\AppData\Roaming\Typora\typora-user-images\image-20201223112930005.png)]

[外鍊圖檔轉存失敗,源站可能有防盜鍊機制,建議将圖檔儲存下來直接上傳(img-OEAilaW0-1608708490362)(C:\Users\王東梁\AppData\Roaming\Typora\typora-user-images\image-20201223113054638.png)]

線程停止

package com.kuang.demo05;

public class TestStop 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) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();
        for (int i = 0; i <1000 ; i++) {
            System.out.println("main"+i);
            if (i==900){
                testStop.stop();
                System.out.println("線程停止了！");
            }
        }
    }
}

線程休眠

sleep（時間）指定目前線程阻塞的毫秒數；

sleep存在異常InterruptedException

sleep時間到達後線程進入就緒狀态

sleep可以模拟網絡延時，倒計時等。

每一個對象都有一個鎖，sleep不會釋放鎖

package com.kuang.demo05;

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

public class TestSleep2 {
    public static void main(String[] args) {
        TestSleep2.tenDown();
        //列印目前系統時間
        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(){
        int num=10;
        while (true){
            try {
                Thread.sleep(1000);
                if (num<=0){
                    break;
                }else{
                    System.out.println("倒計時！！！"+num--+"秒");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

線程禮讓yield

禮讓線程，讓目前正在執行的線程暫停，但不阻塞

将線程從運作狀态轉為就緒狀态

讓cpu重新排程，禮讓不一定成功！看CPU心情。

package com.kuang.demo05;
public class TestYield{
    public static void main(String[] args) {
        MyYield yield=new MyYield();
        new Thread(yield,"a").start();
        new Thread(yield,"b").start();
    }
}
class MyYield implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"線程開始執行");
        Thread.yield();//禮讓
        System.out.println(Thread.currentThread().getName()+"線程停止執行");
    }
}

線程強制執行join

package com.kuang.demo05;
public class TestJoin 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 {
//        Thread thread= new Thread(new TestJoin());
        new Thread(new TestJoin()).start();

        for (int i = 0; i <400 ; i++) {
            System.out.println("主線程在排隊！！！"+i);
            if (i==100){
                new Thread(new TestJoin()).join();

            }
        }
    }
}

Thread.State

線程狀态，線程可以處于一下狀态之一：

new 尚未啟動的線程處于此狀态
Runnable 在java虛拟機中執行的線程處于此狀态
Blocked 被阻塞等待螢幕鎖定的線程處于此狀态。
Waiting 正在等待另一個線程執行特定動作的線程處于此狀态。
Timed Waiting 正在等待另一個線程執行動作達到指定等待時間的線程處于此狀态。
Terminated 已退出的線程處于此狀态。

一個線程可以給定時間點處于一個狀态。這些狀态是不反映任何作業系統線程狀态的虛拟機狀态

package com.kuang.demo05;
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);

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("");
        });

        Thread.State state = thread.getState();
        System.out.println(state);//new

        thread.start();//啟動線程
        state=thread.getState();//runnable
        System.out.println(state);
        while (state!= Thread.State.TERMINATED){//隻要線程不終止就輸入線程狀态
            Thread.sleep(100);
            state=thread.getState();
            System.out.println(state);
        }
    }
}

[外鍊圖檔轉存失敗,源站可能有防盜鍊機制,建議将圖檔儲存下來直接上傳(img-2HsC4lq6-1608708490364)(C:\Users\王東梁\AppData\Roaming\Typora\typora-user-images\image-20201223130000180.png)]

線程優先級

java提供一個線程排程器來監控程式中啟動後進入就緒狀态的所有線程，線程排程器按照優先級決定應該排程哪個線程來執行。

線程的優先級用數字表示，範圍從1~10。

使用以下方式改變或擷取優先級

getPriority().setPriority(int xxx)

package com.kuang.demo05;

public class TestPriority {
    public static void main(String[] args) {
        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.setPriority(1);
        t1.start();
        t2.setPriority(3);
        t2.start();
        t3.setPriority(6);
        t3.start();
        t4.setPriority(Thread.MAX_PRIORITY);//  優先級=10
        t4.start();
        t5.setPriority(Thread.MIN_PRIORITY);// 優先級=1
        t6.setPriority(9);
        t6.start();

        System.out.println("main");
    }
}
class MyPriority implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"---線程被執行了！---"+Thread.currentThread().getPriority());
    }
}

[外鍊圖檔轉存失敗,源站可能有防盜鍊機制,建議将圖檔儲存下來直接上傳(img-vRIzDkCg-1608708490365)(C:\Users\王東梁\AppData\Roaming\Typora\typora-user-images\image-20201223131437565.png)]

注意：先設定優先級，再start線程！！！

守護線程daemon

線程分為使用者線程和守護線程
虛拟機必須確定使用者線程執行完畢
虛拟機不用等待守護線程執行完畢
如，背景記錄記錄檔，監控記憶體，垃圾回收等待。。。

package com.kuang.demo05;
public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you=new You();
        Thread thread = new Thread(god);
        thread.setDaemon(true);//預設為flase 為使用者線程，  true為守護線程
        thread.start();
//        new Thread(you).start();
        Thread thread1 = new Thread(you);
        thread1.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("----goodbye!Beautiful World!!!------");

    }
}

線程同步機制

由于同一進城的多個線程共享同一塊存儲空間，在帶來友善的同僚，也帶來了通路沖突問題，為了保證資料在方法中被通路時的正确性，在通路時加入鎖機制synchronized，當一個線程獲得對象的排它鎖，獨占資源，其他線程必須等待，使用後釋放鎖即可，存在以下問題：
一個線程持有鎖會導緻其它所有需要此鎖的線程挂起；
在多線程競争下，加鎖，釋放鎖會導緻比較多的上下文切換和排程延時，引起性能問題；
如果一個優先級高的線程等待一個優先級低的線程釋放鎖，會導緻優先級倒置，引起性能問題。

三大不安全案例解決

不安全的買票

package com.kuang.demo06;
//不安全的買票
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket bt=new BuyTicket();
        new Thread(bt,"我").start();
        new Thread(bt,"你").start();
        new Thread(bt,"黃牛黨").start();
    }
}

class BuyTicket implements Runnable{
    //票
    private int ticketNums=10;
    boolean flag=true;//外部停止方式
    @Override
    public void run() {
        //買票
        while (flag){
            buy();
        }
    }
    public synchronized void buy(){//鎖了方法，相當于this 把類給鎖住
        //判斷是否有票
        if(ticketNums<=0){
            System.out.println("票沒了");
            flag=false;
            return ;     
        }
        //模拟延時
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+ticketNums--);
    }
}

不安全的銀行

package com.kuang.demo06;
//不安全取錢
//兩個人去銀行取錢，賬戶
public class UnsafeBank {
    public static void main(String[] args) {
        //賬戶
        Account account=new Account(100,"結婚基金");
        Drawing you=new Drawing(account,50,"你");
        Drawing girlFriend=new Drawing(account,100,"女朋友");
        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 (account) {//鎖的對象是變化的量，鎖需要增删改的對象
            //判斷有沒有錢
            if (account.money - drawingMoney <= 0) {
                System.out.println(Thread.currentThread().getName() + "錢不夠");
                return;
            }
            //卡内餘額
            account.money -= drawingMoney;
            //手裡的錢
            nowMoney += drawingMoney;
            System.out.println(account.name + "餘額為:" + account.money);
            //Thread.currentThread().getName()=this.getName();
            System.out.println(this.getName() + "手裡的錢:" + nowMoney);
        }
    }
}

用sleep可以放大問題的發生性

不安全的集合

package com.kuang.demo06;
import java.util.ArrayList;
public class UnsafeList {
     public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<String>();
        for (int i = 0; i <1000 ; i++) {
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
            try {
                Thread.sleep(30);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(list.size());
    }
}

同步

同步方法

[外鍊圖檔轉存失敗,源站可能有防盜鍊機制,建議将圖檔儲存下來直接上傳(img-gFDPBjYN-1608708490368)(C:\Users\王東梁\AppData\Roaming\Typora\typora-user-images\image-20201223135044806.png)]

同步塊

[外鍊圖檔轉存失敗,源站可能有防盜鍊機制,建議将圖檔儲存下來直接上傳(img-CG6hbeAf-1608708490371)(C:\Users\王東梁\AppData\Roaming\Typora\typora-user-images\image-20201223135151154.png)]

死鎖避免方法

産生死鎖的四個必要條件：

1.互斥條件：一個資源每次隻能被一個程序使用。

2.請求與保持條件：一個程序因請求資源而阻塞時，對已獲得的資源保持不妨。

3.不剝奪條件：程序已獲得的資源，在未使用完之前，不能強行剝奪。

4.循環等待條件：若幹程序之間形成一種頭尾相接的循環等待資源關系。

Lock鎖

JDK5.0開始，java提供了更強大的線程同步機制——通過顯式定義同步鎖對象來實作同步。同步鎖使用Lock對象充當
java.util.concurrent.locks.Lock接口是控制多個線程對共享資源進行通路的工具。鎖提供了對共享資源的獨占通路，每次隻能有一個線程對Lock對象加鎖，線程開始通路共享資源之前應先獲得Lock對象
ReentrantLock類實作了Lock，它擁有與synchronized相同的并發性和記憶體語義，在實作線程安全的控制中，比較常用的是ReentrantLock，可以顯式加鎖、釋放鎖。

package com.kuang.demo06;

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        new Thread(ticket).start();
        new Thread(ticket).start();
        new Thread(ticket).start();
    }

}
class Ticket extends Thread{
    private int ticketNums=10;
    //定義lock鎖
    private final ReentrantLock lock=new ReentrantLock();

    @Override
    public void run() {
        while (true){
            try {
                lock.lock();//加鎖
                if (ticketNums > 0) {
                    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>同步代碼塊（已經進入了方法體，配置設定了相應資源）>同步方法（在方法體之外）

線程通信

案例：生産者消費者

[外鍊圖檔轉存失敗,源站可能有防盜鍊機制,建議将圖檔儲存下來直接上傳(img-978jJ3Gl-1608708490372)(C:\Users\王東梁\AppData\Roaming\Typora\typora-user-images\image-20201223142705516.png)]

假設倉庫中隻能存放一件産品，生産者将生産出來的産品放入倉庫，消費者将倉庫中産品取走消費。
如果倉庫中沒有産品，則生産者将産品放入倉庫，否則停止生産并等待，直到倉庫中的産品被消費者取走為止。
如果倉庫中放有産品，則消費者可以将産品取走消費，否則停止消費并等待，直到倉庫中再次放入産品為止。

管程法

package com.kuang.demo07;
//測試：生産者消費者模型--》
//生産者，消費者，産品
public class TestPC{
    public static void main(String[] args) {
        SynContain contain=new SynContain();
        new Productor(contain).start();
        new Consumer(contain).start();
    }

}


//生産者
class Productor extends Thread{
    SynContain contain;
    public  Productor(SynContain contain){
        this.contain=contain;
    }

    @Override//生産
    public  void run()
    {
        for (int i = 0; i < 100; i++) {
            contain.push(new Chicken(i));
            System.out.println("生産了"+i+"隻雞");

        }
    }
}

//消費者
class Consumer extends Thread{
    SynContain contain;
    public  Consumer(SynContain contain){
        this.contain=contain;}
    @Override//生産
    public  void run()
    {
        for (int i = 0; i < 100; i++) {
            System.out.println("消費了"+contain.pop().id+"隻雞");
        }
    }

}
//産品
class Chicken{
    int id;//産品編
    public Chicken(int id){
        this.id=id;
}

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

    //生産者放入産品
    public synchronized void push(Chicken chicken) {
        //如果容器滿了,需要等待消費者消費
        if (count == chickens.length) {
            //通知消費者消費.生産等待
            try {//Ctrl加Alt加T進行代碼塊的包裹
                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;
    }

}

信号燈法

package com.kuang.demo07;
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{
    //演員表演，觀衆等待  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;
    }
}

線程池

背景：經常建立和銷毀、使用量特别大的資源，比如并發情況下的線程，對性能影響很大。
思路：提前建立好多個線程，放入線程池中，使用時直接擷取，使用完放回池中。可以避免頻繁建立銷毀、實作重複利用。類似生活中的公共交通工具。
- 提高響應速度（減少了建立新線程的時間）
- 降低資源消耗（重複利用線程池中線程，不需要每次都建立）
- 便于線程管理（。。。）
  - corePoolSize:核心池的大小
  - maximumPoolSize：最大線程數
  - keepAliveTime：線程沒有任務時最多保持多長時間後會終止

package com.kuang.demo07;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestPool {
    public static void main(String[] args) {
        //1.建立服務，建立線程池
        ExecutorService service= Executors.newFixedThreadPool(10);
        //newFixedThreadPool 參數為：線程池大小
        //執行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        //2.關閉連接配接
        service.shutdown();
    }
}
class MyThread implements Runnable{
    @Override
    public void run() {
            System.out.println(Thread.currentThread().getName());
    }
}

JAVA多線程總結(筆記)

1.Thread

2.Runnable接口

小結

執行個體

3.實作Callable接口(了解)

函數式接口

lamda表達式簡化

線程停止

線程休眠

線程禮讓yield

線程強制執行join

不安全的買票

不安全的銀行

不安全的集合

同步方法

同步塊

synchronized與Lock的對比

案例：生産者消費者

管程法

信号燈法

繼續閱讀

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

Spring整合JMS(二)——三種消息監聽器一、消息監聽器MessageListener

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method