Java學習-第一部分-第二階段-第七節：泛型

来源:https://www.cnblogs.com/wenjie2000/archive/2022/09/01/16646637.html
-Advertisement-
Play Games

線程 筆記目錄：(https://www.cnblogs.com/wenjie2000/p/16378441.html) 程式(program) 是為完成特定任務、用某種語言編寫的一組指令的集合。簡單的說:就是我們寫的代碼 進程 進程是指運行中的程式，比如我們使用QQ，就啟動了一個進程，操作系統就會 ...


線程

筆記目錄：(https://www.cnblogs.com/wenjie2000/p/16378441.html)

程式(program)

是為完成特定任務、用某種語言編寫的一組指令的集合。簡單的說:就是我們寫的代碼

進程

  1. 進程是指運行中的程式，比如我們使用QQ，就啟動了一個進程，操作系統就會為該進程分配記憶體空間。當我們使用迅雷，又啟動了一個進程，操作系統將為迅雷分配新的記憶體空間。
  2. 進程是程式的一次執行過程，或是正在運行的一個程式。是動態過程:有它自身的產生、存在和消亡的過程

線程介紹

什麼是線程

  1. 線程由進程創建的，是進程的一個實體2.一個進程可以擁有多個線程（例如迅雷中 多個下載任務同時進行）

  2. 坦克大戰（每個敵人坦克就是一個線程）[後面會把多線程加入到坦克大戰中，學以致用]

其他相關概念

  1. 單線程:同一個時刻，只允許執行一個線程

  2. 多線程:同一個時刻，可以執行多個線程，比如:一個qq進程，可以同時打開多個聊天視窗,一個迅雷進程，可以同時下載多個文件

  3. 併發:同一個時刻，多個任務交替執行，造成一種“貌似同時”的錯覺，簡單的說，單核cpu實現的多任務就是併發。

    image

  4. 並行:同一個時刻，多個任務同時執行。多核cpu可以實現並行。

    image

    public class Test {
    public static void main(String[] args) {
        Runtime runtime = Runtime.getRuntime();
        //獲取當前電腦的cpu數量/核心數
        int cpuNums = runtime.availableProcessors();
        System.out.println("當前有CPU個數"+cpuNums);
    }
}

線程使用

創建線程的兩種方式

在java中線程來使用有兩種方法。

  1. 繼承Thread類,重寫run方法

  2. 實現Runnable介面，重寫run方法

image

繼承Thread

線程應用案例1-繼承Thread類

  1. 請編寫程式,開啟一個線程，該線程每隔1秒。在控制台輸出“啪瞄,我是小貓咪'

  2. 對上題改進:當輸出80次唶瞄,我是小貓咪，結束該線程

  3. 使用JConsole監控線程執行情況，並畫出程式示意圖!

    image

public class Test {
    public static void main(String[] args) throws InterruptedException {
        //創建Cat對象，可以當做線程使用
        Cat cat = new Cat();

        /*
            (1)
            public synchronized void start() {
                start0();
            }
            (2)
            //start0()是本地方法，是JVM調用，底層是c/c++實現
            //真正實現多線程的效果，是start0()，而不是 run
            private native void start0();
        */

        cat.start();//啟動線程
        //cat.run();//run方法就是一個普通的方法，沒有真正的啟動一個線程，就會把run方法執行完畢，才向下執行

        //說明:當main線程啟動一個子線程 Thread-0，主線程不會阻塞，會繼續執行//這時主線程和子線程是交替執行..
        System.out.println("主線程繼續執行" + " 線程名" + Thread.currentThread().getName());//線程main
        for (int i = 0; i < 60; i++) {
            System.out.println("主線程i=" + i);
            //讓主線程休眠
            Thread.sleep(1000);
        }

    }
}
//說明
//1。當一個類繼承了 Thread 類，該類就可以當做線程使用
//2．我們會重寫 run方法，寫上自己的業務代碼
//3.run Thread類實現了Runnable介面的run方法
/*
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
*/

class Cat extends Thread {
    int times = 0;

    @Override
    public void run() {
        while (true) {
            //該線程每隔1秒。在控制台輸出“瞄瞄，我是小貓咪"
            System.out.println("瞄瞄，我是小貓咪" + " 線程名" + (++times) + Thread.currentThread().getName());//讓該線程休眠1秒ctrl+alt+t
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (times == 80) {
                break; //當times 到80，退出while，這時線程也就退出..
            }
        }
    }
}

start()方法原理

image

實現Runnable

線程應用案例2-實現Runnable介面

說明

  1. java是單繼承的，在某些情況下一個類可能已經繼承了某個父類,這時在用繼承Thread類方法來創建線程顯然不可能了。
  2. java設計者們提供了另外一個方式創建線程，就是通過實現Runnable介面來創建線程

線程使用應用案例-實現Runnable介面

應用案例

請編寫程式該程式可以每隔1秒。在控制台輸出“hi!”,當輸出10次後，自動退出。請使用實現Runnable介面的方式實現。

public class Test {
    public static void main(String[] args) throws InterruptedException {
        Dog dog = new Dog();
        //dog.start();這裡不能調用start
        //創建了Thread對象，把 dog對象(實現Runnable)，放入Thread
        Thread thread = new Thread(dog);
        thread.start();
    }
}

class Dog implements Runnable {//通過實現Runnable介面，開發線程
    int count = 0;

    @Override
    public void run() {//普通方法
        while (true) {
            System.out.println("小狗汪汪叫..hi" + (++count) + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count>10){
                break;
            }
        }
    }
}

這裡底層使用了設計模式【代理模式】

以下為代碼模擬 實現Runnable介面開發線程的機制(可以用來代替上述代碼中的Thread類的功能)此處只是模擬來展示原理，並不能實際創建新線程，任然是執行main線程

//線程代理類，模擬了一個極簡的Thread類
class ThreadProxy implements Runnable {//你可以把Proxy類當做 ThreadProxy
    private Runnable target = null;//屬性，類型是 Runnable

    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

    public ThreadProxy(Runnable target) {
        this.target = target;
    }

    public void start() {
        start0();
    }

    public void start0() {
        run();
    }
}

繼承Thread vs 實現Ruunnable的區別

  1. 從java的設計來看，通過繼承Thread或者實現Runnable介面來創建線程本質上沒有區別,從jdk幫助文檔我們可以看到Thread類本身就實現了Runnable介面
  2. 實現Runnable介面方式更加適合多個線程共用一個資源的情況，並且避免了單繼承的限制（建議使用Runnnable介面）

思考：[售票系統]，編程模擬三個售票視窗售票100張,分別使用繼承 Thread和實現Runnable方式,並分析有什麼問題?

public class Test {
    public static void main(String[] args) {
//測試
        SellTicket01 sellTicket01 = new SellTicket01();
        SellTicket01 sellTicket02 = new SellTicket01();
        SellTicket01 sellTicket03 = new SellTicket01();
        //這裡會出現超賣問題
        sellTicket01.start();//啟動售票線程
        sellTicket02.start();//啟動售票線程
        sellTicket03.start();//啟動售票線程
    }
}

class SellTicket01 extends Thread {
    private static int ticketNum = 100;//讓多個線程共用ticketNum

    @Override
    public void run() {

        while (true) {
            if (ticketNum <= 0) {
                System.out.println("售票結束...");
                break;
            }
            //休眠50毫秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("視窗" + Thread.currentThread().getName() +"售出一張票"
                    + "剩餘票數=" + (--ticketNum));
        }
    }
}

線程終止

基本說明

  1. 當線程完成任務後,會自動退出。
  2. 還可以通過使用變數來控制run方法退出的方式停止線程，即通知方式

●應用案例

需求:啟動一個線程，要求在main線程中去停止線程t,請編程實現.

public class Test {
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T();
        Thread thread = new Thread(t1);
        thread.start();
        //如果希望main線程去控制t1 線程的終止，必須可以修改 loop
        // 讓t1退出run方法，從而終止t1線程->通知方式
        //讓主線程休眠10秒，再通知t1線程退出
        System.out.println("main線程休眠10s");
        Thread.sleep(5 * 1000);
        t1.setLoop(false);
    }

}

