主頁 > 後端開發 > Java---多執行緒入門

Java---多執行緒入門

2022-09-06 11:34:33 後端開發

前置知識

什么是行程，什么又是執行緒？咱不是講系統，簡單說下，知道個大概就好了，

行程：一個可執行檔案執行的程序，
執行緒：作業系統能夠進行運算調度的最小單位，它被包含在行程之中，是行程中的實際運作單位，一條執行緒指的是行程中一個單一順序的控制流，一個行程中可以并發多個執行緒，每條執行緒并行執行不同的任務

什么是并行，什么是并發？這個也簡單說下，

并行：cpu的兩個核心分別執行兩個執行緒，
并發：cpu的一個核心在兩個(或多個)執行緒上反復橫跳執行，

執行緒的創建

繼承Thread

// 宣告
class T extends Thread {
    public void run() {
        // do something
    }
}
// 使用
new T().start();

實作Runnable

// 宣告
class T implements Runnable {
    public void run() {
        // do something
    }
}
// 使用
new Thread(new T()).start();

為什么是start，而不是run，其實run只是個很普通的方法，我們來看看start的原始碼，

public synchronized void start() {
    if (threadStatus != 0)
        throw new IllegalThreadStateException();
    group.add(this);
    boolean started = false;
    try {
        start0(); // 這個才是開啟執行緒
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
        }
    }
}
// start0的實作
private native void start0(); // 這是一個native方法，通常使用C/C++來實作

多執行緒機流程（從啟動到終止）

我們通過一個案例來說明，

順便說說sleep()

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        new Thread(new T0(), "T0").start();
        int cnt = 0;
        while (cnt < 50) {
            cnt ++;
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(200); // 讓當前執行緒停止200毫秒
        }
    }
}
class T0 implements Runnable {
    int cnt;
    @Override
    public void run() {
        while (cnt < 50) {
            cnt ++;
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(200); // 讓當前執行緒停止200毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

執行流程：

  1. 啟動main方法(行程開啟)
  2. 啟動main執行緒
  3. 列印main/列印T0(根據執行緒調度執行)
  4. 其中一個執行緒結束
  5. 另一個執行緒結束
  6. 行程結束

執行緒常用方法

  • setName：設定執行緒名稱，不設定則使用默認執行緒名稱，

  • getName：獲取執行緒名稱，

  • start：開啟執行緒，實際開啟執行緒的方法為start0，

  • run：呼叫start后創建的新執行緒會呼叫run方法，單純呼叫run方法無法達到多執行緒的效果，run方法只是個普通的方法，

  • setPriority：更改執行緒優先級，

  • getPriority：獲取執行緒優先級，

    執行緒的優先級：
public static final int MIN_PRIORITY = 1;
public static final int NORM_PRIORITY = 5;
public static final int MAX_PRIORITY = 10;

  • sleep：讓執行緒休眠指定時間，

執行緒終止

雖然Thread中提供了一個stop方法用來停止執行緒，但目前已經被廢棄，那么我們如何停止執行緒呢？我們來看看下面這個例子，

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        T0 t0 = new T0();
        new Thread(t0, "T0").start();
        int cnt = 0;
        while (cnt < 50) {
            cnt ++;
            System.out.println(Thread.currentThread().getName());
        }
        t0.flag = false; // 設定為false用以跳出T0執行緒的回圈
        /*
        	在main執行緒執行了50次后退出T0執行緒，接著退出main執行緒
         */
    }
}
class T0 implements Runnable {
    boolean flag = true; // 定義一個標記，用來控制執行緒是否停止
    @Override
    public void run() {
        while (flag) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

通過定義一個標記flag讓執行緒退出，

執行緒中斷

Thread中有一個interrupt方法，這個方法不是說中斷執行緒的運行，而是中斷執行緒當前執行的操作，我們來看下樣例，

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        T0 t0 = new T0();
        Thread thread0 = new Thread(t0, "T0");
        thread0.start();
        System.out.println("張三在劃水，，，");
        Thread.sleep(2000);
        thread0.interrupt(); // 通過拋出一個InterruptedException例外來打斷當前操作(sleep)
    }
}
class T0 implements Runnable {
    boolean flag = true;
    @Override
    public void run() {
        System.out.println("李四在打盹，，，");
        while (flag) {
            try {
                Thread.sleep(20000); // 2秒后被interrupt中斷
            } catch (InterruptedException e) {
                flag = false;
                System.out.println("老板來了，張三搖醒了李四，，，"); // 由于main執行緒呼叫了interrupt，實際過了2秒就輸出了
            }
        }
    }
}

輸出結果：

張三在劃水，，，
李四在打盹，，，
老板來了，張三搖醒了李四，，，

執行緒讓步

Thread類中提供了yield方法，用來禮讓cpu資源，禮讓了資源就會執行其他執行緒嗎？我們看看這個例子

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        T0 t0 = new T0();
        Thread thread0 = new Thread(t0, "T0");
        thread0.start();
        int cnt = 0;
        while (cnt < 5) {
            cnt ++;
            System.out.println(Thread.currentThread().getName());
            Thread.yield(); // 放棄當前的cpu資源，讓cpu重新分配資源，
        }
    }
}
class T0 implements Runnable {
    int cnt;
    @Override
    public void run() {
        int cur = 0; // 連續吃的包子數
        while (cnt < 5) {
            cnt ++;
            System.out.println(Thread.currentThread().getName());
            Thread.yield(); // 放棄當前的cpu資源，讓cpu重新分配資源，
        }
    }
}

