Java 執行緒池的實現原理

阿新 • • 發佈：2022-05-23

P60 什麼是面向物件

面向過程&面向物件

面向過程思想
- 步驟清晰簡單，第一步做什麼，第二步做什麼...
- 面對過程適合處理一些較為簡單的問題
面向物件思想
- 物以類聚，分類的思維模式，思考問題首先會解決問題需要哪些分類，然後對這些分類進
  行單獨思考。最後，才對某個分類下的細節進行面向過程的思索。
- 面向物件適合處理複雜的問題，適合處理需要多人協作的問題！
對於描述複雜的事物，為了從巨集觀上把握、從整體.上合理分析,我們需要使用面向物件的思路
來分析整個系統。但是，具體到微觀操作，仍然需要面向過程的思路去處理。

什麼是面向物件

面向物件程式設計(Object-Oriented Programming，00P)

面向物件程式設計的本質就是：以類的方式組織程式碼，以物件的組織(封裝)資料。
抽象
三大特性：
- 封裝
- 繼承
- 多型
從認識論角度考慮是先有物件後有類。物件,是具體的事物。類，是抽象的，是對物件的抽象
從程式碼執行角度考慮是先有類後有物件。類是物件的模板。

P61 回顧方法的定義

回顧方法及加深

方法的定義
- 修飾符
- 返回型別
- break：跳出switch、跳出迴圈和return的區別
- 方法名：注意規範就OK，見名知意
- 引數列表：（引數型別，引數名）...
- 異常丟擲：疑問，後面講解

P62 回顧方法的呼叫

方法的呼叫
- 靜態方法
- 非靜態方法
- 形參和實參
- 值傳遞和引用傳遞
- this關鍵字

P63 類於物件的建立

類與物件的關係

類是一種抽象的資料型別，它是對某-類事物整體描述/定義，但是並不能代表某一個具體的事物。
- 動物、植物、手機、電腦....
- Person類、 Pet類.、Car類等，這些類都是用來描述/定義某- 類具體的事物應該具備的特點和行為
物件是抽象概念的具體例項
- 張三就是人的一個具體例項，張三家裡的旺財就是狗的一個具體例項。
- 能夠體現出特點展現出功能的是具體的例項，而不是-個抽象的概念。

建立與初始化物件

使用new關鍵字建立物件
使用new關鍵字建立的時候，除了分配記憶體空間之外，還會給建立好的物件進行預設的初始化以及對類中構造器的呼叫。

package com.chen.oop;

/**
 * ClassName:Student
 * Description:學生類
 *
 * @Date:2022-12-11 11:28
 * @Author:chenfp
 */
public class Student {
    //屬性：欄位
    String name;
    int age;

    //方法
    public void study(){
        System.out.println(this.name+"在學習");
    }
}

package com.chen.oop;

/**
 * ClassName:Application
 * Description:一個專案應該只存在一個main方法
 *
 * @Date:2022-12-11 11:28
 * @Author:chenfp
 */
public class Application {
    public static void main(String[] args) {
        //類：是抽象的，例項化
        //類例項化後會放回自己的物件！
        //student物件就是一個Student類的具體例項！
        Student xm = new Student();
        Student xh = new Student();
        xm.name = "小明";
        xm.age = 3;

        System.out.println(xm.name);
        System.out.println(xm.age);

        xh.name = "小紅";
        xh.age = 3;
        System.out.println(xh.name);
        System.out.println(xh.age);

    }
}

P64 構造器詳解

類中的構造器也稱為構造方法，是在進行建立物件的時候必須要呼叫的。並且構造器有以下倆個特點：
1. 必須和類的名字相同
2. 必須沒有返回型別，也不能寫void
構造器必須要掌握。

package com.chen.oop;

/**
 * ClassName:Person
 * Description:
 *
 * @Date:2022-12-11 11:42
 * @Author:chenfp
 */