class T implements Runnable {
    boolean loop = true;//步驟1:定義標記變數，預設為true@Override
    int count=0;
    @Override
    public void run() {
        while (loop) {//步驟2:將loop作為迴圈條件
            try {
                Thread.sleep(50);//讓當前線程休眠10ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("AThread運行中...."+(++count));
        }
    }

    //步驟3:提供公共的set方法，用於更新loop
    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

線程常用方法

常用方法第一組

  1. setName //設置線程名稱,，使之與參數name相同
  2. getName //返回該線程的名稱
  3. start //使該線程開始執行;Java虛擬機底層調用該線程的start0方法
  4. run //調用線程對象 run方法;
  5. setPriprity //更改線程的優先順序
  6. getPriority //獲取線程的優先順序
  7. sleep //在指定的毫秒數內讓當前正在執行的線程休眠(暫停執行)
  8. interrupt //中斷線程

註意事項和細節

  1. start底層會創建新的線程,調用run。run 就是一個簡單的方法調用，本身不會啟動新線程

  2. 線程優先順序的範圍

  3. sleep:線程的靜態方法,使當前線程休眠

  4. interrupt:中斷線程，但並沒有真正的結束線程。所以一般用於中斷正在休眠線程

    public class Test {
    public static void main(String[] args) throws InterruptedException {
        //測試相關的方法
        T t = new T();
        t.setName("老韓");
        t.setPriority(Thread.MIN_PRIORITY);//1
        t.start();//啟動子線程

        //主線程列印5hi，然後我就中斷子線程的休眠
        for (int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("hi " + i);
        }
        t.interrupt();//當執行到這裡,就會中斷t線程的休眠。

    }
}

class T extends Thread {
    int count=0;
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 100; i++) {
                //Thread.currentThread().getName()獲取當前線程的名稱
                System.out.println(Thread.currentThread().getName() + "吃包子~" + i);
            }
            try {
                System.out.println(Thread.currentThread().getName() + "休眠中 ~~~"+(++count));
                Thread.sleep(20000);//20秒
            } catch (InterruptedException e) {
                //當該線程執行到一個interrupt 方法時，就會catch一個異常，可以加入自己的業務代碼
                //InterruptedException是捕獲到一個中斷異常。
                System.out.println(Thread.currentThread().getName() + "被interrupt了");
            }
        }
    }
}

