go-goroutine 和 channel

来源:https://www.cnblogs.com/ygjzs/archive/2019/11/20/11901365.html
-Advertisement-
Play Games

goroutine 和 channel goroutine 看一個需求 需求：要求統計 1 9000000000 的數字中，哪些是素數？ 分析思路： 1) 傳統的方法，就是使用一個迴圈，迴圈的判斷各個數是不是素數。[很慢] 2) 使用併發或者並行的方式，將統計素數的任務分配給多個 goroutine ...


goroutine 和 channel

goroutine-看一個需求
需求：要求統計 1-9000000000 的數字中，哪些是素數？

分析思路：
1) 傳統的方法，就是使用一個迴圈，迴圈的判斷各個數是不是素數。[很慢]
2) 使用併發或者並行的方式，將統計素數的任務分配給多個 goroutine 去完成，這時就會使用到goroutine.【速度提高 4 倍】

goroutine-基本介紹

進程和線程介紹

程式、進程和線程的關係

併發和並行

併發和並行
1) 多線程程式在單核上運行，就是併發
2) 多線程程式在多核上運行，就是並行

Go 協程和 Go 主線程

Go 主線程(有程式員直接稱為線程/也可以理解成進程): 一個 Go 線程上，可以起多個協程，你可以這樣理解，協程是輕量級的線程[編譯器做優化]。

Go 協程的特點
1) 有獨立的棧空間
2) 共用程式堆空間
3) 調度由用戶控制
4) 協程是輕量級的線程

goroutine-快速入門

案例說明
請編寫一個程式，完成如下功能:
1) 在主線程(可以理解成進程)中，開啟一個 goroutine, 該協程每隔 1 秒輸出 "hello,world"
2) 在主線程中也每隔一秒輸出"hello,golang", 輸出 10 次後，退出程式
3) 要求主線程和 goroutine 同時執行.

package main
import (
    "fmt"
    "strconv"
    "time"
)

// 在主線程(可以理解成進程)中，開啟一個goroutine, 該協程每隔1秒輸出 "hello,world"
// 在主線程中也每隔一秒輸出"hello,golang", 輸出10次後，退出程式
// 要求主線程和goroutine同時執行

//編寫一個函數，每隔1秒輸出 "hello,world"
func test() {
    for i := 1; i <= 10; i++ {
        fmt.Println("tesst () hello,world " + strconv.Itoa(i))
        time.Sleep(time.Second)
    }
}

func main() {

    go test() // 開啟了一個協程

    for i := 1; i <= 10; i++ {
        fmt.Println(" main() hello,golang" + strconv.Itoa(i))
        time.Sleep(time.Second)
    }
}

快速入門小結

1) 主線程是一個物理線程，直接作用在 cpu 上的。是重量級的，非常耗費 cpu 資源。
2) 協程從主線程開啟的，是輕量級的線程，是邏輯態。對資源消耗相對小。
3) Golang 的協程機制是重要的特點，可以輕鬆的 開啟上萬個協程。其它編程語言的併發機制是一般基於線程的，開啟過多的線程，資源耗費大，這裡就突顯 Golang 在併發上的優勢了

goroutine 的調度模型

MPG 模式基本介紹

解釋一下MPG含義：
M（Machine）：操作系統的主線程
P（Processor）：協程執行需要的資源（上下文context），可以看作一個局部的調度器，使go代碼在一個線程上跑，他是實現從N：1到N：M映射的關鍵
G（Gorountine）：協程，有自己的棧。包含指令指針（instruction pointer）和其它信息（正在等待的channel等等），用於調度。一個P下麵可以有多個G

