生產者-消費者問題

来源:https://www.cnblogs.com/songhe364826110/archive/2019/09/15/11522117.html
-Advertisement-
Play Games

[TOC] 1. 概述 定義 生產者消費者問題是線程同步的經典問題，也稱為有界緩衝區問題，問題描述大致如下： 生產者和消費者之間共用一個有界數據緩衝區 一個或多個生產者（線程或進程）向緩衝區放置數據 一個或多個消費者（線程或進程）從緩衝區取出數據 緩衝區 生產者消費者問題中的緩衝區，包括隊列緩衝區和 ...


目錄

1. 概述

定義

生產者消費者問題是線程同步的經典問題，也稱為有界緩衝區問題，問題描述大致如下：

  • 生產者和消費者之間共用一個有界數據緩衝區
  • 一個或多個生產者（線程或進程）向緩衝區放置數據
  • 一個或多個消費者（線程或進程）從緩衝區取出數據

緩衝區

生產者消費者問題中的緩衝區，包括隊列緩衝區和環形緩衝區，它們都按照先進先出的順序處理數據，我們現在只考慮隊列緩衝區：

  • 隊列緩衝區通常使用普通的隊列數據結構
  • 隊列內部實現可以是鏈表或數組

緩衝區有兩個極端狀態：緩衝區空，緩衝區滿。鏈表隊列和數組隊列緩衝區空的含義相同，都是隊列中沒有一個元素的情形，但兩者緩衝區滿的含義不同：

  • 數組隊列在初始化時就必須指定最大容量，緩衝區滿的條件很清晰
  • 鏈表隊列沒有最大容量的概念，需要人為指定

此外，Posix消息隊列也可以作為隊列緩衝區，Posix當以無優先順序消息的方式使用時，也是按照先進先出的順序進行處理的。
本文只討論第一種數據結構隊列緩衝區，基於Posix消息隊列緩衝區的生產者消費者問題，會在後續Posix消息隊列中單獨講解。

2. 典型模型

生產者消費者個數的多少、緩衝區的類型都會影響生產者消費者問題模型的複雜度，本文選取兩種常見典型模型進行分析。

模型一

  • 單個生產者 + 單個消費者
  • 生產者線程啟動後，立即創建消費者線程
  • 緩衝區容量有限，且小於數據條目數量

該模型只需要處理生產者和消費者之間的同步問題，在實際工程很常見，具體的同步詳情為：

  • 當緩衝區為空時，消費者不能從其中取出數據
  • 當緩衝區為滿時，生產者不能向其中寫入數據

模型二

  • 多個生產者 + 單個消費者
  • 生產者線程啟動後，立即創建消費者線程
  • 緩衝區容量有限，且小於數據條目數量

模型二與模型一相比，既需要處理生產者之間的同步問題，又需要處理生產者和消費者之間的同步問題，在實際工程也比較常見，具體的同步詳情為：

  • 同時只能有一個生產者向緩衝區寫入數據
  • 當緩衝區為空時，消費者不能從其中取出數據
  • 當緩衝區為滿時，生產者不能向其中寫入數據

可選需求

模型一和模型二所列均為必須處理的同步問題，還有一個根據實際情況、可能會存在的同步需求：

  • 共用數據中包含描述緩衝區當前狀態的變數，如下標、計數、鏈表等
  • 生產者和消費者在讀寫緩衝區後都需要更新緩衝區狀態變數
  • 若滿足上述兩個條件，則同時只能有一個生產者或消費者可以進行緩衝區操作與狀態變數更新

隊列緩衝區，不管是數組實現還是鏈表實現，其內部都符合上述條件，都需要處理該可選同步需求。

3. 數據結構隊列C語言實現

網上找了份數據結構隊列C語言實現的代碼，稍微改了下，可正常使用，本節後續的生產者消費者問題示例代碼就是用它作為緩衝區。

#ifndef _LINK_QUEUE_H_
#define _LINK_QUEUE_H_

typedef enum
{
    false = 0,
    true
} bool;

typedef int data_t;

typedef struct LinkNode
{
    data_t data;
    struct LinkNode *next;
} LinkNode, *LinkQueue;

typedef struct
{
    LinkQueue front;
    LinkQueue rear;
} HeadQueue;