常用方法第二組

  1. yield:線程的禮讓。讓出cpu,讓其他線程執行,但禮讓的時間不確定,所以也不一定禮讓成功（例：Thread.yield();//禮讓自己使用cpu資源，不指定某一特定線程。具體用法看下麵代碼）

  2. join:線程的插隊。插隊的線程一旦插隊成功,則肯定
    先執行完插入的線程所有的任務（例：t2.join();//指定特定的某一線程先完成任務，再執行自己的工作）

    image

案例:創建一個子線程,每隔1s輸出hello,輸出20次,主線程每隔1秒,，輸出hi,輸出20次.要求:兩個線程同時執行，當主線程輸出5次後,就讓子線程運行完畢,主線程再繼續

public class Test {
    public static void main(String[] args) throws InterruptedException {
        T2 t2 = new T2();
        t2.start();
        for (int i = 1; i <= 20; i++) {
            Thread.sleep(1000);
            System.out.println("主線程(小弟)吃了" +i+"個包子");
            if (i == 5) {
                System.out.println("主線程(小弟)讓子線程(老大）先吃");
                //join，線程插隊
                //t2.join();// 這裡相當於讓t2 線程先執行完畢
                Thread.yield();//禮讓，不一定成功
                System.out.println("線程(老大)吃完了主線程(小弟）接著吃..");
            }
        }
    }
}

class T2 extends Thread {
    public void run() {
        for (int i = 1; i <= 20; i++) {
            try {
                Thread.sleep(1000);//休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子線程（老大）吃了" + i + "包子");
        }
    }
}

用戶線程和守護線程