輸出結果：

main
T0
main
main
main
main
T0
T0
T0
T0

可以看到兩個執行緒互相禮讓，如果yield方法會強制執行其他執行緒的話，那執行緒應該會交替執行，而不是有連續執行同一個執行緒的情況，所以證明了yield并不是強制禮讓，

執行緒插隊

Thread類提供了join方法，可以指定一個執行緒優先執行，

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        Thread thread0 = new Thread(new T0(), "T0");
        thread0.start();
        Thread thread1 = new Thread(new T0(), "T1");
        thread1.start();
        int cnt = 0;
        while (cnt < 2) {
            cnt ++;
            System.out.println(Thread.currentThread().getName());
            thread0.join(); // 讓執行緒thread0插隊，執行完thread0的所有任務后回到當前執行緒，
        }
    }
}
class T0 implements Runnable {
    int cnt;
    @Override
    public void run() {
        int cur = 0;
        while (cnt < 2) {
            cnt ++;
            System.out.println(Thread.currentThread().getName());
        }
    }
}

輸出結果：

main
T1
T1
T0
T0
main

總體上main執行緒確實被T0插隊了，但為啥T1在T0的前面被執行？因為當前是多核CPU的環境，其它的核心在執行剩下的執行緒，執行T1執行緒的核心比T0的快所以T1在T0之前被輸出，不止有并發，還有并行，在單純并發的條件下，就變成了T0的所有任務都執行完畢后，才會執行其他執行緒，當前的main與T0是并發的，與T1是并行，

守護執行緒

Thread類提供setDaemon方法，可以設定目標執行緒為當前執行緒的守護執行緒，當前執行緒終止時，目標(守護)執行緒也隨之終止，

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        Thread thread0 = new Thread(new T0(), "T0");
        thread0.setDaemon(true);
        thread0.start();
        System.out.println("張三 --> 新一天的作業開始了");
        int time = 0;
        while (time < 8) { // 張三每天作業八個小時，，，
            time ++;
        }
        System.out.println("張三 --> 下班了，回家吃老婆做的飯咯");
        System.out.println("小紅 --> 我老公張三下班了，今天就到這了");
        System.out.println("小紅 --> 守護執行緒YYDS");
    }
}
class T0 implements Runnable {
    int cnt;
    @Override
    public void run() {
        System.out.println("小紅 --> 李四來我家甜蜜雙排王者榮耀");
        while (true);
    }
}

輸出結果：

張三 --> 新一天的作業開始了
小紅 --> 李四來我家甜蜜雙排王者榮耀
張三 --> 下班了，回家吃老婆做的飯咯
小紅 --> 我老公張三下班了，今天就到這了
小紅 --> 守護執行緒YYDS

當main執行緒終止時，T0執行緒也終止，

執行緒的狀態

5種狀態是OS的執行緒狀態，而6種則說的是JVM的執行緒狀態，以下是狀態圖，

執行緒狀態

