C++ Qt開發：運用QThread多線程組件

来源:https://www.cnblogs.com/LyShark/p/18056212
-Advertisement-
Play Games

Qt 是一個跨平臺C++圖形界面開發庫，利用Qt可以快速開發跨平臺窗體應用程式，在Qt中我們可以通過拖拽的方式將不同組件放到指定的位置，實現圖形化開發極大的方便了開發效率，本章將重點介紹如何運用`QThread`組件實現多線程功能。 ...


Qt 是一個跨平臺C++圖形界面開發庫，利用Qt可以快速開發跨平臺窗體應用程式，在Qt中我們可以通過拖拽的方式將不同組件放到指定的位置，實現圖形化開發極大的方便了開發效率，本章將重點介紹如何運用QThread組件實現多線程功能。

多線程技術在程式開發中尤為常用，Qt框架中提供了QThread庫來實現多線程功能。當你需要使用QThread時，需包含QThread模塊，以下是QThread類的一些主要成員函數和槽函數。

成員函數/槽函數 描述
QThread(QObject *parent = nullptr) 構造函數，創建一個QThread對象。
~QThread() 析構函數，釋放QThread對象。
void start(QThread::Priority priority = InheritPriority) 啟動線程。
void run() 預設的線程執行函數，需要在繼承QThread的子類中重新實現以定義線程的操作。
void exit(int returnCode = 0) 請求線程退出，線程將在適當的時候退出。
void quit() 請求線程退出，與exit()類似。
void terminate() 立即終止線程的執行。這是一個危險的操作，可能導致資源泄漏和未完成的操作。
void wait() 等待線程完成。主線程將被阻塞，直到該線程退出。
bool isRunning() const 檢查線程是否正在運行。
void setPriority(Priority priority) 設置線程的優先順序。
Priority priority() const 獲取線程的優先順序。
QThread::Priority priority() 獲取線程的優先順序。
void setStackSize(uint stackSize) 設置線程的堆棧大小（以位元組為單位）。
uint stackSize() const 獲取線程的堆棧大小。
void msleep(unsigned long msecs) 使線程休眠指定的毫秒數。
void sleep(unsigned long secs) 使線程休眠指定的秒數。
static QThread *currentThread() 獲取當前正在執行的線程的QThread對象。
void setObjectName(const QString &name) 為線程設置一個對象名。

當我們需要創建線程時，通常第一步則是要繼承QThread類，並重寫類內的run()方法，在run()方法中，你可以編寫需要在新線程中執行的代碼。當你創建一個QThread的實例並調用它的start()方法時，會自動調用run()來執行線程邏輯，如下這樣一段代碼展示瞭如何運用線程類。

#include <QCoreApplication>
#include <QThread>
#include <QDebug>

class MyThread : public QThread
{
public:
    void run() override
    {
        for (int i = 0; i < 5; ++i)
        {
            qDebug() << "Thread is running" << i;
            sleep(1);
        }
    }
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    MyThread thread;
    thread.start();
    thread.wait();

    qDebug() << "Main thread is done.";
    return a.exec();
}

上述代碼運行後則會每隔1秒輸出一段話，在主函數內通過調用thread.start方法啟動這個線程，並通過thread.wait等待線程結束，如下圖所示；

1.1 線程組與多線程

線程組是一種組織和管理多個線程的機制，允許將相關聯的線程集中在一起，便於集中管理、協調和監控。通過線程組，可以對一組線程進行統一的生命周期管理，包括啟動、停止、調度和資源分配等操作。

上述方法並未真正實現多線程功能，我們繼續完善MyThread自定義類，在該類內增加兩個標誌，is_run()用於判斷線程是否正在運行，is_finish()則用來判斷線程是否已經完成，併在run()中增加列印當前線程對象名稱的功能。

class MyThread: public QThread
{
protected:
    volatile bool m_to_stop;

protected:
    void run()
    {
        for(int x=0; !m_to_stop && (x <10); x++)
        {
            msleep(1000);
            std::cout << objectName().toStdString() << std::endl;
        }
    }

public:
    MyThread()
    {
        m_to_stop = false;
    }

    void stop()
    {
        m_to_stop = true;
    }

    void is_run()
    {
        std::cout << "Thread Running = " << isRunning() << std::endl;
    }

