Java JUC&多線程 基礎完整版

来源:https://www.cnblogs.com/MineLSG/p/18210998
-Advertisement-
Play Games

Java JUC&多線程 基礎完整版 目錄Java JUC&多線程 基礎完整版1、 多線程的第一種啟動方式之繼承Thread類2、多線程的第二種啟動方式之實現Runnable介面3、多線程的第三種實現方式之實現Callable介面4、多線的常用成員方法5、線程的優先順序6、守護線程7、線程的讓出8、線 ...


Java JUC&多線程 基礎完整版

目錄

1、 多線程的第一種啟動方式之繼承Thread類

優點: 比較簡單,可以直接使用Thread類中的方法，缺點: 可以拓展性比較差,不能再繼承其他的類

線程類MyThread

public class MyThread extends Thread {


    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "Hello World");
        }
    }
}

執行類ThreadDemo

public class ThreadDemo {

    public static void main(String[] args) {
        /*
         * 多線程第一種啟動方式
         * 1. 自己定義一個類繼承Thread
         * 2. 重寫run方法
         * 3. 創建啟動對象,並啟動線程
         */

        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        t1.setName("線程1");
        t2.setName("線程2");
        t1.start();
        t2.start();
    }

}

2、多線程的第二種啟動方式之實現Runnable介面

優點: 拓展性強,實現該介面的同時可以繼承其他的類，缺點: 相對複雜,不能直接使用Thread類中的方法

線程類MyRunnable

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        // 線程要執行的代碼
        for (int i = 0; i < 100; i++) {
            // 先獲取當前線程的對象
            Thread thread = Thread.currentThread();
            System.out.println(thread.getName() + "Hello World");
        }
    }
}

執行類ThreadDemo

public class ThreadDemo {

    public static void main(String[] args) {
        /*
         * 多線程的第二種啟動方式
         * 1. 自定義一個類實現Runnable介面
         * 2. 重寫裡面的run方法
         * 3. 創建自己的類對象
         * 4.創建一個Thread類的對象,並開啟線程
         *
         */

        // 任務對象
        MyRunnable myRun = new MyRunnable();
        // 線程對象
        Thread t1 = new Thread(myRun);
        Thread t2 = new Thread(myRun);

        // 給線程設置名字
        t1.setName("線程1");
        t2.setName("線程2");
        // 開啟線程
        t1.start();
        t2.start();
    }
}

3、多線程的第三種實現方式之實現Callable介面

優點: 拓展性強,實現該介面的同時可以繼承其他的類，相對複雜,不能直接使用Thread類中的方法

線程類MyCallable

public class MyCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        // 求1~100之間的和
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            sum = sum + i;
        }
        return sum;
    }
}

執行類ThreadDemo

public class ThreadDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /*
         * 多線程的第三種實現方式
         *   特點： 可以獲取到多線程的運行結果
         *  1. 創建一個MyCallable類實現Callable介面
         *  2. 重寫call (是有返回值的,表示多線程運行的結果)
         *  3. 創建MyCallable的對象 (表示多線程要執行的任務)
         *  4. 創建FutureTask的對象 (管理多線程運行的結果)
         *  5. 創建Thread類的對象 並啟動(表示線程)
         */

        // 創建MyCallable對象 (表示要執行的多線程的任務)
        MyCallable mc = new MyCallable();
        // 創建FutureTask的對象 (作用管理多線程運行的結果)
        FutureTask<Integer> ft = new FutureTask<>(mc);
        // 創建線程對象
        Thread t1 = new Thread(ft);
        // 啟動線程
        t1.start();

        // 獲取多線程運行的結果
        Integer result = ft.get();
        System.out.println(result);

    }
}

4、多線的常用成員方法

  • String getName() 返回此線程的名稱
  • void setName(String name) 設置線程名稱(構造方法也可以設置名稱)
    • 細節
      • 1.如果不設置線程名稱,線程也是有預設序號的,從0開始格式為Thread-X
      • 2.如果給線程設置名稱可以使用setName和子類的構造方法
    • 細節
      • 當jvm虛擬機啟動後會自動啟動多條線程，其中就有一個線程名字為main他的作用就是調用main方法,執行裡面的代碼
  • static void sleep(long time) 讓線程休眠指定的時間, 單位為毫秒
    • 細節
      • 哪條線程執行到了這個方法,那麼哪條線程就會在這裡停留相對於的時間方法的參數就表示睡眠的時間,單位為毫秒時間到了後線程會自動蘇醒,並繼續執行

線程類MyThread

public class MyThread extends Thread {

    // 構造方式設置線程名稱
    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "@" + i);
        }
    }
}