OS的執行緒狀態為粗體
JVM的執行緒狀態為英文

執行緒同步機制

想看個經典問題，

多執行緒售票問題

我們來看看案例，

public class ThreadTest {
    public static void main(String[] args) {
        T0 t0 = new T0();
        Thread thread0 = new Thread(t0, "張三");
        Thread thread1 = new Thread(t0, "李四");
        thread0.start();
        thread1.start();
    }
}
class T0 implements Runnable {
    int ticket = 100;
    @Override
    public void run() {
        while (ticket > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.printf("%s買了一張票，還剩%d張%n", Thread.currentThread().getName(), -- ticket);
        }
    }
}

輸出結果：

...
張三買了一張票，還剩3張
張三買了一張票，還剩2張
李四買了一張票，還剩1張
張三買了一張票，還剩0張
李四買了一張票，還剩0張

出現了重復賣票，造成這種現象的原因是執行緒不安全，那如何讓執行緒安全呢，這就是接下來要介紹的互斥鎖，

互斥鎖

java提供了synchronized關鍵字用以開啟鎖，看看如何使用鎖解決上面的執行緒安全問題，

public class ThreadTest {
    public static void main(String[] args) {
        T0 t0 = new T0();
        Thread thread0 = new Thread(t0, "張三");
        Thread thread1 = new Thread(t0, "李四");
        thread0.start();
        thread1.start();
    }
}
class T0 implements Runnable {
    int ticket = 100;
    @Override
    public synchronized void run() { // 我們將鎖加在run方法上
        while (ticket > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.printf("%s買了一張票，還剩%d張%n", Thread.currentThread().getName(), -- ticket);
        }
    }
}

輸出結果：

...
張三買了一張票，還剩4張
張三買了一張票，還剩3張
張三買了一張票，還剩2張
張三買了一張票，還剩1張
張三買了一張票，還剩0張

所有的輸出都在執行緒張三上，這顯然不是我們想要的，
首先，為什么會有這種現象發生？其實，被synchronized修飾的方法或代碼塊會被上鎖，并發環境下先進入該方法或者代碼塊的執行緒將獲得鎖并執行這部分代碼，而其他執行緒則處于阻塞狀態直到獲得鎖的執行緒執行完被上鎖的所有代碼后，其他執行緒才有機會去爭奪鎖，

上述現象的原因是synchronized修飾了整個方法，所以當張三拿到鎖時會執行完所有的回圈后釋放鎖，這時李四就什么都輸出不了了，和單執行緒一樣，除了多了個一直阻塞的執行緒，性能低下，

那么如何保證執行緒安全的前提下，保證并發的性能呢？第一次嘗試解決，

public class ThreadTest {
    public static void main(String[] args) {
        T0 t0 = new T0();
        Thread thread0 = new Thread(t0, "張三");
        Thread thread1 = new Thread(t0, "李四");
        thread0.start();
        thread1.start();
    }
}
class T0 implements Runnable {
    int ticket = 100;
    @Override
    public /*synchronized*/ void run() { // 我們將鎖加在run方法上
        while (ticket > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized(this) { // 存在兩個執行緒執行時都滿足ticket>0,仍然有執行緒安全問題  
                System.out.printf("%s買了一張票，還剩%d張%n", Thread.currentThread().getName(), -- ticket);
            }
        }
    }
}

輸出結果：

...
李四買了一張票，還剩3張
李四買了一張票，還剩2張
張三買了一張票，還剩1張
張三買了一張票，還剩0張
李四買了一張票，還剩-1張

雖然兩個執行緒恢復了并發，但執行緒安全問題也隨之出現，

第二次嘗試解決，

public class ThreadTest {
    public static void main(String[] args) {
        T0 t0 = new T0();
        Thread thread0 = new Thread(t0, "張三");
        Thread thread1 = new Thread(t0, "李四");
        thread0.start();
        thread1.start();
    }
}
class T0 implements Runnable {
    int ticket = 100;
    @Override
    public /*synchronized*/ void run() { // 我們將鎖加在run方法上
        while (ticket > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized(this) {
                if (ticket <= 0) return; // 在同步代碼塊中再次判斷以確保執行緒安全
                System.out.printf("%s買了一張票，還剩%d張%n", Thread.currentThread().getName(), -- ticket);
            }
        }
    }
}

