狂神說Java個人筆記-多線程

本文轉載自查看原文 2020-08-01 15:13 2820

多線程

1.0本章核心概念

線程就是獨立的執行路徑；
在線程運行時，即使沒有自己創建線程，后台也會有多個線程，如主線程，gc線程；
main()稱之為主線程，為系統的入口，用於執行整個程序；
在一個進程中，如果開辟了多個線程，線程的運行由調度器安排調度，調度器是與操作系統緊密相關的，先后順序是不能人為的干預的。
對同一份資源操作時，會存在資源搶奪的問題，需要加入並發控制；
線程會帶來額外的開銷，如cpu調度時間，並發控制開銷。
每個線程在自己的工作內存交互，內存控制不當會造成數據不一致

創建線程對象方法

1.Thread
- 自定義線程類繼承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");
       }
   }
}

練習

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();
        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;//勝利者
    @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);
提交執行：Future<Boolean>result1=ser.submit(t1);
獲取結果：boolean r1=result.get()
關閉服務：ser.shutdownNow();

靜態代理模式總結

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

代理對象要代理真實角色

好處：

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

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

Lambda表達式

避免匿名內部類定義過多

其實質屬於函數式編程的概念

可以讓代碼看起來很簡潔

去掉了一堆沒有意義的代碼，只留下核心的邏輯

函數式接口

Functional Interface（函數式接口）

定義：

任何接口，如果只包含唯一一個抽象方法，那么它就是一個函數式接口。

對於函數式接口，可以通過lambda表達式來創建該接口的對象。

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表達式只能有一行代碼的情況下才能簡化為一行，如果有多行，那么就用代碼塊包裹
前提是接口為函數式接口
多個參數也可以去掉參數類型，要去掉就都去掉，必須加上括號。

線程停止

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不會釋放鎖

public class TestSleep1 {
    public static void main(String[] args) {
    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();
           }
       }
   }
}

線程禮讓

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

將線程從運行狀態轉為就緒狀態

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

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

join

join合並線程，待此線程執行完成后，再執行其他線程，其他線程阻塞

可以想象成插隊

public class TestJoin implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            System.out.println("VIP線程來插隊了！！！"+i);
        }
    }


        public static void main(String[] args) throws InterruptedException {
           Thread thread= new Thread(new TestJoin());

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

            }
        }
    }
}

線程狀態觀測

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);

                } 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);
        }
    }
}

線程優先級

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

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

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

getPriority().setPriority(int xxx)

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());
    }
}

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

守護（daemon）線程

線程分為用戶線程和守護線程
虛擬機必須確保用戶線程執行完畢
虛擬機不用等待守護線程執行完畢
如，后台記錄操作日志，監控內存，垃圾回收等待。。。

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();
    }
}
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，當一個線程獲得對象的排它鎖，獨占資源，其他線程必須等待，使用后釋放鎖即可，存在以下問題：

一個線程持有鎖會導致其它所有需要此鎖的線程掛起；
在多線程競爭下，加鎖，釋放鎖會導致比較多的上下文切換和調度延時，引起性能問題；
如果一個優先級高的線程等待一個優先級低的線程釋放鎖，會導致優先級倒置，引起性能問題。

線程鎖

//不安全的買票
public class UnsafeButTicket {
    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--);
    }
}

//不安全取錢
    //兩個人去銀行取錢，賬戶
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);
            System.out.println(this.getName() + "手里的錢:" + nowMoney);
        }
    }
}

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());
    }
}

同步塊

Synchronized(Obj){}

Obj稱之為同步監視器

Obj可以是任何對象，但是推薦使用共享資源作為同步監視器
同步方法中無需指定同步監視器，因為同步方法的同步監視器就是this,就是這個對象本身，或者是class【反射中講解】

同步監視器的執行過程：