HeadQueue *CreateEmptyQueue();
bool EmptyLinkQueue(HeadQueue *queue);
void EnQueue(HeadQueue *queue, data_t value);
void DeQueue(HeadQueue *queue, data_t *value);
void PrintQueue(HeadQueue *queue);
bool ClearLinkQueue(HeadQueue *queue);
bool DestroyLinkQueue(HeadQueue *queue);
int  GetCurItemsNum(HeadQueue *queue);

#endif
#include "linkqueue.h"
#include <stdio.h>
#include <stdlib.h>

static int nitems;

//創建空鏈表隊列
HeadQueue *CreateEmptyQueue(void)
{
    HeadQueue *queue = (HeadQueue *)malloc(sizeof(HeadQueue));

    if (queue == NULL)
    {
        perror("Create empty queue failed");
        exit(EXIT_FAILURE);
    }

    queue->rear = queue->front = NULL;
    nitems = 0;

    return queue;
}

//判斷是否為空鏈表隊列
bool EmptyLinkQueue(HeadQueue *queue)
{
    if (queue == NULL)
    {
        printf("Empty link queue error!\n");
        exit(EXIT_FAILURE);
    }

    return queue->front == NULL ? true : false;
}

//增加隊列元素
void EnQueue(HeadQueue *queue, data_t value)
{
    LinkQueue new;

    if (queue == NULL)
    {
        printf("EnQueue Error!\n");
        return;
    }

    new = (LinkQueue)malloc(sizeof(LinkNode));

    if (new == NULL)
    {
        perror("Insert value failed");
        return;
    }

    new->data = value;
    new->next = NULL;

    if (EmptyLinkQueue(queue))
    {
        queue->front = queue->rear = new;
    }
    else
    {
        queue->rear->next = new;
        queue->rear = new;
    }

    nitems++;
}

//刪除隊列元素
void DeQueue(HeadQueue *queue, data_t *value)
{
    *value = 0;
    LinkQueue remove;

    if (queue == NULL)
    {
        printf("DeQueue error!\n");
        return;
    }

    if (EmptyLinkQueue(queue))
    {
        printf("queue is empty!\n");
        return;
    }

    remove = queue->front;
    queue->front = remove->next;

    if (queue->front == NULL)
        queue->rear = NULL;

    *value = remove->data;
    free(remove);

    nitems--;
}

//遍歷隊列元素
void PrintQueue(HeadQueue *queue)
{
    LinkQueue node;

    printf("queue = {");
    node = queue->front;

    if (node == NULL)
    {
        printf("}\n");
        return ;
    }

    while (node != NULL)
    {
        printf("%d,", node->data);
        node = node->next;
    }

    printf("\b}\n");
}

//清空隊列元素
bool ClearLinkQueue(HeadQueue *queue)
{
    LinkQueue remove = queue->front;

    while (remove != NULL)
    {
        queue->front = queue->front->next;
        free(remove);
        remove = queue->front;
    }

    queue->front = NULL;
    queue->rear = NULL;
    nitems = 0;

    return true;
}

//銷毀隊列
bool DestroyLinkQueue(HeadQueue *queue)
{
    if (queue != NULL)
    {
        ClearLinkQueue(queue);
        free(queue);
        nitems = 0;
        return true;
    }
    else
    {
        printf("DestroyLinkQueue error!\n");
        return false;
    }
}

//獲得當前隊列元素個數
int GetCurItemsNum(HeadQueue *queue)
{
    return nitems;
}

4. 代碼實現——互斥鎖 + 條件變數

#include "linkqueue.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <pthread.h>

#define MAX_THREADS   10
#define MAX_ITEMS     1000000
#define MAX_BUFFER    10

/*
 * 編程技巧：儘量把共用數據和它們的同步變數（互斥鎖、條件變數、信號量）收集到同一個結構體中
*/
struct Shared
{
    pthread_cond_t  cond_nempty;  //條件變數：緩衝區不滿
    pthread_cond_t  cond_nstored; //條件變數：緩衝區不空
    pthread_mutex_t cond_mutex;   //保護條件的鎖，用於確保同時只有一個線程可以訪問緩衝區
    pthread_mutex_t mutex;        //同步多個生產者的鎖，僅在有多個生產者時使用
    HeadQueue *queue;             //隊列緩衝區
    int nput;
    int nval;
};