MPG 模式運行的狀態一

  • P的數量可以通過GOMAXPROCS()來設置，他其實代表了真正的併發度，即有多少個goroutine可以同時運行。P同時也維護著G（協程）的隊列（稱之為runqueue進程隊列）。Go代碼中的M每有一個語句被執行，P就在末尾加入一個G（從runqueue隊列中取出來的），在下一個調度點（P），就從runqueue隊列中取出G。

  • P可以在OS線程（主線程，或者是M）被阻塞時，轉到另一個OS線程（M）！Go中的調度器保證有足夠的線程來運行所有的P。當啟用一個M0中的G0被sysCall（系統調用）的時候，M0下麵的P轉給另一個線程M1（可以是創建的，也可以是原本就存在的）。M1接受了P（包括P所帶的runqueue的隊列裡面所有狀態的G，但不包括已經被syscall的G0），繼續運行。而M0會等待執行syscall的G0的返回值。當G0的syscall結束後，他的主線程M0會嘗試取得一個P來運行G0，一般情況下，他會從其他的M裡面偷一個P過來，如果沒有偷到的話就會把G0放到一個Global runqueue（全局進程隊列）中，然後把自己（M0）放進線程池或者轉為休眠狀態。

設置 Golang 運行的 cpu 數

介紹：為了充分了利用多 cpu 的優勢，在 Golang 程式中，設置運行的 cpu 數目

package main
import (
    "runtime"
    "fmt"
)

func main() {
    cpuNum := runtime.NumCPU()
    fmt.Println("cpuNum=", cpuNum)

    //可以自己設置使用多個cpu
    runtime.GOMAXPROCS(cpuNum - 1)
    fmt.Println("ok")
}

channel(管道)-看個需求

需求：現在要計算 1-200 的各個數的階乘，並且把各個數的階乘放入到 map 中。最後顯示出來。
要求使用 goroutine 完成

分析思路：
1) 使用 goroutine 來完成，效率高，但是會出現併發/並行安全問題.
2) 這裡就提出了不同 goroutine 如何通信的問題

代碼實現
1) 使用 goroutine 來完成(看看使用 gorotine 併發完成會出現什麼問題? 然後去解決)
2) 在運行某個程式時，如何知道是否存在資源競爭問題。 方法很簡單，在編譯該程式時，增加一個參數 -race 即可

不同 goroutine 之間如何通訊

1) 全局變數的互斥鎖
2) 使用管道 channel 來解決

使用全局變數加鎖同步改進程式

因為沒有對全局變數 m 加鎖，因此會出現資源爭奪問題，代碼會出現錯誤，提示 concurrent map
writes
解決方案：加入互斥鎖
我們的數的階乘很大，結果會越界,可以將求階乘改成 sum += uint64(i)

package main
import (
    "fmt"
    _ "time"
    "sync"
)

// 需求：現在要計算 1-200 的各個數的階乘，並且把各個數的階乘放入到map中。
// 最後顯示出來。要求使用goroutine完成 

// 思路
// 1. 編寫一個函數，來計算各個數的階乘，並放入到 map中.
// 2. 我們啟動的協程多個，統計的將結果放入到 map中
// 3. map 應該做出一個全局的.

var (
    myMap = make(map[int]int, 10)  
    //聲明一個全局的互斥鎖
    //lock 是一個全局的互斥鎖， 
    //sync 是包: synchornized 同步
    //Mutex : 是互斥
    lock sync.Mutex
)

// test 函數就是計算 n!, 讓將這個結果放入到 myMap
func test(n int) {
    
    res := 1
    for i := 1; i <= n; i++ {
        res *= i
    }

    //這裡我們將 res 放入到myMap
    //加鎖
    lock.Lock()
    myMap[n] = res //concurrent map writes?
    //解鎖
    lock.Unlock()
}

func main() {

    // 我們這裡開啟多個協程完成這個任務[200個]
    for i := 1; i <= 20; i++ {
        go test(i)
    }


    //休眠10秒鐘【第二個問題 】
    //time.Sleep(time.Second * 5)

    //這裡我們輸出結果,變數這個結果
    lock.Lock()
    for i, v := range myMap {
        fmt.Printf("map[%d]=%d\n", i, v)
    }
    lock.Unlock()

}

為什麼需要 channel