  1. 用戶線程:也叫工作線程，當線程的任務執行完或通知方式結束
  2. 守護線星:一般是為工作線程服務的，當所有的用戶線程結束，守護線程自動結束
  3. 常見的守護線程:垃圾回收機制
public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        //如果我們希望當main線程結束後，子線程自動結束
        //,只需將子線程設為守護線程即可
        myDaemonThread.setDaemon(true);//守護線程要在該線程啟動前設置
        myDaemonThread.start();
        for (int i = 1; i <= 10; i++) {//main線程
            System.out.println("寶強在辛苦的工作...");
            Thread.sleep(1000);
        }
    }
}

class MyDaemonThread extends Thread {
    public void run() {
        while (true) {//無限迴圈
            try {
                Thread.sleep(1000);//休眠1000毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("馬蓉和宋喆快樂聊天，哈哈哈~~~");
        }
    }
}

線程的生命周期

JDK文檔中用Thread.State枚舉表示了線程的幾種狀態

image

線程狀態轉換圖

image

synchronized

線程同步機制

  1. 在多線程編程，一些敏感數據不允許被多個線程同時訪問,此時就使用同步訪問技術，保證數據在任何同一時刻，最多有一個線程訪問，以保證數據的完整性。
  2. 也可以這裡理解:線程同步，即當有一個線程在對記憶體進行操作時，其他線程都不可以對這個記憶體地址進行操作，直到該線程完成操作，其他線程才能對該內仔地址進行操作.

同步具體方法-Synchronized

註意 synchronized鎖的是一個特定的對象。而不是方法，也不是某塊代碼（由同一類創建的不同對象中的同一方法或代碼並不能被synchronized鎖）

  1. 同步代碼塊

    synchronized(對象){//得到對象的鎖，才能操作同步代碼
    //需要被同步代碼;
}

  2. synchronized還可以放在方法聲明中，表示整個方法-為同步方法

    public synchronized void m (String name){
	//需要被同步的代碼
}

線程同步可理解為上廁所問題

只有一間廁所（synchronized處理了的方法或代碼塊），進入一個人然後鎖上門（鎖），出來後下一個人才能進入。

使用synchronized解決售票問題（之前會出現剩餘票數為負數的情況）

public class Test {
    public static void main(String[] args) {
        //測試
        SellTicket03 sellTicket03 = new SellTicket03();

        new Thread(sellTicket03).start();//啟動售票線程1
        new Thread(sellTicket03).start();//啟動售票線程2
        new Thread(sellTicket03).start();//啟動售票線程3
    }
}

class SellTicket03 implements Runnable{
    private int ticketNum = 100;//讓多個線程共用ticketNum
    private boolean loop = true;

    @Override
    public void run() {

        while (loop) {
            ticketCheck();
        }
    }
    
    public synchronized void ticketCheck() {//註意此處 synchronized鎖的是一個特定的對象。而不是方法（由同一類創建的不同對象中的同一方法不能被synchronized鎖）
        if (ticketNum <= 0) {
            System.out.println("售票結束...");
            loop = false;
            return;
        }
        //休眠50毫秒
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("視窗" + Thread.currentThread().getName() + " 售出一張票 " + "剩餘票數=" + (--ticketNum));
    }
}

互斥鎖

基本介紹

  1. Java語言中，引入了對象互斥鎖的概念，來保證共用數據操作的完整性。
  2. 每個對象都對應於一個可稱為“互斥鎖”的標記，這個標記用來保證在任一時刻，只能有r-個線程訪問該對象。
  3. 關鍵字synchronized來與對象的互斥鎖聯繫。當某個對象用synchronized修飾時,表明該對象在任一時刻只能由一個線程訪問
  4. 同步的局限性:導致程式的執行效率要降低
  5. 同步方法（(非靜態的)的鎖可以是this(針對一個對象),也可以是其他對象(要求是同一個對象)
  6. 同步方法(靜態的)的鎖為當前類本身。
public class Test {
    public static void main(String[] args) {
        //測試
        SellTicket03 sellTicket03 = new SellTicket03();

        new Thread(sellTicket03).start();//啟動售票線程1
        new Thread(sellTicket03).start();//啟動售票線程2
        new Thread(sellTicket03).start();//啟動售票線程3
    }
}

class SellTicket03 implements Runnable {
    private int ticketNum = 100;//讓多個線程共用ticketNum
    private boolean loop = true;