執行類ThreadDemo

public class ThreadDemo {

    public static void main(String[] args) {

        // 1.創建線程的對象
        MyThread t1 = new MyThread("飛機");
        MyThread t2 = new MyThread("坦克");


        // 2.開啟線程
        t1.start();
        t2.start();

        // 哪條線程執行到這個方法,此時獲取的就是哪條線程的對象
        Thread thread = Thread.currentThread();
        System.out.println("main方法線程" + thread.getName());
    }
}

5、線程的優先順序

  • setPriority(int newPriority) 設置線程優先順序
  • final int getPriority() 獲取線程優先順序

線程類MyRunnable

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "===" + i);
        }
    }
}

執行類ThreadDemo

public class ThreadDemo {

    public static void main(String[] args) {
        /*
         * setPriority(int newPriority)  設置線程優先順序
         * final int getPriority() 獲取線程優先順序
         *
         */
        // 創建線程要執行的參數對象
        MyRunnable mr = new MyRunnable();
        // 創建線程對象
        Thread t1 = new Thread(mr, "飛機");
        Thread t2 = new Thread(mr, "坦克");

        // 設置優先順序
        t1.setPriority(1);
        t2.setPriority(10);

        // 查看線程優先順序
        System.out.println(t1.getPriority());
        System.out.println(t2.getPriority());

        // 啟動線程
        t1.start();
        t2.start();
    }
}

6、守護線程

final void setDaemon(boolean on) 設置為守護線程(備胎線程)，當其他的非守護線程執行結束後,守護線程會陸續結束，當非守護線程結束後,守護線程就沒有存在的必要了。

線程類MyThread1,MyThread2

public class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName() + "@" + i);
        }
    }
}

public class MyThread2 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "@" + i);
        }
    }
}

執行類ThreadDemo

public class ThreadDemo {

    public static void main(String[] args) {

        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();

        t1.setName("女神");
        t2.setName("備胎");

        // 線程2設置為守護線程
        t2.setDaemon(true);

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

7、線程的讓出

public static void yield() 出讓線程/禮讓線程，讓出當前執行線程CPU的執行權

線程類MyThread

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "@" + i);
            // 出讓當前CPU的執行權
            Thread.yield();
        }
    }
}

執行類ThreadDemo

public class ThreadDemo {
    public static void main(String[] args) {

        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        t1.setName("飛機");
        t2.setName("坦克");

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

8、線程插隊

public final void join() 插入線程/插隊線程，講指定的線程插入到main(當前線程)之前執行

線程類MyThread

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "@" + i);
        }
    }
}

執行類ThreadDemo

public class ThreadDemo {

    public static void main(String[] args) throws InterruptedException {

        MyThread t1 = new MyThread();
        t1.setName("土豆");
        t1.start();
        // 將t1(土豆) 線程插入到main線程(當前線程)之前
        t1.join();

        // 執行在main線程中
        for (int i = 0; i < 10; i++) {
            System.out.println("main線程" + i);
        }
    }
}

9、同步代碼塊

在需要同步的代碼塊中加入synchronized(當前類位元組碼文件)

線程類MyThread

public class MyThread extends Thread {

    /**
     * 票號,所有的類都共用該票號
     */
    static int ticket = 0;

    @Override
    public void run() {
        while (true) {
            // 使用同步代碼塊枷鎖，鎖對象必須是唯一的才行(使用當前類位元組碼)
            synchronized (MyThread.class) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                if (ticket < 100) {
                    ticket++;
                    System.out.println(getName() + "正在賣第" + ticket + "張票!");
                } else {
                    break;
                }
            }
        }
    }
}

執行類ThreadDemo

public class ThreadDemo {

    public static void main(String[] args) {

        /*
         * 需求
         *       某電影院有100張票,只有三個買票視窗,使用多線程設計一個模擬程式來賣票
         * 利用同步代碼塊來完成
         */

        // 創建線程對象
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        // 起名字
        t1.setName("視窗1");
        t2.setName("視窗2");
        t3.setName("視窗3");

        // 開啟線程
        t1.start();
        t2.start();
        t3.start();
    }
}

10、同步方法

將需要同步的代碼抽取為一個方法，並使用synchronized進行修飾

線程類MyRunnable

public class MyRunnable implements Runnable {

    int ticket = 0;

    @Override
    public void run() {
        // 1.寫迴圈
        while (true) {
            // 2.同步代碼塊(同步方法)
            if (method()) {
                break;
            }
        }
    }