1) 前面使用全局變數加鎖同步來解決 goroutine 的通訊，但不完美
2) 主線程在等待所有 goroutine 全部完成的時間很難確定，我們這裡設置 10 秒，僅僅是估算。
3) 如果主線程休眠時間長了，會加長等待時間，如果等待時間短了，可能還有 goroutine 處於工作
狀態，這時也會隨主線程的退出而銷毀
4) 通過全局變數加鎖同步來實現通訊，也並不利用多個協程對全局變數的讀寫操作。
5) 上面種種分析都在呼喚一個新的通訊機制-channel

channel 的基本介紹

1) channle 本質就是一個數據結構-隊列
2) 數據是先進先出【FIFO : first in first out】
3) 線程安全，多 goroutine 訪問時，不需要加鎖，就是說 channel 本身就是線程安全的
4) channel 有類型的，一個 string 的 channel 只能存放 string 類型數據。

定義/聲明 channel

var 變數名 chan 數據類型
舉例：

var intChan chan int (intChan 用於存放 int 數據)
var mapChan chan map[int]string (mapChan 用於存放 map[int]string 類型)
var perChan chan Person
var perChan2 chan *Person
...

說明
channel 是引用類型
channel 必須初始化才能寫入數據, 即 make 後才能使用
管道是有類型的，intChan 只能寫入 整數 int

package main
import (
    "fmt"
)

func main() {

    //演示一下管道的使用
    //1. 創建一個可以存放3個int類型的管道
    var intChan chan int
    intChan = make(chan int, 3)

    //2. 看看intChan是什麼
    fmt.Printf("intChan 的值=%v intChan本身的地址=%p\n", intChan, &intChan)


    //3. 向管道寫入數據
    intChan<- 10
    num := 211
    intChan<- num
    intChan<- 50
    // //如果從channel取出數據後，可以繼續放入
    <-intChan
    intChan<- 98//註意點, 當我們給管寫入數據時，不能超過其容量


    //4. 看看管道的長度和cap(容量)
    fmt.Printf("channel len= %v cap=%v \n", len(intChan), cap(intChan)) // 3, 3

    //5. 從管道中讀取數據

    var num2 int
    num2 = <-intChan 
    fmt.Println("num2=", num2)
    fmt.Printf("channel len= %v cap=%v \n", len(intChan), cap(intChan))  // 2, 3

    //6. 在沒有使用協程的情況下，如果我們的管道數據已經全部取出，再取就會報告 deadlock

    num3 := <-intChan
    num4 := <-intChan

    //num5 := <-intChan

    fmt.Println("num3=", num3, "num4=", num4/*, "num5=", num5*/)

}

管道的初始化，寫入數據到管道，從管道讀取數據及基本的註意事項

channel 使用的註意事項

1) channel 中只能存放指定的數據類型
2) channle 的數據放滿後，就不能再放入了
3) 如果從 channel 取出數據後，可以繼續放入
4) 在沒有使用協程的情況下，如果 channel 數據取完了，再取，就會報 dead lock

讀寫 channel 案例演示

package main
import (
    "fmt"
)

type Cat struct {
    Name string
    Age int
}

func main() {

    //定義一個存放任意數據類型的管道 3個數據
    //var allChan chan interface{}
    allChan := make(chan interface{}, 3)

    allChan<- 10
    allChan<- "tom jack"
    cat := Cat{"小花貓", 4}
    allChan<- cat

    //我們希望獲得到管道中的第三個元素，則先將前2個推出
    <-allChan
    <-allChan

    newCat := <-allChan //從管道中取出的Cat是什麼?

    fmt.Printf("newCat=%T , newCat=%v\n", newCat, newCat)
    //下麵的寫法是錯誤的!編譯不通過
    //fmt.Printf("newCat.Name=%v", newCat.Name)
    //使用類型斷言
    a := newCat.(Cat) 
    fmt.Printf("newCat.Name=%v", a.Name)
    

}

channel 的遍歷和關閉

channel 的關閉

使用內置函數 close 可以關閉 channel, 當 channel 關閉後，就不能再向 channel 寫數據了，但是仍然可以從該 channel 讀取數據