    @Override
    public void run() {
        while (loop) {
            ticketCheck();
        }
    }

    //說明
    //1. public synchronized static void m1()丹鎖是加在SellTicket03.class
    //2．如果在靜態方法中，實現一個同步代碼塊.
    /*
    synchronized (SellTicket03.class) {
        System.out.println("m2");
    */
    public synchronized static void m1() {
    }

    public static void m2() {
        synchronized (SellTicket03.class) {
            System.out.println("m2");
        }
    }

    //說明
    //1. public synchronized void sell(){}就是一個同步方法
    //2．這時鎖在 this對象
    //3．也可以在代碼塊上寫 synchronize ,同步代碼塊
    public /*synchronized*/ void ticketCheck() {
        synchronized (this) {
            if (ticketNum <= 0) {
                System.out.println("售票結束...");
                loop = false;
                return;
            }
            //休眠50毫秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("視窗" + Thread.currentThread().getName() + " 售出一張票 " + "剩餘票數=" + (--ticketNum));
        }
    }
}

註意事項和細節

  1. 同步方法如果沒有使用static修飾:預設鎖對象為this

  2. 如果方法使用static修飾，預設鎖對象:當前類.class

  3. 實現的落地步驟:

    需要先分析上鎖的代碼
    選擇同步代碼塊或同步方法
    要求多個線程的鎖對象為同一個即可!

死鎖

基本介紹

多個線程都占用了對方的鎖資源,但不肯相讓，導致了死鎖，在編程是一定要避免死鎖的發生。

應用案例

媽媽：你先完成作業，才讓你玩手機

小明：你先讓我玩手機,我才完成作業。

模擬死鎖

public class Test {
    public static void main(String[] args) {
        //模擬死鎖現象
        DeadLockDemo A = new DeadLockDemo(true);
        A.setName("A線程");
        DeadLockDemo B = new DeadLockDemo(false);
        B.setName("B線程");
        A.start();
        B.start();
    }
}
//線程
class DeadLockDemo extends Thread {
    static Object o1 = new Object();//保證多線程，共用一個對象,這裡使用static
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {
        this.flag = flag;
    }

    //下麵業務邏輯的分析
    //1．如果flag為 T，線程A就會先得到/持有o1 對象鎖，然後嘗試去獲取o2對象鎖
    //2．如果線程A得不到o2對象鎖，就會Blocked
    //3．如果flag為F，線程B就會先得到/持有o2對象鎖，然後嘗試去獲取 o1對象鎖
    //4．如果線程B得不到 o1 對象鎖，就會Blocked
    //總的來說兩個線程都有對方的鎖，且都需要對方的鎖，如果沒有，就會一直等待，因而照成Blocked
    public void run() {
        if (flag) {
            synchronized (o1) {
                System.out.println(Thread.currentThread().getName() + "進入1");
                synchronized (o2) {// 這裡獲得li對象的監視權
                    System.out.println(Thread.currentThread().getName() + "進入2");
                }
            }
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + "進入3");
                synchronized (o1) {//這裡獲得li對象的監視權
                    System.out.println(Thread.currentThread().getName() + "進入4");
                }
            }
        }
    }
}

死鎖現象很危險，一定要避免。

釋放鎖

下麵操作會釋放鎖（還是將同步機制比作上廁所）

  1. 當前線程的同步方法、同步代碼塊執行結束

    案例:上廁所，完事出來

  2. 當前線程在同步代碼塊、同步方法中遇到break、return.

    案例:沒有正常的完事,經理叫他修改bug，不得已出來

  3. 當前線程在同步代碼塊、同步方法中出現了未處理的Error或Exception,導致異常結束

    案例:沒有正常的完事,發現忘帶紙,不得已出來

  4. 當前線程在同步代碼塊、同步方法中執行了線程對象的wait()方法，當前線程暫停，並釋放鎖。

    案例:沒有正常完事,覺得需要醞釀下，所以出來等會再進去，讓其他人先進來。