struct Shared shared;

void shared_init()
{
    shared.queue = CreateEmptyQueue();
    pthread_mutex_init(&shared.mutex, NULL);
    pthread_mutex_init(&shared.cond_mutex, NULL);
    pthread_cond_init(&shared.cond_nempty, NULL);
    pthread_cond_init(&shared.cond_nstored, NULL);
}

void shared_destroy()
{
    DestroyLinkQueue(shared.queue);
    pthread_mutex_destroy(&shared.mutex);
    pthread_mutex_destroy(&shared.cond_mutex);
    pthread_cond_destroy(&shared.cond_nempty);
    pthread_cond_destroy(&shared.cond_nstored);
}

void *produce(void *arg)
{
    int nthreads = *((int *)arg);

    while (1)
    {
        if (shared.nput >= MAX_ITEMS)
        {
            pthread_exit(NULL);
        }

        if (nthreads > 1)
        {
            pthread_mutex_lock(&shared.mutex);
        }

        pthread_mutex_lock(&shared.cond_mutex);

        while (GetCurItemsNum(shared.queue) == MAX_BUFFER)
            pthread_cond_wait(&shared.cond_nempty, &shared.cond_mutex);

        EnQueue(shared.queue, shared.nval);

        shared.nput++;
        shared.nval++;

        pthread_cond_signal(&shared.cond_nstored);

        if (nthreads > 1)
        {
            pthread_mutex_unlock(&shared.mutex);
        }

        pthread_mutex_unlock(&shared.cond_mutex);
    }

    pthread_exit(NULL);
}

void *consume(void *arg)
{
    int nval;
    int i;

    for (i = 0; i < MAX_ITEMS; i++)
    {
        pthread_mutex_lock(&shared.cond_mutex);

        while (GetCurItemsNum(shared.queue) == 0)
            pthread_cond_wait(&shared.cond_nstored, &shared.cond_mutex);

        DeQueue(shared.queue, &nval);

        pthread_cond_signal(&shared.cond_nempty);
        pthread_mutex_unlock(&shared.cond_mutex);

        if (nval != i)
        {
            printf("error: buff[%d] = %d\n", i, nval);
        }
    }

    pthread_exit(NULL);
}

int main(int argc, char **argv)
{
    pthread_t tid_produce[MAX_THREADS];
    pthread_t tid_consume;
    int nthreads;
    struct timeval start_time;
    struct timeval end_time;
    float time_sec;
    int i;

    nthreads = (atoi(argv[1]) > MAX_THREADS) ? MAX_THREADS : atoi(argv[1]);
    shared_init();
    gettimeofday(&start_time, NULL);

    for (i = 0; i < nthreads; i++)
    {
        pthread_create(&tid_produce[i], NULL, produce, &nthreads);
    }

    pthread_create(&tid_consume, NULL, consume, NULL);

    for (i = 0; i < nthreads; i++)
    {
        pthread_join(tid_produce[i], NULL);
    }

    pthread_join(tid_consume, NULL);

    gettimeofday(&end_time, NULL);
    time_sec = (end_time.tv_sec - start_time.tv_sec) + (end_time.tv_usec - start_time.tv_usec) / 1000000.0;
    printf("%d produce and %d consume total spend %.2f second\n", nthreads, 1, time_sec);

    shared_destroy();

    return 0;
}

運行時通過命令行參數指定生產者個數，來選擇模型一或模型二，其中，在produce()中，第57-56行、第74-77行會根據生產者個數，選擇是否使用第二把鎖。
下麵分別是模型一和模型二的運行結果。

5. 代碼實現——互斥鎖 + Posix有名信號量

#include "linkqueue.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/time.h>
#include <pthread.h>
#include <semaphore.h>

#define SEM_NEMPTY    "/sem_nempty"
#define SEM_NSTROED   "/sem_nstored"

#define MAX_THREADS   10
#define MAX_ITEMS     1000000
#define MAX_BUFFER    10