channel 的遍歷

channel 支持 for--range 的方式進行遍歷，請註意兩個細節
1) 在遍歷時，如果 channel 沒有關閉，則回出現 deadlock 的錯誤
2) 在遍歷時，如果 channel 已經關閉，則會正常遍曆數據，遍歷完後，就會退出遍歷。

channel 遍歷和關閉的案例演示

package main
import (
   "fmt"
)

func main() {

   intChan := make(chan int, 3)
   intChan<- 100
   intChan<- 200
   close(intChan) // close
   //這是不能夠再寫入數到channel
   //intChan<- 300
   fmt.Println("okook~")
   //當管道關閉後，讀取數據是可以的
   n1 := <-intChan
   fmt.Println("n1=", n1)


   //遍歷管道
   intChan2 := make(chan int, 100)
   for i := 0; i < 100; i++ {
       intChan2<- i * 2  //放入100個數據到管道
   }

   //遍歷管道不能使用普通的 for 迴圈
   // for i := 0; i < len(intChan2); i++ {

   // }
   //在遍歷時，如果channel沒有關閉，則會出現deadlock的錯誤
   //在遍歷時，如果channel已經關閉，則會正常遍曆數據，遍歷完後，就會退出遍歷
   close(intChan2)
   for v := range intChan2 {
       fmt.Println("v=", v)
   }


}

應用示例--channel與goroutine

package main
import (
    "fmt"
    "time"
)


//write Data
func writeData(intChan chan int) {
    for i := 1; i <= 50; i++ {
        //放入數據
        intChan<- i //
        fmt.Println("writeData ", i)
        //time.Sleep(time.Second)
    }
    close(intChan) //關閉
}

//read data
func readData(intChan chan int, exitChan chan bool) {

    for {
        v, ok := <-intChan
        if !ok {
            break
        }
        time.Sleep(time.Second)
        fmt.Printf("readData 讀到數據=%v\n", v) 
    }
    //readData 讀取完數據後，即任務完成
    exitChan<- true
    close(exitChan)

}

func main() {

    //創建兩個管道
    intChan := make(chan int, 10)
    exitChan := make(chan bool, 1)
    
    go writeData(intChan)
    go readData(intChan, exitChan)

    time.Sleep(time.Second * 10)
    for {
        _, ok := <-exitChan
        if !ok {
            break
        }
    }

}

應用實例 2-阻塞

若上面的代碼，註釋掉go readData(intChan, exitChan)，會怎樣，因為管道有長度，所以當編譯器發現一個管道只有寫而沒有讀，改管道會阻塞（讀與寫的頻率不一致沒關係）！

應用實例 3

需求：
要求統計 1-200000 的數字中，哪些是素數？這個問題在本章開篇就提出了，現在我們有 goroutine和 channel 的知識後，就可以完成了 [測試數據: 80000]

分析思路：

傳統的方法，就是使用一個迴圈，迴圈的判斷各個數是不是素數【ok】。
使用併發/並行的方式，將統計素數的任務分配給多個(4 個)goroutine 去完成，完成任務時間短。

傳統方法，一個協程

package main
import (
    "time"
    "fmt"
)

func main() {

        start := time.Now().Unix()
        for num := 1; num <= 80000; num++ {

            flag := true //假設是素數
            //判斷num是不是素數
            for i := 2; i < num; i++ {
                if num % i == 0 {//說明該num不是素數
                    flag = false
                    break
                }
            }

            if flag {
                //將這個數就放入到primeChan
                //primeChan<- num
            }

        }
        end := time.Now().Unix()
        fmt.Println("普通的方法耗時=", end - start)
        
}

開了四個協程

package main
import (
    "fmt"
    "time"
)



//向 intChan放入 1-8000個數
func putNum(intChan chan int) {

    for i := 1; i <= 80000; i++ {    
        intChan<- i
    }

    //關閉intChan
    close(intChan)
}