第一個線程訪問，鎖定同步監視器，執行其中代碼
第二個線程訪問，發現同步監視器被鎖定，無法訪問
第一個線程訪問完畢，皆出同步監視器
第二個線程訪問，發現同步監視器沒有鎖

死鎖避免方法

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

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

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

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

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

Lock鎖
- JDK5.0開始，java提供了更強大的線程同步機制——通過顯式定義同步鎖對象來實現同步。同步鎖使用Lock對象充當
- java.util.concurrent.locks.Lock接口是控制多個線程對共享資源進行訪問的工具。鎖提供了對共享資源的獨占訪問，每次只能有一個線程對Lock對象加鎖，線程開始訪問共享資源之前應先獲得Lock對象
- ReentrantLock類實現了Lock，它擁有與synchronized相同的並發性和內存語義，在實現線程安全的控制中，比較常用的是ReentrantLock，可以顯式加鎖、釋放鎖。
  
  synchronized與Lock的對比
  - Lock是顯式鎖（手動開啟和關閉鎖，別忘記關閉鎖）synchronized是隱式鎖，出了作用域自動釋放
  - Lock只有代碼塊加鎖，synchronized有代碼塊鎖和方法鎖
  - 使用Lock鎖，JVM將花費較少的時間來調度線程，性能更好。並且具有更好的擴展性（提供更多的子類）
  - 優先使用順序：
  - Lock》同步代碼塊（已經進入了方法體，分配了相應資源）》同步方法（在方法體之外）

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();//減鎖
            }
        }
    }
}

線程通信

應用場景：生產者和消費者問題

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

//信號燈法！！！
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;
    }
}

管程法

//測試：生產者消費者模型--》
    //生產者，消費者，產品
public class Tes
    public stati
        SynConta
        new Prod
        new Cons
    }
}
//生產者
class Productor 
    SynContainer
    public Produ
        this.con
    }
    //生產

    @Override
    public void 
        for (int
            cont
            Syst
        }
    }
}
//消費者
class Consumer e
    SynContainer
    public Consu
        this.con
    }
//消費
    @Override
    public void 
        for (int
            Syst
        }
    }
}
//產品
class Chicken{
    int id;//產品編
    public Chick
        this.id=
    }

}
//容器
class SynContain
    //需要一個容器大小
    Chicken[] ch
    //容器計數器
    int count =1
    //生產者放入產品
    public synch
        //如果容器滿了
        if (coun
            //同知

                
                
                
                
                

        }
        //如果沒有滿，
        chickens
        count++;
        //可以同知消費
        this.not
    }
    //消費者消費產品
    public synch
        //判斷能否消費
        if (coun
            //等待
            try 
                
            } ca
                
            }
        }

        //如果可以消費
        count--;
        Chicken 
        //吃完了，同知
        this.not
        return c
    }
}

線程池

背景：經常創建和銷毀、使用量特別大的資源，比如並發情況下的線程，對性能影響很大。
思路：提前創建好多個線程，放入線程池中，使用時直接獲取，使用完放回池中。可以避免頻繁創建銷毀、實現重復利用。類似生活中的公共交通工具。

好處：

提高響應速度（減少了創建新線程的時間）
降低資源消耗（重復利用線程池中線程，不需要每次都創建）

便於線程管理（。。。）

corePoolSize:核心池的大小
maximumPoolSize：最大線程數

keepAliveTime：線程沒有任務時最多保持多長時間后會終止

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());
    }
}

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 java多線程筆記 b站狂神視頻筆記狂神說Java筆記-Java入門狂神說Java筆記-Java基礎 Spring筆記（狂神說Java） SpringMVC學習筆記（狂神說Java）【狂神說】JAVA Mybatis 筆記+源碼【狂神說Java】SpringBoot筆記存檔 Java基礎筆記 | 狂神說版狂神說Java個人筆記-注解和反射狂神說Java個人筆記-MySQL

狂神說Java個人筆記-多線程

多線程

1.0本章核心概念

創建線程對象方法

1.Thread