    void is_finish()
    {
        std::cout << "Thread Finished = " << isFinished() << std::endl;
    }

};

接著在主函數內調整，增加一個MyThread thread[10]用於存儲線程組，線程組是一種用於組織和管理多個線程的概念。在不同的編程框架和操作系統中，線程組可能具有不同的實現和功能，但通常用於提供一種集中管理和協調一組相關線程的機制。

我們通過迴圈的方式依次對線程組進行賦值，通過調用setObjectName對每一個線程賦予一個不同的名稱，當需要使用這些線程時則可以通過迴圈調用run()方法來實現，而結束調用同樣如此，如下是調用的具體實現；

#include <QCoreApplication>
#include <iostream>
#include <QThread>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 定義線程數組
    MyThread thread[10];

    // 設置線程對象名字
    for(int x=0;x<10;x++)
    {
        thread[x].setObjectName(QString("thread => %1").arg(x));
    }

    // 批量調用run執行
    for(int x=0;x<10;x++)
    {
        thread[x].start();
        thread[x].is_run();
        thread[x].isFinished();
    }

    // 批量調用stop關閉
    for(int x=0;x<10;x++)
    {
        thread[x].wait();
        thread[x].stop();

        thread[x].is_run();
        thread[x].is_finish();
    }

    return a.exec();
}

如下圖則是運行後實現的多線程效果；

1.2 向線程中傳遞參數

向線程中傳遞參數是多線程編程中常見的需求，不同的編程語言和框架提供了多種方式來實現這個目標，在Qt中，由於使用的自定義線程類，所以可通過增加一個set_value()方法來向線程內傳遞參數，由於線程函數內的變數使用了protected屬性，所以也就實現了線程間變數的隔離，當線程被執行結束後則可以通過result()方法獲取到線程執行結果，這個線程函數如下所示；

class MyThread: public QThread
{
protected:
    int m_begin;
    int m_end;
    int m_result;

    void run()
    {
        m_result = m_begin + m_end;
    }

public:
    MyThread()
    {
        m_begin = 0;
        m_end = 0;
        m_result = 0;
    }

    // 設置參數給當前線程
    void set_value(int x,int y)
    {
        m_begin = x;
        m_end = y;
    }

    // 獲取當前線程名
    void get_object_name()
    {
        std::cout << "this thread name => " << objectName().toStdString() << std::endl;
    }

    // 獲取線程返回結果
    int result()
    {
        return m_result;
    }
};

在主函數中，我們通過MyThread thread[3];來定義3個線程組，並通過迴圈三次分別thread[x].set_value()設置三組不同的參數，當設置完成後則可以調用thread[x].start()方法運行這些線程，線程運行結束後則返回值將會被依次保存在thread[x].result()中，此時直接將其相加即可得到最終線程執行結果；

#include <QCoreApplication>
#include <iostream>
#include <QThread>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    MyThread thread[3];

    // 分別將不同的參數傳入到線程函數內
    for(int x=0; x<3; x++)
    {
        thread[x].set_value(1,2);
        thread[x].setObjectName(QString("thread -> %1").arg(x));
        thread[x].start();
    }

    // 等待所有線程執行結束
    for(int x=0; x<3; x++)
    {
        thread[x].get_object_name();
        thread[x].wait();
    }

    // 獲取線程返回值並相加
    int result = thread[0].result() + thread[1].result() + thread[2].result();
    std::cout << "sum => " << result << std::endl;

    return a.exec();
}

程式運行後，則可以輸出三個線程相加的和；

1.3 互斥同步線程鎖

QMutex 是Qt框架中提供的用於線程同步的類，用於實現互斥訪問共用資源。Mutex是“互斥鎖（Mutual Exclusion）”的縮寫，它能夠確保在任意時刻，只有一個線程可以訪問被保護的資源，從而避免了多線程環境下的數據競爭和不一致性。

在Qt中，QMutex提供了簡單而有效的線程同步機制，其基本用法包括：

  • 鎖定（Lock）： 線程在訪問共用資源之前，首先需要獲取QMutex的鎖，這通過調用lock()方法來實現。
  • 解鎖（Unlock）： 當線程使用完共用資源後，需要釋放QMutex的鎖，以允許其他線程訪問，這通過調用unlock()方法來實現。