// 從 intChan取出數據，並判斷是否為素數,如果是，就
//  //放入到primeChan
func primeNum(intChan chan int, primeChan chan int, exitChan chan bool) {

    //使用for 迴圈
    // var num int
    var flag bool // 
    for {
        //time.Sleep(time.Millisecond * 10)
        num, ok := <-intChan //intChan 取不到..
        
        if !ok { 
            break
        }
        flag = true //假設是素數
        //判斷num是不是素數
        for i := 2; i < num; i++ {
            if num % i == 0 {//說明該num不是素數
                flag = false
                break
            }
        }

        if flag {
            //將這個數就放入到primeChan
            primeChan<- num
        }
    }

    fmt.Println("有一個primeNum 協程因為取不到數據，退出")
    //這裡我們還不能關閉 primeChan
    //向 exitChan 寫入true
    exitChan<- true 

}

func main() {

    intChan := make(chan int , 1000)
    primeChan := make(chan int, 20000)//放入結果
    //標識退出的管道
    exitChan := make(chan bool, 8) // 4個



    start := time.Now().Unix()
    
    //開啟一個協程，向 intChan放入 1-8000個數
    go putNum(intChan)
    //開啟4個協程，從 intChan取出數據，並判斷是否為素數,如果是，就
    //放入到primeChan
    for i := 0; i < 8; i++ {
        go primeNum(intChan, primeChan, exitChan)
    }

    //這裡我們主線程，進行處理
    //直接
    go func(){
        for i := 0; i < 8; i++ {
            <-exitChan
        }

        end := time.Now().Unix()
        fmt.Println("使用協程耗時=", end - start)

        //當我們從exitChan 取出了4個結果，就可以放心的關閉 prprimeChan
        close(primeChan)
    }()


    //遍歷我們的 primeChan ,把結果取出
    for {
        _, ok := <-primeChan
        if !ok{
            break
        }
        //將結果輸出
        //fmt.Printf("素數=%d\n", res)
    }

    fmt.Println("main線程退出")


    
}

結論：使用 go 協程後，執行的速度，理論上比普通方法提高至少 4 倍(我這是兩倍)

channel 使用細節和註意事項

1) channel 可以聲明為只讀，或者只寫性質 【案例演示】

package main
import (
    "fmt"
)

func main() {
    //管道可以聲明為只讀或者只寫

    //1. 在預設情況下下，管道是雙向
    //var chan1 chan int //可讀可寫
    
    //2 聲明為只寫
    var chan2 chan<- int
    chan2 = make(chan int, 3)
    chan2<- 20
    //num := <-chan2 //error

    fmt.Println("chan2=", chan2)

    //3. 聲明為只讀
    var chan3 <-chan int
    num2 := <-chan3
    //chan3<- 30 //err
    fmt.Println("num2", num2)

}

3) 使用 select 可以解決從管道取數據的阻塞問題

package main
import (
    "fmt"
    "time"
)

func main() {

    //使用select可以解決從管道取數據的阻塞問題

    //1.定義一個管道 10個數據int
    intChan := make(chan int, 10)
    for i := 0; i < 10; i++ {
        intChan<- i
    }
    //2.定義一個管道 5個數據string
    stringChan := make(chan string, 5)
    for i := 0; i < 5; i++ {
        stringChan <- "hello" + fmt.Sprintf("%d", i)
    }

    //傳統的方法在遍歷管道時，如果不關閉會阻塞而導致 deadlock

    //問題，在實際開發中，可能我們不好確定什麼關閉該管道.
    //可以使用select 方式可以解決
    //label:
    for {
        select {
            //註意: 這裡，如果intChan一直沒有關閉，不會一直阻塞而deadlock
            //，會自動到下一個case匹配
            case v := <-intChan : 
                fmt.Printf("從intChan讀取的數據%d\n", v)
                time.Sleep(time.Second)
            case v := <-stringChan :
                fmt.Printf("從stringChan讀取的數據%s\n", v)
                time.Sleep(time.Second)
            default :
                fmt.Printf("都取不到了，不玩了, 程式員可以加入邏輯\n")
                time.Sleep(time.Second)
                return 
                //break label
        }
    }
}