輸出結果：

...
李四買了一張票，還剩4張
李四買了一張票，還剩3張
張三買了一張票，還剩2張
張三買了一張票，還剩1張
李四買了一張票，還剩0張

通過在同步代碼塊中再次判斷以達到執行緒安全，

死鎖

并發編程中不只有執行緒安全問題，還有死鎖問題，

public class ThreadTest {
    public static void main(String[] args) {
        String lock1 = "A";
        String lock2 = "B";
        String lock3 = "C";
        Thread t0 = new Thread(new T0(lock1, lock2));
        Thread t1 = new Thread(new T0(lock2, lock3));
        Thread t2 = new Thread(new T0(lock3, lock1));
        t0.start();
        t1.start();
        t2.start();
    }
}
class T0 implements Runnable {
    String lock1;
    String lock2;
    T1(String lock1, String lock2) {
        this.lock1 = lock1;
        this.lock2 = lock2;
    }
    @Override
    public void run() {
        synchronized(lock1) {
            System.out.println("獲取鎖: " + lock1);
            synchronized(lock2) {
                System.out.println("獲取鎖: " + lock2);
            }
            System.out.println("釋放鎖: " + lock2);
        }
        System.out.println("釋放鎖: " + lock1);
    }
}

輸出結果：

獲取鎖：B
獲取鎖：A
獲取鎖：C

可以看出三個執行緒分別持有一把鎖，相互鎖住不能釋放，形成死鎖，
為了不寫出死鎖的并發代碼，我們需要學習釋放鎖的時機，