/*
 * 編程技巧：把共用數據和它們的同步變數（互斥鎖、條件變數、信號量）收集到同一個結構體中
*/
struct Shared
{
    pthread_mutex_t mutex;
    sem_t *nempty;
    sem_t *nstored;
    HeadQueue *queue;
    int nput;
    int nval;
};

struct Shared shared;

void shared_init()
{
    shared.queue = CreateEmptyQueue();
    pthread_mutex_init(&shared.mutex, NULL);
    shared.nempty = sem_open(SEM_NEMPTY,  O_CREAT, 0666, MAX_BUFFER);
    shared.nstored = sem_open(SEM_NSTROED, O_CREAT, 0666, 0);
}

void shared_destroy()
{
    DestroyLinkQueue(shared.queue);
    pthread_mutex_destroy(&shared.mutex);
    sem_close(shared.nempty);
    sem_close(shared.nstored);
    sem_unlink(SEM_NEMPTY);
    sem_unlink(SEM_NSTROED);
}

void *produce(void *arg)
{
    while (1)
    {
        if (shared.nput >= MAX_ITEMS)
        {
            pthread_exit(NULL);
        }

        /*
         * produce和consume都必須先sem_wait，確保sem_wait返回後再上鎖；
         * 防止先上鎖後sem_wait阻塞，導致另一方二次上鎖而死鎖.
        */
        sem_wait(shared.nempty);
        pthread_mutex_lock(&shared.mutex);

        EnQueue(shared.queue, shared.nval);

        /* 如果隊列緩衝區中的元素個數超過了MAX_BUFFER，就輸出提示信息 */
        if (GetCurItemsNum(shared.queue) > MAX_BUFFER)
        {
            printf("notice: queue buffer capacity > %d\n", MAX_BUFFER);
        }

        shared.nput++;
        shared.nval++;

        pthread_mutex_unlock(&shared.mutex);
        sem_post(shared.nstored);
    }

    pthread_exit(NULL);
}

void *consume(void *arg)
{
    int nval;
    int i;

    for (i = 0; i < MAX_ITEMS; i++)
    {
        /*
         * produce和consume都必須先sem_wait，確保sem_wait返回後再上鎖；
         * 防止先上鎖後sem_wait阻塞，導致另一方二次上鎖而死鎖.
        */
        sem_wait(shared.nstored);
        pthread_mutex_lock(&shared.mutex);

        DeQueue(shared.queue, &nval);

        if (nval != i)
        {
            printf("error: buff[%d] = %d\n", i, nval);
        }

        pthread_mutex_unlock(&shared.mutex);
        sem_post(shared.nempty);
    }

    pthread_exit(NULL);
}

int main(int argc, char **argv)
{
    pthread_t tid_produce[MAX_THREADS];
    pthread_t tid_consume;
    int nthreads;
    struct timeval start_time;
    struct timeval end_time;
    float time_sec;
    int i;

    nthreads = (atoi(argv[1]) > MAX_THREADS) ? MAX_THREADS : atoi(argv[1]);
    shared_init();
    gettimeofday(&start_time, NULL);

    for (i = 0; i < nthreads; i++)
    {
        pthread_create(&tid_produce[i], NULL, produce, &nthreads);
    }

    pthread_create(&tid_consume, NULL, consume, NULL);

    for (i = 0; i < nthreads; i++)
    {
        pthread_join(tid_produce[i], NULL);
    }

    pthread_join(tid_consume, NULL);

    gettimeofday(&end_time, NULL);
    time_sec = (end_time.tv_sec - start_time.tv_sec) + (end_time.tv_usec - start_time.tv_usec) / 1000000.0;
    printf("%d produce and %d consume total spend %.2f second\n", nthreads, 1, time_sec);

    shared_destroy();

    return 0;
}

運行時通過命令行參數指定生產者個數，來選擇模型一或模型二。

6. 代碼實現——互斥鎖 + Posix無名信號量

#include "linkqueue.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/time.h>
#include <pthread.h>
#include <semaphore.h>

#define MAX_THREADS   10
#define MAX_ITEMS     1000000
#define MAX_BUFFER    10

/*
 * 編程技巧：把共用數據和它們的同步變數（互斥鎖、條件變數、信號量）收集到同一個結構體中
*/
struct Shared
{
    pthread_mutex_t mutex;
    sem_t nempty;
    sem_t nstored;
    HeadQueue *queue;
    int nput;
    int nval;
};