4) goroutine 中使用 recover，解決協程中出現 panic，導致程式崩潰問題

如果我們開了一個協程，但這個協程出現panic，就會導致整個程式崩潰，這時我們可以在goroutine中使用recover來捕獲panic，這樣及時協程發生問題，主線程依然不受影響

package main
import (
    "fmt"
    "time"
)

//函數
func sayHello() {
    for i := 0; i < 10; i++ {
        time.Sleep(time.Second)
        fmt.Println("hello,world")
    }
}
//函數
func test() {
    //這裡我們可以使用defer + recover
    defer func() {
        //捕獲test拋出的panic
        if err := recover(); err != nil {
            fmt.Println("test() 發生錯誤", err)
        }
    }()
    //定義了一個map
    var myMap map[int]string
    myMap[0] = "golang" //error
}

func main() {

    go sayHello()
    go test()


    for i := 0; i < 10; i++ {
        fmt.Println("main() ok=", i)
        time.Sleep(time.Second)
    }

}

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

-Advertisement-
Play Games
更多相關文章
  • hashMap怎樣解決hash衝突
    通過鏈表的方式處理: java1.7是單向鏈表 jvav1.8在數量小於8時是單向鏈表,大於8就是紅黑樹,查找方式很粗糙(遍歷判斷) 解決衝突的方式很多,例如再hash,再散列(開放地址法,探測再散列) ...
  • 我的 Java 復興之路
    "概述" "變數與數據類型" "運算符與方法" "面向對象" ...
  • java的hashCode和equals為什麼要同時重寫?
    原因: java規範:相等的對象必須具有相等的散列碼（hashCode） 同時對於HashSet和HashMap這些基於散列值（hash）實現的類。key的判斷是通過hashCode完成,且散列也是通過和數組容量取模完成的 ...
  • Java 複習筆記3 - 運算符 方法
    本位是複習筆記,不適合零基礎 賦值運算符 變數 名稱 = 值/表達式 ; 需要註意的是,賦值運算符的計算是按照從右往左的; 註意: 1.在使用賦值符號時,必須保證左側的類型範圍大於等於右側產生的類型 2.兩個類型不同的數據相加時,得到的結果類型為範圍更大的一方 算術運算符 "+"號不僅可以作為加法運 ...
  • Java 複習筆記2 - 變數常量數據類型
    本文是複習筆記,不適合零基礎 標識符命名規範 可以有字母數字下劃線和美元符組成, hello abc 不能以數字開頭 123abc 嚴格區分大小寫 void Void 不能是java的關鍵字和保留字 class 標識符必須是見名知意的 ps:在Eclipse中紫色的都是關鍵字 關鍵字 具有某個特殊含 ...
  • Java 複習筆記1 - java概述
    本文是複習筆記,不適合零基礎 簡介: JAVA是一門面向對象的編程語言 1995有sun公司發佈 java程式執行流程: 1. xxxjava源文件, 2. 經過編譯器編譯 3. 產生位元組碼文件 4. 位元組碼交給解釋器 5. 解釋成當前平臺的本地機器指令 名詞概念 JVM,:是java虛擬機 jvm ...
  • 併發:線程池
    學習:1.先大綱,然後思路優先(適當的提出問題) 2.合理推測 為了熟悉線程池,提出一些問題 1.線程什麼時候創建? 2.線程池主要做什麼? 3.無任務執行處於什麼狀態? 4.提交一個任務,執行邏輯? 5.線程池怎樣被銷毀? ...
  • [Go] gocron源碼閱讀-判斷是否使用root用戶執行
    判斷是linux系統，並且uid為0,allowRoot是通過命令行傳參傳進來的，通過flag包解析出來的，可以使用go run node.go -h看到這些參數 log.Fatal傳入的是一個可變參數v ...interface{}，並且可以傳入任意類型，可變參數的使用和切片很像 如果要真的傳入一 ...
一周排行
    -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.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類