    // 3.同步方法(從同步代碼塊中抽取出來)
    private synchronized boolean method() {
        // 4.共用代碼是否到了末尾
        if (ticket == 1000) {
            return true;
        } else {
            ticket++;
            System.out.println(Thread.currentThread().getName() + "在賣第" + ticket + "張票");
        }
        return false;
    }
}

執行類ThreadDemo

public class ThreadDemo {

    public static void main(String[] args) {

        /*
         * 需求
         *       某電影院有100張票,只有三個買票視窗,使用多線程設計一個模擬程式來賣票
         *  利用同步方法來完成
         */

        MyRunnable mr = new MyRunnable();

        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);
        Thread t3 = new Thread(mr);

        t1.setName("視窗1");
        t2.setName("視窗2");
        t3.setName("視窗3");

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

    }
}

11、線程鎖

lock() 配合使用可以達到synchronized相同操作

線程類MyThread

public class MyThread extends Thread {

    static int ticket = 0;

    // 只有一把鎖
    static Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            // 2.同步代碼塊
            // synchronized (MyThread.class) {
            lock.lock(); // 加鎖
            // 3.判斷
            try {
                if (ticket == 100) {
                    break;
                } else {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticket++;
                    System.out.println(getName() + "在賣第" + ticket + "張票");
                }
            }finally {
                lock.unlock(); // 釋放鎖
            }
            //   }
        }

    }
}

執行類ThreadDemo