public class Person {
    //一個類即使什麼都不屑，也會存在一個預設的構造方法
    //顯示的定義構造器
    String name;
    int age;
    //例項化初始值
    //1. 使用new關鍵字，本質是在呼叫構造器
    //2. 用來初始化值
    public Person(){
        this.name = "chenfp";
    }
    //有參構造：一旦定義了有參構造，無參必須顯示定義
    public Person(String name){
        this.name=name;
    }

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

package com.chen.oop;

/**
 * ClassName:Application
 * Description:一個專案應該只存在一個main方法
 *
 * @Date:2022-12-11 11:28
 * @Author:chenfp
 */
public class Application {
    public static void main(String[] args) {
        //使用news 關鍵詞例項化了一個物件
        Person person = new Person("shuaixiaoge",23);
        System.out.println(person.name);
        System.out.println(person.age);
    }
}

P65 建立物件記憶體分析

package com.chen.oop;

/**
 * ClassName:Pet
 * Description:
 *
 * @Date:2022-12-11 11:55
 * @Author:chenfp
 */
public class Pet {
    public String name;
    public int age;
    //無參構造
    public void shout(){
        System.out.println("叫了兩聲！");
    }
}

package com.chen.oop;

/**
 * ClassName:Application
 * Description:一個專案應該只存在一個main方法
 *
 * @Date:2022-12-11 11:28
 * @Author:chenfp
 */
public class Application {
    public static void main(String[] args) {
        Pet dog = new Pet();
        dog.name = "旺財";
        dog.age = 3;
        dog.shout();
        System.out.println(dog.name);
        System.out.println(dog.age);

        Pet cat = new Pet();
    }
}

P66 簡單小結類於物件

類與物件
- 類是一個模板：抽象，物件是一個具體的例項
方法
- 定義、呼叫
對應的引用
- 引用型別：基本型別
- 物件是通過引用來操作的：棧——>堆
屬性：欄位Field 成員變數
- 預設初始化
  - 數字：0，0.0
  - char：u0000
  - boolean：false
  - 引用：null
- 修飾符屬性型別屬性名 = 屬性值！
物件的建立和使用
- 必須使用new關鍵字創造物件，構造器 Person shuaixiaoge = new Person();
- 物件的屬性 shuaixiaoge.name;
- 物件的方法 shuaixiaoge.sleep();
類：
- 靜態的屬性屬性
- 動態的行為方法

P67 封裝詳解

封裝

該露的露，該藏的藏
- 我們程式設計要追求“高內聚，低耦合”。高內聚就是類的內部資料操作細節自己完成，不允許外部干涉；低耦合：僅暴露少量的方法給外部使用。
封裝(資料的隱藏)
- 通常，應禁止直接訪問-個物件中資料的實際表示，而應通過操作介面來訪問，這稱為資訊隱藏。
記住這句話就夠了：屬性私有，get/set

package com.chen.oop.demo04;

/**
 * ClassName:Student
 * Description:
 *
 * @Date:2022-12-11 12:17
 * @Author:chenfp
 */
//類 private：私有
public class Student {
    //屬性私有
    private String name; //名字
    private int id;//學號
    private char sex;//性別
    private int age;
    //提供一些可以操作這個屬性的方法！
    // 提供一些public的get、set方法

    //get 獲得這個資料
    public String getName(){
        return this.name;
    }

    //set 個這個資料設定值
    public void setName(String name){
        this.name = name;
    }

    //alt +insert
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age > 120 || age < 0){//不合法
            this.age = 3;
        }else{
            this.age = age;
        }
    }
}

package com.chen.oop;

import com.chen.oop.demo04.Student;

/**
 * ClassName:Application
 * Description:一個專案應該只存在一個main方法
 *
 * @Date:2022-12-11 11:28
 * @Author:chenfp
 */
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("帥小哥");
        System.out.println(student.getName());
        student.setAge(-1);
        System.out.println(student.getAge());
    }
}

提高程式的安全性，保護資料
隱藏程式碼的實現細節
統一介面
系統可維護增加了

P68 什麼是繼承

繼承

繼承的本質是對某一批類的抽象, 從而實現對現實世界更好的建模。
extends的意思是“擴充套件”。子類是父類的擴充套件。
JAVA中類只有單繼承，沒有多繼承！
繼承是類和類之間的一種關係。除此之外,類和類之間的關係還有依賴、組合、聚合等。
繼承關係的倆個類，一個為子類（派生類），一個為父類（基類）。子類繼承父類，使用關鍵字extends來表示。
子類和父類之間，從意義上講應該具有"is a"的關係。
object類：在Java鍾，所有的類，都預設直接或間接繼承Object類。
super
方法重寫：重寫——多型

P69 Super詳解

super注意點

super呼叫父類的貢藕早方法，必須在構造方法的第一個；
super 必須只能出現在子類的方法或者構造方法中！
super和this不能同事呼叫構造方法！

VS this

代表的物件不同：
- this：本身呼叫者這個物件
- super：代表父類物件的應用
前提：
- this：沒有繼承也可以使用
- super：只能在繼承條件才可以使用
構造方法：
- this(); 本類的構造
- super(); 父類的構造

P70 方法重寫

重寫：需要有繼承關係，子類重寫父類的方法！

方法名必須相同；
引數列表必須相同；
修飾符：範圍可以擴大：public>protected>default>private；
丟擲的異常：範圍，可以被縮小，但不能擴大：ClassNotFoundException（小）-->Exception（大）

重寫，子類的方法和父類的方法必須要一致，方法體不同！

為什麼需要重寫：

父類的功能，子類不一定需要，或者不一定滿足；
Alt + Insert：override；

P71 什麼是多型

多型

即同一方法可以根據傳送物件的不同而採用多種不同的行為方式。
一個物件的實際型別是確定的，但可以指向物件的引用的型別有很多
多型存在的條件
- 有繼承關係
- 子類重寫父類方法
- 父類引用指向子類物件
- 注意：多型是方法的多型，屬性沒有多型性。
- instanceof

多型注意事項：