釋放鎖

  • run執行完畢，釋放鎖，

  • wait執行，釋放鎖，

  • sleep執行，不會釋放鎖，

  • join執行，不會釋放鎖，而是掛起當前執行緒，

  • notify執行，不會釋放鎖，

    public class ThreadTest {
    public static void main(String[] args) {
        String lock = "A";
        Thread thread0 = new Thread(new T0(lock), "T0");
        Thread thread1 = new Thread(new T1(lock), "T1");
        thread0.start();
        thread1.start();
    }
}
class T0 implements Runnable {
    String lock;
    public T0(String lock) {
        this.lock = lock;
    }
    @Override
    public void run() {
        synchronized(lock) {
            System.out.println(Thread.currentThread().getName() + "獲取鎖");
            try {
                lock.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName() + "釋放鎖");
        }
    }
}
class T1 implements Runnable {
    String lock;
    public T1(String lock) {
        this.lock = lock;
    }
    @Override
    public void run() {
        try {
            Thread.sleep(5000);
            synchronized(lock) {
                System.out.println(Thread.currentThread().getName() + "獲取鎖");
                lock.notify();
                Thread.sleep(5000);
                System.out.println(Thread.currentThread().getName() + "釋放鎖");
            }
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

    輸出結果：

    T0獲取鎖
T1獲取鎖
T1釋放鎖
T0釋放鎖

? 證明notify并不會釋放鎖，只是通知一個wait的執行緒：Waiting → Runnable(Ready)，接著在呼叫notify的執行緒執行完畢后釋放鎖，

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

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

標籤：其他

上一篇：使用 Mypy 檢查 30 萬行 Python 代碼，總結出 3 大痛點與 6 個技巧！

下一篇：顯示圖示而不是整數，反應原生資料

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 【C++】Microsoft C++、C 和匯編程式檔案

    ......

    uj5u.com 2020-09-10 00:57:23 more
  • 例外宣告

    相比于斷言適用于排除邏輯上不可能存在的狀態，例外通常是用于邏輯上可能發生的錯誤。 例外宣告 Item 1：當函式不可能拋出例外或不能接受拋出例外時，使用noexcept 理由 如果不打算拋出例外的話，程式就會認為無法處理這種錯誤，并且應當盡早終止，如此可以有效地阻止例外的傳播與擴散。 示例 //不可 ......

    uj5u.com 2020-09-10 00:57:27 more
  • Codeforces 1400E Clear the Multiset(貪心 + 分治)

    鏈接：https://codeforces.com/problemset/problem/1400/E 來源：Codeforces 思路：給你一個陣列，現在你可以進行兩種操作，操作1：將一段沒有 0 的區間進行減一的操作，操作2：將 i 位置上的元素歸零。最終問：將這個陣列的全部元素歸零后操作的最少 ......

    uj5u.com 2020-09-10 00:57:30 more
  • UVA11610 【Reverse Prime】

    本人看到此題沒有翻譯，就附帶了一個自己的翻譯版本 思考 這一題，它的第一個要求是找出所有 $7$ 位反向質數及其質因數的個數。 我們應該需要質數篩篩選1~$10^{7}$的所有數，這里就不慢慢介紹了。但是，重讀題，我們突然發現反向質數都是 $7$ 位，而將它反過來后的數字卻是 $6$ 位數，這就說明 ......

    uj5u.com 2020-09-10 00:57:36 more
  • 統計區間素數數量

    1 #pragma GCC optimize(2) 2 #include <bits/stdc++.h> 3 using namespace std; 4 bool isprime[1000000010]; 5 vector<int> prime; 6 inline int getlist(int ......

    uj5u.com 2020-09-10 00:57:47 more
  • C/C++編程筆記：C++中的 const 變數詳解，教你正確認識const用法

    1、C中的const 1、區域const變數存放在堆疊區中，會分配記憶體（也就是說可以通過地址間接修改變數的值）。測驗代碼如下： 運行結果： 2、全域const變數存放在只讀資料段（不能通過地址修改，會發生寫入錯誤）， 默認為外部聯編，可以給其他源檔案使用（需要用extern關鍵字修飾） 運行結果： ......

    uj5u.com 2020-09-10 00:58:04 more
  • 【C++犯錯記錄】VS2019 MFC添加資源不懂如何修改資源宏ID

    1. 首先在資源視圖中，添加資源 2. 點擊新添加的資源，復制自動生成的ID 3. 在解決方案資源管理器中找到Resource.h檔案，編輯，使用整個專案搜索和替換的方式快速替換 宏宣告 4. Ctrl+Shift+F 全域搜索，點擊查找全部，然后逐個替換 5. 為什么使用搜索替換而不使用屬性視窗直 ......

    uj5u.com 2020-09-10 00:59:11 more
  • 【C++犯錯記錄】VS2019 MFC不懂的批量添加資源

    1. 打開資源頭檔案Resource.h，在其中預先定義好宏 ID（不清楚其實ID值應該設定多少，可以先新建一個相同的資源項，再在這個資源的ID值的基礎上遞增即可） 2. 在資源視圖中選中專案資源，按F7編輯資源檔案，按 ID 型別 相對路徑的形式添加 資源。（別忘了先把檔案拷貝到專案中的res檔案 ......

    uj5u.com 2020-09-10 01:00:19 more
  • C/C++編程筆記：關于C++的參考型別，專供新手入門使用

    今天要講的是C++中我最喜歡的一個用法——參考，也叫別名。 參考就是給一個變數名取一個變數名，方便我們間接地使用這個變數。我們可以給一個變數創建N個參考，這N + 1個變數共享了同一塊記憶體區域。(參考型別的變數會占用記憶體空間，占用的記憶體空間的大小和指標型別的大小是相同的。雖然參考是一個物件的別名，但 ......

    uj5u.com 2020-09-10 01:00:22 more
  • 【C/C++編程筆記】從頭開始學習C ++：初學者完整指南

    眾所周知，C ++的學習曲線陡峭，但是花時間學習這種語言將為您的職業帶來奇跡，并使您與其他開發人員區分開。您會更輕松地學習新語言，形成真正的解決問題的技能，并在編程的基礎上打下堅實的基礎。 C ++將幫助您養成良好的編程習慣（即清晰一致的編碼風格，在撰寫代碼時注釋代碼，并限制類內部的可見性），并且由 ......

    uj5u.com 2020-09-10 01:00:41 more
最新发布
  • Rust中的智能指標:Box<T> Rc<T> Arc<T> Cell<T> RefCell<T> Weak

    Rust中的智能指標是什么 智能指標（smart pointers）是一類資料結構，是擁有資料所有權和額外功能的指標。是指標的進一步發展 指標（pointer）是一個包含記憶體地址的變數的通用概念。這個地址參考，或 ” 指向”（points at）一些其 他資料 。參考以 & 符號為標志并借用了他們所 ......

    uj5u.com 2023-04-20 07:24:10 more
  • Java的值傳遞和參考傳遞

    值傳遞不會改變本身，參考傳遞（如果傳遞的值需要實體化到堆里）如果發生修改了會改變本身。 1.基本資料型別都是值傳遞 package com.example.basic; public class Test { public static void main(String[] args) { int ......

    uj5u.com 2023-04-20 07:24:04 more
  • [2]SpinalHDL教程——Scala簡單入門

    第一個 Scala 程式 shell里面輸入 $ scala scala> 1 + 1 res0: Int = 2 scala> println("Hello World!") Hello World! 檔案形式 object HelloWorld { /* 這是我的第一個 Scala 程式 * 以 ......

    uj5u.com 2023-04-20 07:23:58 more
  • 理解函式指標和回呼函式

    理解 函式指標 指向函式的指標。比如： 理解函式指標的偽代碼 void (*p)(int type, char *data); // 定義一個函式指標p void func(int type, char *data); // 宣告一個函式func p = func; // 將指標p指向函式func ......

    uj5u.com 2023-04-20 07:23:52 more
  • Django筆記二十五之資料庫函式之日期函式

    本文首發于公眾號：Hunter后端 原文鏈接：Django筆記二十五之資料庫函式之日期函式 日期函式主要介紹兩個大類，Extract() 和 Trunc() Extract() 函式作用是提取日期，比如我們可以提取一個日期欄位的年份，月份，日等資料 Trunc() 的作用則是截取，比如 2022-0 ......

    uj5u.com 2023-04-20 07:23:45 more
  • 一天吃透JVM面試八股文

    什么是JVM？ JVM，全稱Java Virtual Machine（Java虛擬機），是通過在實際的計算機上仿真模擬各種計算機功能來實作的。由一套位元組碼指令集、一組暫存器、一個堆疊、一個垃圾回收堆和一個存盤方法域等組成。JVM屏蔽了與作業系統平臺相關的資訊，使得Java程式只需要生成在Java虛擬機 ......

    uj5u.com 2023-04-20 07:23:31 more
  • 使用Java接入小程式訂閱訊息！

    更新完微信服務號的模板訊息之后，我又趕緊把微信小程式的訂閱訊息給實作了！之前我一直以為微信小程式也是要企業才能申請，沒想到小程式個人就能申請。 訊息推送平臺🔥推送下發【郵件】【短信】【微信服務號】【微信小程式】【企業微信】【釘釘】等訊息型別。 https://gitee.com/zhongfuch ......

    uj5u.com 2023-04-20 07:22:59 more
  • java -- 緩沖流、轉換流、序列化流

    緩沖流 緩沖流, 也叫高效流, 按照資料型別分類： 位元組緩沖流：BufferedInputStream，BufferedOutputStream 字符緩沖流：BufferedReader，BufferedWriter 緩沖流的基本原理，是在創建流物件時，會創建一個內置的默認大小的緩沖區陣列，通過緩沖 ......

    uj5u.com 2023-04-20 07:22:49 more
  • Java-SpringBoot-Range請求頭設定實作視頻分段傳輸

    老實說，人太懶了，現在基本都不喜歡寫筆記了，但是網上有關Range請求頭的文章都太水了 下面是抄的一段StackOverflow的代碼...自己大修改過的，寫的注釋挺全的，應該直接看得懂，就不解釋了 寫的不好...只是希望能給視頻網站開發的新手一點點幫助吧. 業務場景：視頻分段傳輸、視頻多段傳輸（理 ......

    uj5u.com 2023-04-20 07:22:42 more
  • Windows 10開發教程_編程入門自學教程_菜鳥教程-免費教程分享

    教程簡介 Windows 10開發入門教程 - 從簡單的步驟了解Windows 10開發，從基本到高級概念，包括簡介，UWP，第一個應用程式，商店，XAML控制元件，資料系結，XAML性能，自適應設計，自適應UI，自適應代碼，檔案管理，SQLite資料庫，應用程式到應用程式通信，應用程式本地化，應用程式 ......

    uj5u.com 2023-04-20 07:22:35 more

Copyright © 2010-2020 有解無憂