public class ThreadDemo {
    public static void main(String[] args) {

        /*
         * 需求：
         *      某電影院目前正在上映國產電影,共有100張票,3個視窗
         *      使用JDK的lock實現
         */
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        t1.setName("視窗1");
        t2.setName("視窗2");
        t3.setName("視窗3");

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

12、死鎖問題

死鎖原因常見於鎖的嵌套等操作，導致相互獲取不到資源產生的等待問題

線程類MyThread

public class MyThread extends Thread{

    static Object objA = new Object();
    static Object objB = new Object();

    @Override
    public void run() {
        // 1.迴圈
        while (true){
            if ("線程A".equals(getName())){
                synchronized (objA){
                    System.out.println("線程A拿到了A鎖，準備拿B鎖");
                    synchronized (objB){
                        System.out.println("線程A拿到了B");
                    }
                }
            }else if ("線程B".equals(getName())){
                if ("線程B".equals(getName())){
                    synchronized (objB){
                        System.out.println("線程B拿到了B鎖，準備拿A鎖");
                        synchronized (objA){
                            System.out.println("線程B拿到了A鎖，順利執行完了一輪");
                        }
                    }
                }
            }
        }
    }
}

執行類ThreadDemo

public class ThreadDemo {

    public static void main(String[] args) {
        /*
         * 需求：死鎖
         */
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        t1.setName("線程A");
        t2.setName("線程B");

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

13、等待喚醒機制(消費者模式)

生產者(Cook) => 中間者(Desk) <= 消費者(Foodie)

線程類Cook,Foodie

/**
* 廚師
*/
public class Cook extends Thread {

    /**
     * 1.迴圈
     * 2.同步代碼塊
     * 3.判斷共用數據是否到末尾(到了)
     * 4.判斷共用數據是否到末尾(沒有,執行核心邏輯)
     */

    @Override
    public void run() {
        // 1.迴圈
        while (true) {
            // 2.同步代碼塊
            synchronized (Desk.lock) {
                // 3.判斷共用數據是否到末尾(到了)
                if (Desk.count == 0) {
                    break;
                } else {
                    // 4.判斷共用數據是否到末尾(沒有,執行核心邏輯)

                    // 判斷桌子上是否有食物
                    if (Desk.foodFlag == 1) {
                        // 如果有 就等待
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }else {
                        // 如果沒有 就製作
                        System.out.println("廚師做了一碗麵條");
                        // 修改桌子上食物狀態
                        Desk.foodFlag = 1;
                        // 叫醒等待的消費者開吃
                        Desk.lock.notifyAll();
                    }
                }
            }
        }
    }
}

/**
* 客人
*/
public class Foodie extends Thread {

    /**
     * 1.迴圈
     * 2.同步代碼塊
     * 3.判斷共用數據是否到末尾(到了)
     * 4.判斷共用數據是否到末尾(沒有,執行核心邏輯)
     */

    @Override
    public void run() {

        // 1.迴圈
        while (true) {
            // 2.同步代碼塊
            synchronized (Desk.lock) {
                // 3.判斷共用數據是否到了末尾(到了末尾,線程執行完畢)
                if (Desk.count == 0) {
                    break;
                } else {
                    // 4.判斷共用數據是否到了末尾(沒有到末尾,執行核心邏輯)
                    // 先判斷桌子上是否有麵條
                    if (Desk.foodFlag == 0) {
                        // 沒有就等待
                        try {
                            Desk.lock.wait(); // 讓當前線程跟鎖進行綁定
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    } else {
                        // 把吃的總數減一
                        Desk.count--;
                        // 有就開吃
                        System.out.println("吃貨正在吃麵條,還能吃" + Desk.count + "碗!");
                        // 吃完後喚醒廚師繼續製作
                        Desk.lock.notifyAll();
                        // 修改桌子狀態
                        Desk.foodFlag = 0;
                    }
                }
            }
        }
    }
}

/**
* 中間者 桌子
*/
public class Desk {
    /*
     * 控制生產者和消費者的執行
     */

    /**
     * 桌子上是否有麵條 0:沒有 1:有
     */
    public static int foodFlag = 0;

    /**
     * 總個數,最多能吃10碗
     */
    public static int count = 10;

    // 鎖對象
    public static Object lock = new Object();

}

執行類ThreadDemo

public class ThreadDemo {

    public static void main(String[] args) {
        /*
         * 需求：完成生產者和消費者(等待喚醒機制)的代碼
         *      實現線程輪流交替的執行效果
         *
         * 生產者 ===> 中間者 <=== 消費者
         *
         */

        // 創建線程對象
        Cook cook = new Cook();
        Foodie foodie = new Foodie();

        cook.setName("廚師");
        foodie.setName("客人");

        // 開啟線程
        cook.start();
        foodie.start();

    }
}

14、阻塞隊列下的等待喚醒機制

生產者和消費者必須使用同一個隊列ArrayBlockingQueue

生產者 => ArrayBlockingQueue <= 消費者

線程類Cook,Foodie

/**
* 廚師
*/
public class Cook extends Thread {

    ArrayBlockingQueue<String> queue;

    public Cook(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }


    @Override
    public void run() {

        while (true) {
            // 不斷的把麵條放入阻塞隊列中
            try {
                // put方法底層實現了鎖操作,所以無需加鎖
                queue.put("麵條");
                System.out.println("廚師放了一碗麵條");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

/**
* 客人
*/
public class Foodie extends Thread {

    ArrayBlockingQueue<String> queue;

    public Foodie(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true) {
            // 不斷的從阻塞隊列中獲取麵條
            // peek方法底層實現了鎖操作,所以無需加鎖
            String food = null;
            try {
                food = queue.take();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("客戶吃了 " + food);
        }
    }
}

執行類ThreadDemo

public class ThreadDemo {

    public static void main(String[] args) {

        /*
         * 需要：利用阻塞隊列完成生產者和消費者（等待喚醒機制）的代碼
         * 細節：
         *      生產者和消費者必須使用同一個隊列
         */

        // 1.創建阻塞隊列(容量位1 )
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(1);

        // 2.創建線程對象，並把阻塞隊列傳遞過去
        Cook cook = new Cook(queue);
        Foodie foodie = new Foodie(queue);

        // 3.開啟線程
        cook.start();
        foodie.start();
    }
}

線程池

1、線程池的創建

ExecutorService newCachedThreadPool() 創建一個沒有上限的線程池

ExecutorService new FixedThreadPool(int nThread) 創建有上限的線程池

線程類MyRunnable

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

執行類MyThreadPoolDemo

public class MyThreadPoolDemo {

    public static void main(String[] args) throws InterruptedException {

        /*
         * public static ExecutorService newCachedThreadPool() 創建一個沒有上限的線程池
         * public static ExecutorService new FixedThreadPool(int nThread) 創建有上限的線程池
         */

        fixedThreadPool();
    }

    public static void newCachedThreadPool() throws InterruptedException {
        // 1.獲取線程池對象
        ExecutorService pool1 = Executors.newCachedThreadPool();

        // 2.提交任務
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);
        pool1.submit(new MyRunnable());


        // 3.銷毀線程池
        pool1.shutdown();
    }

    public static void fixedThreadPool() throws InterruptedException {
        // 創建三個線程
        ExecutorService pool1 = Executors.newFixedThreadPool(3);
        // 2.提交任務
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);
        pool1.submit(new MyRunnable());

        // 3.銷毀線程池
        pool1.shutdown();
    }
}

2、自定義線程池

(核心線程數量, 最大線程數量, 空閑線程最大存活時間, 任務隊列, 創建線程工廠, 任務的拒絕策略)
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
	參數一： 核心線程數量      不能小於0,
	參數二： 最大線程數       不能小於等於0，最大數量 >= 核心線程數量,
	參數三： 控線線程最大存活時間      不能小於0,
	參數四： 線程存活時間單位        用TimeUnit指定,
	參數五： 任務隊列        不能為null,
	參數六： 創建線程工廠      不能為null,
	參數七： 任務的拒絕策略     不能為null
);

例子,MyThreadPoolDemo1

public class MyThreadPoolDemo1 {

    public static void main(String[] args) {
        // 自定義線程池
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                // 核心線程數量,不能小於0
                3,
                // 最大線程數不能小於等於0，最大數量 >= 核心線程數量
                6,
                // 控線線程最大存活時間
                60,
                // 線程存活時間單位，用TimeUnit指定
                TimeUnit.SECONDS,
                // 任務隊列
                new ArrayBlockingQueue<>(3),
                // 創建線程工廠
                Executors.defaultThreadFactory(),
                //  任務的拒絕策略
                new ThreadPoolExecutor.CallerRunsPolicy()
        );

        // 提交任務到線程池
        pool.submit(() -> {
            System.out.println(Thread.currentThread().getName());
        });
    }
}

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 說說webpack的熱更新是如何做到的？原理是什麼？
    一、是什麼 HMR全稱 Hot Module Replacement，可以理解為模塊熱替換，指在應用程式運行過程中，替換、添加、刪除模塊，而無需重新刷新整個應用 例如，我們在應用運行過程中修改了某個模塊，通過自動刷新會導致整個應用的整體刷新，那頁面中的狀態信息都會丟失 如果使用的是 HMR，就可以實 ...
  • lodash已死？radash庫方法介紹及源碼解析 —— 對象方法篇
    theme: nico 寫在前面 主頁有更多其他篇章的方法，歡迎訪問查看。 本篇我們介紹radash中對象相關方法的使用和源碼解析。 assign：遞歸合併兩個對象 使用說明 功能說明：類似於 JavaScript 的 Object.assign 方法，用於將 override 對象的屬性和值複製到 ...
  • Vue 3 組件基礎與模板語法詳解
    title: Vue 3 組件基礎與模板語法詳解 date: 2024/5/24 16:31:13 updated: 2024/5/24 16:31:13 categories: 前端開發 tags: Vue3特性 CompositionAPI Teleport Suspense Vue3安裝 組件 ...
  • Python游戲編程：一步步用Python打造經典貪吃蛇小游戲
    貪吃蛇作為一款極其經典且廣受歡迎的小游戲，是早期 Windows 電腦和功能手機（特別是諾基亞手機）流行度極高的小游戲，是當時功能手機時代最具代表性的游戲之一。游戲的基本規則和目標十分簡單，但卻極具吸引力，讓人欲罷不能。本博文我們用 Python 編寫屬於自己的貪吃蛇游戲，一起來體驗一下編程的樂趣與... ...
  • 在Linux下管理MySQL的大小寫敏感性
    當開發與Linux環境下MySQL資料庫交互的Java應用程式時，理解MySQL中的大小寫敏感性可以避免潛在的錯誤和問題。本指南深入探討了MySQL中的大小寫敏感設置，比較了5.7和8.0版本，併為Java開發者提供了最佳實踐。 1 理解MySQL中的大小寫敏感性 預設情況下，MySQL在Windo ...
  • Spring6 對 集成MyBatis 開發運用(附有詳細的操作步驟)
    1. Spring6 對 集成MyBatis 開發運用(附有詳細的操作步驟) @目錄1. Spring6 對 集成MyBatis 開發運用(附有詳細的操作步驟)每博一文案2. 大概的實現步驟概述3. 詳細實現操作步驟4. Spring配置文件的 import，導入外部xml 配置5. 總結：6. 最 ...
  • 白嫖免費圖床！CloudFlare R2太香了！
    1 為啥要折騰搭建一個專屬圖床？ 技術大佬寫博客都用 md 格式，要在多平臺發佈，圖片就得有外鏈 後續如博客遷移，國內博客網站如掘金，簡書，語雀等都做了防盜鏈，圖片無法遷移 2 為啥選擇CloudFlare R2 跳轉：https://dash.cloudflare.com/ 有白嫖額度 免費 CD ...
  • 實時識別關鍵詞API介面，將搜索結果提升至新的高度！
    實時識別關鍵詞是一種能夠將搜索結果提升至新的高度的API介面。它可以幫助我們更有效地分析文本，並提取出關鍵詞，以便進行進一步的處理和分析。 該介面是挖數據平臺提供的，有三種模式：精確模式、全模式和搜索引擎模式。不同的模式在分詞的方式上有所不同，適用於不同的場景。 首先是精確模式。這種模式會儘量將句子 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類