struct Shared shared;

void shared_init()
{
    shared.queue = CreateEmptyQueue();
    pthread_mutex_init(&shared.mutex, NULL);
    sem_init(&shared.nempty, 0, MAX_BUFFER);
    sem_init(&shared.nstored, 0, 0);
}

void shared_destroy()
{
    DestroyLinkQueue(shared.queue);
    pthread_mutex_destroy(&shared.mutex);
    sem_destroy(&shared.nempty);
    sem_destroy(&shared.nstored);
}

void *produce(void *arg)
{
    while (1)
    {
        if (shared.nput >= MAX_ITEMS)
        {
            pthread_exit(NULL);
        }

        /*
         * produce和consume都必須先sem_wait，確保sem_wait返回後再上鎖；
         * 防止先上鎖後sem_wait阻塞，導致另一方二次上鎖而死鎖.
        */
        sem_wait(&shared.nempty);
        pthread_mutex_lock(&shared.mutex);

        EnQueue(shared.queue, shared.nval);

        /* 如果隊列緩衝區中的元素個數超過了MAX_BUFFER，就輸出提示信息 */
        if (GetCurItemsNum(shared.queue) > MAX_BUFFER)
        {
            printf("notice: queue buffer capacity > %d\n", MAX_BUFFER);
        }

        shared.nput++;
        shared.nval++;

        pthread_mutex_unlock(&shared.mutex);
        sem_post(&shared.nstored);
    }

    pthread_exit(NULL);
}

void *consume(void *arg)
{
    int nval;
    int i;

    for (i = 0; i < MAX_ITEMS; i++)
    {
        /*
         * produce和consume都必須先sem_wait，確保sem_wait返回後再上鎖；
         * 防止先上鎖後sem_wait阻塞，導致另一方二次上鎖而死鎖.
        */
        sem_wait(&shared.nstored);
        pthread_mutex_lock(&shared.mutex);

        DeQueue(shared.queue, &nval);

        if (nval != i)
        {
            printf("error: buff[%d] = %d\n", i, nval);
        }

        pthread_mutex_unlock(&shared.mutex);
        sem_post(&shared.nempty);
    }

    pthread_exit(NULL);
}

int main(int argc, char **argv)
{
    pthread_t tid_produce[MAX_THREADS];
    pthread_t tid_consume;
    int nthreads;
    struct timeval start_time;
    struct timeval end_time;
    float time_sec;
    int i;

    nthreads = (atoi(argv[1]) > MAX_THREADS) ? MAX_THREADS : atoi(argv[1]);
    shared_init();
    gettimeofday(&start_time, NULL);

    for (i = 0; i < nthreads; i++)
    {
        pthread_create(&tid_produce[i], NULL, produce, &nthreads);
    }

    pthread_create(&tid_consume, NULL, consume, NULL);

    for (i = 0; i < nthreads; i++)
    {
        pthread_join(tid_produce[i], NULL);
    }

    pthread_join(tid_consume, NULL);

    gettimeofday(&end_time, NULL);
    time_sec = (end_time.tv_sec - start_time.tv_sec) + (end_time.tv_usec - start_time.tv_usec) / 1000000.0;
    printf("%d produce and %d consume total spend %.2f second\n", nthreads, 1, time_sec);

    shared_destroy();

    return 0;
}

運行時通過命令行參數指定生產者個數，來選擇模型一或模型二。

7. 效率對比

結論

  • 只有Posix無名信號量使用多生產者獲得了效率正提升，其餘都是負提升
  • 單生產者效率，Posix有名信號量 > Posix無名信號量 > 條件變數
  • 多生產者效率，Posix無名信號量 > Posix有名信號量 > 條件變數

該結論僅限於本文使用的示例代碼，僅作結果陳述，不代表具有普適性，也沒有進行深層原因分析。

奇怪的問題

在使用條件變數的示例代碼中，當有多個生產者時用了兩把鎖：

  • mutex同步多個生產者，確保多個生產者不會同時訪問緩衝區
  • cond_mutex確保生產者消費者不會同時訪問緩衝區

實際上，只需要一個cond_mutex就夠了，但經過測試發現這樣運行時間會明顯增加，如下圖所示：