該鎖lock()鎖定與unlock()解鎖必須配對使用，線程鎖保證線程間的互斥，利用線程鎖能夠保證臨界資源的安全性。

  • 線程鎖解決的問題: 多個線程同時操作同一個全局變數，為了防止資源的無序覆蓋現象，從而需要增加鎖，來實現多線程搶占資源時可以有序執行。
  • 臨界資源(Critical Resource): 每次只允許一個線程進行訪問 (讀/寫)的資源。
  • 線程間的互斥(競爭): 多個線程在同一時刻都需要訪問臨界資源。
  • 一般性原則: 每一個臨界資源都需要一個線程鎖進行保護。

我們以生產者消費者模型為例來演示鎖的使用方法，生產者消費者模型是一種併發編程中常見的同步機制，用於解決多線程環境下的協作問題。該模型基於兩類角色：生產者（Producer）和消費者（Consumer），它們通過共用的緩衝區進行協作。

主要特點和工作原理如下：

  1. 生產者：
    • 生產者負責產生一些資源或數據，並將其放入共用的緩衝區中。生產者在生產資源後，需要通知消費者，以便它們可以取走資源。
  2. 消費者：
    • 消費者從共用的緩衝區中取走資源，併進行相應的處理。如果緩衝區為空，消費者需要等待，直到有新的資源可用。
  3. 共用緩衝區：
    • 作為生產者和消費者之間的交換介質，共用緩衝區存儲被生產者產生的資源。它需要提供對資源的安全訪問，以防止競態條件和數據不一致性。
  4. 同步機制：
    • 生產者和消費者之間需要一些同步機制，以確保在正確的時機進行資源的生產和消費。典型的同步機制包括信號量、互斥鎖、條件變數等。

生產者消費者模型的典型應用場景包括非同步任務處理、事件驅動系統、數據緩存等。這種模型的實現可以通過多線程編程或使用消息隊列等方式來完成。

首先在全局中引入#include <QMutex>庫，併在全局定義static QMutex線程鎖變數，接著我們分別定義兩個自定義線程函數，其中Producer代表生產者，而Customer則是消費者，生產者中負責每次產出一個隨機數並將其追加到g_store全局變數內保存，消費者則通過g_store.remove每次取出一個元素。

static QMutex g_mutex;      // 線程鎖
static QString g_store;     // 定義全局變數

class Producer : public QThread
{
protected:
    void run()
    {
        int count = 0;

        while(true)
        {
            // 加鎖
            g_mutex.lock();

            g_store.append(QString::number((count++) % 10));
            std::cout << "Producer -> "<< g_store.toStdString() << std::endl;

            // 釋放鎖
            g_mutex.unlock();
            msleep(900);
        }
    }
};

class Customer : public QThread
{
protected:
    void run()
    {
        while( true )
        {
            g_mutex.lock();
            if( g_store != "" )
            {
                g_store.remove(0, 1);
                std::cout << "Curstomer -> "<< g_store.toStdString() << std::endl;
            }

            g_mutex.unlock();
            msleep(1000);
        }
    }
};

在主函數中分別定義兩個線程類，並依次運行它們；

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Producer p;
    Customer c;

    p.setObjectName("producer");
    c.setObjectName("curstomer");

    p.start();
    c.start();

    return a.exec();
}

至此，生產者產生數據，消費者消費數據；如下圖所示；

QMutexLocker 是Qt框架中提供的一個輔助類，它是在QMutex基礎上簡化版的線程鎖，QMutexLocker會保護加鎖區域，並自動實現互斥量的鎖定和解鎖操作，可以將其理解為是智能版的QMutex鎖，通過 QMutexLocker可以確保在作用域內始終持有鎖，從而避免因為忘記釋放鎖而導致的問題。該鎖只需要在上方代碼中稍加修改即可。

使用 QMutexLocker 的一般流程如下：

  1. 創建一個 QMutex 對象。
  2. 創建一個 QMutexLocker 對象，傳入需要鎖定的 QMutex。
  3. 在 QMutexLocker 對象的作用域內進行需要互斥訪問的操作。
  4. 當 QMutexLocker 對象超出作用域範圍時，會自動釋放鎖。
static QMutex g_mutex;      // 線程鎖
static QString g_store;     // 定義全局變數