下麵操作不會釋放鎖

  1. 線程執行同步代碼塊或同步方法時，程式調用Thread.sleep()、Thread.yield()方法暫停當前線程的執行,不會釋放鎖

    案例:上廁所，太困了，在坑位上眯了一會

  2. 線程執行同步代碼塊時,其他線程調用了該線程的suspend()方法將該線程掛起,該線程不會釋放鎖。

    註意:應儘量避免使用suspend()和resume()來控制線程，這兩個方法官方不再推薦使用。


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

-Advertisement-
Play Games
更多相關文章
  • python帶你採集桌游、劇本殺游戲店數據信息~
    前言 嗨嘍~大家好呀，這裡是魔王吶 ! 又是學習的一天，讓我們開始叭~ 環境使用: Python 3.8 Pycharm 模塊使用: requests >>> pip install requests re csv 如果安裝python第三方模塊: win + R 輸入 cmd 點擊確定, 輸入安裝 ...
  • java中的一維數組
    數組(array)：是一種用於存儲多個相同數據類型的存儲模型(可以理解為容器) 數組定義和靜態初始化 數組的兩種定義格式： 格式1： 數據類型[] 變數名; 範例： int[] arr; // 定義了一個int類型的數組，數組名是arr 格式2： 數據類型 變數名[]; 範例： int arr[]; ...
  • 人均瑞數系列，瑞數 5 代 JS 逆向分析
    聲明 本文章中所有內容僅供學習交流使用，不用於其他任何目的，不提供完整代碼，抓包內容、敏感網址、數據介面等均已做脫敏處理，嚴禁用於商業用途和非法用途，否則由此產生的一切後果均與作者無關！ 本文章未經許可禁止轉載，禁止任何修改後二次傳播，擅自使用本文講解的技術而導致的任何意外，作者均不負責，若有侵權， ...
  • 【Java面試】面試如何讓面試官面的很爽，看完這道面試題，finally塊一定會執行嗎？
    “finally塊一定會執行嗎？” 這是最近一個工作3年的小伙伴去面試的時候遇到的問題。 你遇到這個問題會怎麼回答呢？ 大家好，我是Mic，一個工作了14年的Java程式員 對於這個問題，面試官想考察什麼呢？ 問題解析 這個問題，很明顯是考察Java基礎。 finally語句塊在實際開發中使用得非常 ...
  • Docker 搭建 Nexus3 私服 | 基本操作
    1 Docker 安裝 Nexus3 1.1 創建目錄 在硬碟上創建 Nexus3 的主目錄： mkdir -p /Users/yygnb/dockerMe/nexus3 為該目錄添加許可權： chmod 777 -R /Users/yygnb/dockerMe/nexus3 1.2 拉取鏡像 搜索鏡 ...
  • Python學習：數據類型轉換的方法教程
    1.type() 函數 使用 type() 函數可以查看數據類型。 示例： >>> type(123) <class 'int'> >>> type(12.3) <class 'float'> >>> type("abc") <class 'str'> >>> type([1,2,3]) <clas ...
  • 性能優化必備——火焰圖
    本文主要介紹火焰圖及使用技巧，學習如何使用火焰圖快速定位軟體的性能卡點。 結合最佳實踐實戰案例，幫助讀者更加深刻地理解火焰圖構造及原理，理解 CPU 耗時，定位性能瓶頸。 ...
  • 微服務Docker打包
    微服務Docker打包 現在的微服務時代，你的代碼沒個微服務、分散式人家都會覺得低端，當然！對於我們開發人員來說，掌握這些技術意味著漲薪。 ​ 我們項目中用到了多個微服務，我們上一節課程打包用的是手動上傳，但是很麻煩，有沒有更好的方式呢，是有的，我們可以直接通過idea將我們的微服務打包成Docke ...
一周排行
    -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.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類