先從理論上分析下，10個生產者1個消費者：

  • 只能同時有一個生產者訪問緩衝區
  • 只能同時有一個生產者或消費者訪問緩衝區

總結起來就是：只能同時有一個線程訪問緩衝區。從這個結論來看，確實不需要第二把鎖，在一把鎖就夠用的情況下，再加第二把鎖反而多了不必要的開銷。
經過測試，Posix有名和無名信號量都符合這個理論，運行時間明顯增加了，有名信號量從1.9s增加到2.3s，無名信號量從1.4s增加到2.5s。
但邪門就邪門在，條件變數卻相反，一把鎖效率低，兩把鎖反而效率有大幅提升，想不通為什麼！


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

-Advertisement-
Play Games
更多相關文章
  • ORM之Dapper運用
    一、前言 上一篇【分層架構設計】我們已經有了架構的輪廓，現在我們就在這個輪廓裡面造輪子。項目要想開始，肯定先得確定ORM框架，目前市面上的ORM框架有很多，對於.net人員來說很容易就想到以ADO.NET為基礎所發展出來的ORM框架EntityFramework。不得不說EntityFramewor ...
  • Linux下二進位編譯安裝MySql，centeros7
    // 當時我裝這個也是折騰了一下午 , 所以寫一個筆記記錄一下; //如果哪裡有問題的話我們可以一起討論( qq: 2970911340,郵箱[email protected]),這也是我第一次寫博客 練練手 1. 安cmake工具 # yum install －y cmake 2. 創建mysql用戶 #usera ...
  • 2019-2020-1 20199319《Linux內核原理與分析》第一周作業
    一、Linux系統簡介 通過實驗一瞭解了Linux 的歷史，Linux與windows之間的區別以及學習Linux的方法。因為一直用的都是windows系統，習慣了圖形界面，而Linux是通過輸入命令執行操作，所以初學還很不適應。正如那句話說的windows能做的Linux都能做，windows不能 ...
  • 記錄舊手機(米6)安裝Linux(Ubuntu16.04)踩過的坑
    舊的小米6在抽屜吃灰半年，一直沒想好要怎麼處理，於是就想著安裝Linux。 完整教程來自https://blog.csdn.net/Greepex/article/details/85333027 原文里把每一個步驟都描述得很清楚（所以本文就不貼詳細步驟圖了，豎版截圖太影響觀感），但難免會踩一些坑。 ...
  • LINUX基礎操作
    常用的linux命令 ls 查看當前（或者指定）目錄下的文件列表 ls -l 查看詳細信息列表 ls -a 或ls -al 查看目錄下所有文件（包含隱藏文件）的詳細信息 cd ./ 切換到當前目錄 cd ../ 切換到上一級目錄 clear 清屏 （或者ctrl+l） / 根目錄 ~ 家目錄 cd ...
  • windows控制台，cmd，命令提示符下的基礎操作
    打開dos命令視窗1、win+r-->運行-->cmd 2、摁住shift+滑鼠右擊 選擇 在此處打開命令視窗3、在磁碟某文件夾下，選擇標題欄中輸入框，輸入cmd 回車 windows下常用的命令 系統管理和文件管理systeminfo 獲取系統信息 系統 補丁 網卡path 查看環境變數set 查 ...
  • VM虛擬機下centos安裝。
    centOS 7安裝步驟： 1.選擇新建虛擬機，稍後安裝，linux選centos7 64位 2.位置改到存放虛擬機的文件夾 3.把硬碟空間改到40g，記憶體分到4g，1處理器2個核心 4 更改cd/dvd到鏡像位置。 5 選擇中文安裝 6選擇需要的安裝軟體，gui和gnome桌面 7 設置root密 ...
  • 【原創】（四）Linux記憶體模型之Sparse Memory Model
    背景 By 魯迅 By 高爾基 說明： 1. Kernel版本：4.14 2. ARM64處理器，Contex A53，雙核 3. 使用工具：Source Insight 3.5， Visio 1. 介紹 順著之前的分析，我們來到了 函數了，本以為一篇文章能搞定，大概掃了一遍代碼之後，我默默的把它拆 ...
一周排行
    -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.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類