class Producer : public QThread
{
protected:
    void run()
    {
        int count = 0;

        while(true)
        {
			// 增加智能線程鎖
            QMutexLocker Locker(&g_mutex);

            g_store.append(QString::number((count++) % 10));
            std::cout << "Producer -> "<< g_store.toStdString() << std::endl;

            msleep(900);
        }
    }
};

1.4 讀寫同步線程鎖

QReadWriteLock 是Qt框架中提供的用於實現讀寫鎖的類。讀寫鎖允許多個線程同時讀取共用數據，但在寫入數據時會互斥，確保數據的一致性和完整性。這對於大多數情況下讀取頻繁而寫入較少的共用數據非常有用，可以提高程式的性能。

其提供了兩種鎖定操作：

  • 讀取鎖（Read Lock）： 允許多個線程同時獲取讀取鎖，用於並行讀取共用數據。在沒有寫入鎖的情況下，多個線程可以同時持有讀取鎖。
  • 寫入鎖（Write Lock）： 寫入鎖是互斥的，當一個線程獲取寫入鎖時，其他線程無法獲取讀取鎖或寫入鎖。這確保了在寫入數據時，不會有其他線程同時讀取或寫入。

互斥鎖存在一個問題，每次只能有一個線程獲得互斥量的許可權，如果在程式中有多個線程來同時讀取某個變數，那麼使用互斥量必須排隊，效率上會大打折扣，基於QReadWriteLock讀寫模式進行代碼段鎖定，即可解決互斥鎖存在的問題。

#include <QCoreApplication>
#include <iostream>
#include <QThread>
#include <QMutex>
#include <QReadWriteLock>

static QReadWriteLock g_mutex;      // 線程鎖
static QString g_store;             // 定義全局變數

class Producer : public QThread
{
protected:
    void run()
    {
        int count = 0;

        while(true)
        {
            // 以寫入方式鎖定資源
            g_mutex.lockForWrite();

            g_store.append(QString::number((count++) % 10));

            // 寫入後解鎖資源
            g_mutex.unlock();

            msleep(900);
        }
    }
};

class Customer : public QThread
{
protected:
    void run()
    {
        while( true )
        {
            // 以讀取方式寫入資源
            g_mutex.lockForRead();
            if( g_store != "" )
            {
                std::cout << "Curstomer -> "<< g_store.toStdString() << std::endl;
            }

            // 讀取到後解鎖資源
            g_mutex.unlock();
            msleep(1000);
        }
    }
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Producer p1,p2;
    Customer c1,c2;

    p1.setObjectName("producer 1");
    p2.setObjectName("producer 2");

    c1.setObjectName("curstomer 1");
    c2.setObjectName("curstomer 2");

    p1.start();
    p2.start();

    c1.start();
    c2.start();

    return a.exec();
}

該鎖允許用戶以同步讀lockForRead()或同步寫lockForWrite()兩種方式實現保護資源，但只要有一個線程在以寫的方式操作資源，其他線程也會等待寫入操作結束後才可繼續讀資源。

1.5 基於信號線程鎖

QSemaphore 是Qt框架中提供的用於實現信號量的類。信號量是一種用於線上程之間進行同步和通信的機制，它允許多個線程在某個共用資源上進行協調，控制對該資源的訪問。QSemaphore 的主要作用是維護一個計數器，線程可以通過獲取和釋放信號量來改變計數器的值。

其主要方法包括：

  • QSemaphore(int n = 0)：構造函數，創建一個初始計數值為 n 的信號量。
  • void acquire(int n = 1)：獲取信號量，將計數器減去 n。如果計數器不足，線程將阻塞等待。
  • bool tryAcquire(int n = 1)：嘗試獲取信號量，如果計數器足夠，立即獲取並返回 true；否則返回 false。
  • void release(int n = 1)：釋放信號量，將計數器加上 n。如果有等待的線程，其中一個將被喚醒。

信號量是特殊的線程鎖，信號量允許N個線程同時訪問臨界資源，通過acquire()獲取到指定資源，release()釋放指定資源。

#include <QCoreApplication>
#include <iostream>
#include <QThread>
#include <QSemaphore>

const int SIZE = 5;
unsigned char g_buff[SIZE] = {0};

QSemaphore g_sem_free(SIZE); // 5個可生產資源
QSemaphore g_sem_used(0);    // 0個可消費資源