多型是方法的多型，屬性沒有多型
父類和子類，有聯絡型別轉換異常！ClassCastException！
存在條件：繼承關係，方法需要重寫。父類引用指向子類物件！
- static方法，屬於類，他不屬於例項
- final 常量：不能重寫
- private方法，不能重寫

P72 instanceof和型別轉換

instanceof

package com.chen.oop;

import com.chen.oop.demo06.Person;
import com.chen.oop.demo06.Student;
import com.chen.oop.demo06.Teacher;

/**
 * ClassName:Application
 * Description:一個專案應該只存在一個main方法
 *
 * @Date:2022-12-11 11:28
 * @Author:chenfp
 */
public class Application {
    public static void main(String[] args) {
        Object object = new Student();
        System.out.println(object instanceof Student);
        System.out.println(object instanceof Person);
        System.out.println(object instanceof Object);
        System.out.println(object instanceof Teacher);
        System.out.println(object instanceof String);
        System.out.println("=====================================");
        Person person = new Student();
        System.out.println(person instanceof Student);
        System.out.println(person instanceof Person);
        System.out.println(person instanceof Object);
        System.out.println(person instanceof Teacher);
        //System.out.println(person instanceof String);
        System.out.println("=====================================");
        Student student = new Student();
        System.out.println(student instanceof Student);
        System.out.println(student instanceof Person);
        System.out.println(student instanceof Object);
        //System.out.println(student instanceof Teacher);
        //System.out.println(person instanceof String);
    }
}

型別轉換

父類引用只想子類的物件
把子類轉換為父類，向上轉型：不用強制轉換
把父類轉換為子類，向下轉型：強制轉換
方便方法的呼叫，減少重複的程式碼，有效提升利用率！簡潔

P73 static關鍵字詳解

P74 抽象類

抽象類

abstract修飾符可以用來修飾方法也可以修飾類，如果修飾方法，那麼該方法就是抽象方法；如果
修飾類，那麼該類就是抽象類。
抽象類中可以沒有抽象方法，但是有抽象方法的類一定要宣告為抽象類。
抽象類，不能使用new關鍵字來建立物件它是用來讓子類繼承的。
抽象方法，只有方法的宣告，沒有方法的實現，它是用來讓子類實現的。
子類繼承抽象類，那麼就必須要實現抽象類沒有實現的抽象方法，否則該子類也要宣告為抽象類。

package com.chen.oop.demo08;

/**
 * ClassName:Action
 * Description:
 *
 * @Date:2022-12-11 16:35
 * @Author:chenfp
 */
//abstract 抽象類：類  extends  單繼承~   （介面可以多繼承）
public abstract class Action {
    //約束~有人幫我們實現~
    //abstract，抽象方法，只有方法名字，沒有方法的實現！
    public abstract void doSomething();
    //1. 不能new抽象類，只能靠子類實現它；約束！
    //2. 抽象方法必須在抽象類中
    //3. 抽象方法必須在抽象類中
    //抽象的抽象：約束~
}

P75 介面的定義與實現

介面

普通類：只有具體實現
抽象類：具體實現和規範（抽象方法）都有!
介面：只有規範！
介面就是規範，定義的是一組規則，體現了現實世界中“如果你是...則必須能...的思想。如果你是天使，則必須能飛。如果你是汽車，則必須能跑。如果你好人，則必須幹掉壞人；如果你是壞人，則必須欺負好人。
介面的本質是契約，就像我們人間的法律一樣。制定好後大家都遵守。
00的精髓，是對物件的抽象，最能體現這一點的就是介面。為什麼我們討論設計模式都只針對具備了抽象能力的語言（比如c++、java、c#等），就是因為設計模式所研究的，實際上就是如何合理的去抽象。

宣告類的關鍵字是class，宣告介面的關鍵字是interface

作用

介面是約束；
定義一些方法，讓不同的人實現~
介面訪問預設修飾：pulic abstract
介面常量預設修飾：pullic static final
介面不能被例項化，介面中沒有構造方法
implements可以實現多個介面
必須要重寫介面中的方法

P76 N種內部類

內部類

內部類就是在一個類的內部在定義一個類，比如，A類中定義一個B類，那麼B類相對A類來說就稱為內部類，而A類相對B類來說就是外部類了。
1.成員內部類
2.靜態內部類
3.區域性內部類
4.匿名內部類

Django非同步任務執行緒池實現原理

這篇文章主要介紹了Django非同步任務執行緒池實現原理,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

Java執行緒池ThreadPoolExecutor原理及使用例項

引導要求：執行緒資源必須通過執行緒池提供，不允許在應用自行顯式建立執行緒；

細數 Java 執行緒池的原理

參考地址: https://mp.weixin.qq.com/s/zKClZIv1TWNPHpxK2nvNJwJava 中的 ThreadPoolExecutor 類java.uitl.concurrent.ThreadPoolExecutor 類是執行緒池中最核心的一個類，因此如果要透徹地瞭解Java 中的執行緒池，必