// 生產者生產產品
class Producer : public QThread
{
protected:
    void run()
    {
        while( true )
        {
            int value = qrand() % 256;

            // 若無法獲得可生產資源，阻塞在這裡
            g_sem_free.acquire();

            for(int i=0; i<SIZE; i++)
            {
                if( !g_buff[i] )
                {
                    g_buff[i] = value;
                    std::cout << objectName().toStdString() << " --> " << value << std::endl;
                    break;
                }
            }

            // 可消費資源數+1
            g_sem_used.release();

            sleep(2);
        }
    }
};

// 消費者消費產品
class Customer : public QThread
{
protected:
    void run()
    {
        while( true )
        {
            // 若無法獲得可消費資源，阻塞在這裡
            g_sem_used.acquire();

            for(int i=0; i<SIZE; i++)
            {
                if( g_buff[i] )
                {
                    int value = g_buff[i];

                    g_buff[i] = 0;
                    std::cout << objectName().toStdString() << " --> " << value << std::endl;
                    break;
                }
            }

            // 可生產資源數+1
            g_sem_free.release();

            sleep(1);
        }
    }
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Producer p1;
    Customer c1;

    p1.setObjectName("producer");
    c1.setObjectName("curstomer");

    p1.start();
    c1.start();

    return a.exec();
}
文章出處：https://www.cnblogs.com/LyShark/p/18056212
本博客所有文章除特別聲明外，均採用 BY-NC-SA 許可協議。轉載請註明出處！
您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 為HTTP而生的requests庫，縱橫江湖難逢敵手
    既然Python是一門全球流行的語言，那麼對於網路通信的HTTP的支持肯定也是非常的優秀的。Python中原生的urllib模塊也有對HTTP的支持，雖然也可以用來發送 HTTP 請求，但使用起來相對繁瑣，並且 API 設計不夠直觀。 requests 庫的出現填補了 Python 在 HTTP 請 ...
  • 【Flink入門修煉】2-2 Flink State 狀態
    - 什麼是狀態？狀態有什麼作用？ - 如果你來設計，對於一個流式服務，如何根據不斷輸入的數據計算呢？ - 又如何做故障恢復呢？ ...
  • PbRL Preference Transformer
    論文題目：Preference Transformer: Modeling Human Preferences using Transformers for RL，ICLR 2023，5 6 6 8，poster。 pdf：https://arxiv.org/pdf/2303.00957.pdf h ...
  • Python函數每日一講 - hex()
    Maven安裝本地的jar包 如果沒配置Maven的環境變數，需要先CD到maven的安裝目錄，因為沒配置環境變數，mvn命令是無法在maven安裝目錄以外的目錄運行。 cd C:\Maven\apache-maven-3.6.3\bin 然後執行下麵命令格式如下： mvn install:inst ...
  • CMS垃圾收集器
    CMS GC的英文名為：“Mostly Concurrent Mark and Sweep Garbage Collector” （最大-併發-標記-清除-垃圾收集器）。 作用範圍： 老年代 演算法： 併發標記清除演算法。 啟用參數：-XX:+UseConMarkSweepGC預設回收線程數：（處理器核 ...
  • 如何簡潔高效的搭建一個SpringCloud2023的maven工程
    依賴管理有gradle和maven，在這裡選擇比較常用和方便的Maven作為工程項目和依賴管理工具來搭建SpringCloud實戰工程。主要用到的maven管理方式是多模塊和bom依賴管理。 ...
  • 掌握pandas cut函數，一鍵實現數據分類
    pandas中的cut函數可將一維數據按照給定的區間進行分組，併為每個值分配對應的標簽。其主要功能是將連續的數值數據轉化為離散的分組數據，方便進行分析和統計。 1. 數據準備 下麵的示例中使用的數據採集自王者榮耀比賽的統計數據。數據下載地址：https://databook.top/。 導入數據： ...
  • pandas筆記（一）-- 大的國家（邏輯索引、切片）
    題目描述 如果一個國家滿足下述兩個條件之一，則認為該國是 大國 ： 面積至少為 300 萬平方公裡 人口至少為 2500 萬 編寫解決方案找出大國的國家名稱、人口和麵積 按任意順序返回結果表，如下例所示 測試用例 輸入： name continent area population gdp Afgh ...
一周排行
    -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.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類