2. 程式人生 > >C/C++ 多執行緒機制

C/C++ 多執行緒機制

阿新 • • 發佈：2018-11-05

一、C/C++多執行緒操作說明

C/C++多執行緒基本操作如下： 
1. 執行緒的建立結束 
2. 執行緒的互斥和同步 
3. 使用訊號量控制執行緒 
4. 執行緒的基本屬性配置 

在C/C++程式碼編寫時，使用多執行緒機制，首先需要做的事情就是宣告引用，具體如下：

#include "pthread.h"

二、執行緒基本操作方法

基本執行緒操作：

1. pthread_create()：建立執行緒開始執行相關執行緒函式，執行結束則執行緒退出

2. pthread_eixt()：因為exit()是用來結束程序的，所以則需要使用特定結束執行緒的函式

3. pthread_join()：掛起當前執行緒，用於阻塞式地等待執行緒結束，如果執行緒已結束則立即返回，0=成功

4. pthread_cancel()：傳送終止訊號給thread執行緒，成功返回0，但是成功並不意味著thread會終止

5. pthread_testcancel()：在不包含取消點，但是又需要取消點的地方建立一個取消點，以便在一個沒有包含取消點的執行程式碼執行緒中響應取消請求.

6. pthread_setcancelstate()：設定本執行緒對cancle執行緒的反應

7. pthread_setcanceltype()：設定取消狀態 繼續執行至下一個取消點再退出或者是立即執行取消動作

8. pthread_setcancel()：設定取消狀態

三、執行緒互斥與同步機制 

基本的互斥與同步的操作方法：

1. pthread_mutex_init()：互斥鎖的初始化

2. pthread_mutex_lock()：鎖定互斥鎖，如果嘗試鎖定已經被上鎖的互斥鎖則阻塞至可用為止

3. pthread_mutex_trylock()：非阻塞的鎖定互斥鎖

4. pthread_mutex_unlock()：釋放互斥鎖

5. pthread_mutex_destory()：互斥鎖銷燬函式

四、訊號量執行緒控制機制

C/C++在使用訊號量機制的時候，預設的訊號量為匿名訊號量。

1. sem_init(sem)：初始化一個定位在sem的匿名訊號量

2. sem_wait()：把訊號量減1操作，如果訊號量的當前值為0則進入阻塞，為原子操作

3. sem_trywait()：如果訊號量的當前值為0則返回錯誤而不是阻塞呼叫(errno=EAGAIN),其實是sem_wait()的非阻塞版本

4. sem_post()：給訊號量的值加1，它是一個“原子操作”，即同時對同一個訊號量做加1,操作的兩個執行緒是不會衝突的

5. sem_getvalue(sval)：把sem指向的訊號量當前值放置在sval指向的整數上

6. sem_destory(sem)：銷燬由sem指向的匿名訊號量

五、多執行緒實踐

1. 基本的執行緒及建立執行

下面的程式碼是C/C++開發的基本的執行緒的執行，使用的就是最基本的pthread.h：

/* thread.c */
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
 
#define THREAD_NUMBER       3                 /*執行緒數*/
#define REPEAT_NUMBER       5                 /*每個執行緒中的小任務數*/
#define DELAY_TIME_LEVELS  10.0             /*小任務之間的最大時間間隔*/
//
void *thrd_func(void *arg) { 
    /* 執行緒函式例程 */
    int thrd_num = (int)arg;
    int delay_time = 0;
    int count = 0;
    printf("Thread %d is starting\n", thrd_num);
    for (count = 0; count < REPEAT_NUMBER; count++) {
        delay_time = (int)(rand() * DELAY_TIME_LEVELS/(RAND_MAX)) + 1;
        sleep(delay_time);
        printf("\tThread %d: job %d delay = %d\n", thrd_num, count, delay_time);
    }
 
    printf("Thread %d finished\n", thrd_num);
    pthread_exit(NULL);
}
 
int main(void) {
     pthread_t thread[THREAD_NUMBER];
     int no = 0, res;
     void * thrd_ret;
     srand(time(NULL));    
     for (no = 0; no < THREAD_NUMBER; no++) {
          /* 建立多執行緒 */
          res = pthread_create(&thread[no], NULL, thrd_func, (void*)no);
          if (res != 0) {
               printf("Create thread %d failed\n", no);
               exit(res);
          }
     }
 
     printf("Create treads success\n Waiting for threads to finish...\n");
     for (no = 0; no < THREAD_NUMBER; no++) {
          /* 等待執行緒結束 */
          res = pthread_join(thread[no], &thrd_ret);
          if (!res) {
            printf("Thread %d joined\n", no);
          } else {
            printf("Thread %d join failed\n", no);
          }
     }
     return 0;        
}

例程中迴圈3次建立3條執行緒，並且使用pthread_join函式依次等待執行緒結束； 
執行緒中使用rand()獲取隨機值隨機休眠5次，隨意會出現後執行的執行緒先執行完成； 
執行結果：

$ gcc thread.c -lpthread
$ ./a.out 
Create treads success
 Waiting for threads to finish...
Thread 0 is starting
Thread 1 is starting
Thread 2 is starting
Thread 1: job 0 delay = 2
Thread 1: job 1 delay = 2
Thread 0: job 0 delay = 8
Thread 2: job 0 delay = 10
Thread 2: job 1 delay = 3
Thread 1: job 2 delay = 10
Thread 0: job 1 delay = 8
Thread 0: job 2 delay = 3
Thread 0: job 3 delay = 1
Thread 2: job 2 delay = 8
Thread 1: job 3 delay = 8
Thread 1: job 4 delay = 1
Thread 1 finished
        Thread 2: job 3 delay = 6
        Thread 0: job 4 delay = 7
Thread 0 finished
Thread 0 joined
Thread 1 joined
        Thread 2: job 4 delay = 10
Thread 2 finished
Thread 2 joined

可以看到，執行緒1先於執行緒0執行，但是pthread_join的呼叫時間順序，先等待執行緒0執行； 
由於執行緒1已經早結束，所以執行緒0被pthread_join等到的時候，執行緒1已結束，就在等待到執行緒1時，直接返回； 

2. 執行緒執行的互斥和同步pthread_mutex_lock

下面我們在上面的程式中增加互斥鎖：

/*thread_mutex.c*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
 
#define THREAD_NUMBER        3            /* 執行緒數 */
#define REPEAT_NUMBER        3            /* 每個執行緒的小任務數 */
#define DELAY_TIME_LEVELS 10.0         /*小任務之間的最大時間間隔*/
pthread_mutex_t mutex;
 
void *thrd_func(void *arg) {
     int thrd_num = (int)arg;
     int delay_time = 0, count = 0;
     int res;
     /* 互斥鎖上鎖 */
     res = pthread_mutex_lock(&mutex);
     if (res) {
          printf("Thread %d lock failed\n", thrd_num);
          pthread_exit(NULL);
     }
     printf("Thread %d is starting\n", thrd_num);
     for (count = 0; count < REPEAT_NUMBER; count++) {          
         delay_time = (int)(rand() * DELAY_TIME_LEVELS/(RAND_MAX)) + 1;
         sleep(delay_time);
         printf("\tThread %d: job %d delay = %d\n", 
                                      thrd_num, count, delay_time);
     }
     printf("Thread %d finished\n", thrd_num);
     pthread_exit(NULL);
}
 
int main(void) {
     pthread_t thread[THREAD_NUMBER];
     int no = 0, res;
     void * thrd_ret;
 
     srand(time(NULL));
     /* 互斥鎖初始化 */
     pthread_mutex_init(&mutex, NULL);
     for (no = 0; no < THREAD_NUMBER; no++) {
          res = pthread_create(&thread[no], NULL, thrd_func, (void*)no);
          if (res != 0) {
              printf("Create thread %d failed\n", no);
              exit(res);
          }
     }     
     printf("Create treads success\n Waiting for threads to finish...\n");
     for (no = 0; no < THREAD_NUMBER; no++) {
          res = pthread_join(thread[no], &thrd_ret);
          if (!res) {
                printf("Thread %d joined\n", no);
          } else  {
              printf("Thread %d join failed\n", no);
          }
     }   
     /****互斥鎖解鎖***/
     pthread_mutex_unlock(&mutex);
     pthread_mutex_destroy(&mutex);          
     return 0;        
}

在上面的例程中直接新增同步鎖pthread_mutex_t； 
線上程中加入，於是程式在執行執行緒程式時； 
呼叫pthread_mutex_lock上鎖，發現上鎖時候後進入等待，等待鎖再次釋放後重新上鎖； 
所以執行緒程式載入到佇列中等待，等待成功上鎖後繼續執行程式程式碼； 
執行結果如下：

$gcc thread_mutex.c -lpthread
$ ./a.out 
Create treads success
 Waiting for threads to finish...
Thread 0 is starting
        Thread 0: job 0 delay = 9
        Thread 0: job 1 delay = 4
        Thread 0: job 2 delay = 7
Thread 0 finished
Thread 0 joined
Thread 1 is starting
        Thread 1: job 0 delay = 6
        Thread 1: job 1 delay = 4
        Thread 1: job 2 delay = 7
Thread 1 finished
Thread 1 joined
Thread 2 is starting
        Thread 2: job 0 delay = 3
        Thread 2: job 1 delay = 1
        Thread 2: job 2 delay = 6
Thread 2 finished
Thread 2 joined

 

3. 使用訊號量控制執行緒的執行順序sem_post

修改上面例程，上面的是使用pthread_mutex_lock互斥鎖控制執行緒執行順序， 
使用另外一種執行緒執行順序的控制：

/* thread_sem.c */
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
 
#define THREAD_NUMBER       3
#define REPEAT_NUMBER       3
#define DELAY_TIME_LEVELS   10.0
 
sem_t sem[THREAD_NUMBER];
 
void * thrd_func(void *arg) {
    int thrd_num = (int)arg;
    int delay_time = 0;
    int count = 0;
    sem_wait(&sem[thrd_num]);
    printf("Thread %d is starting\n", thrd_num);
    for (count = 0; count < REPEAT_NUMBER; count++) {
        delay_time = (int)(rand() * DELAY_TIME_LEVELS/(RAND_MAX)) + 1;
        sleep(delay_time);
        printf("\tThread %d: job %d delay = %d\n", thrd_num, count, delay_time);
    }
    printf("Thread %d finished\n", thrd_num);
    pthread_exit(NULL);
}
 
int main(void) {
    pthread_t thread[THREAD_NUMBER];
    int no = 0, res;
    void * thrd_ret;
    srand(time(NULL));
    for (no = 0; no < THREAD_NUMBER; no++) {
        sem_init(&sem[no], 0, 0);
        res = pthread_create(&thread[no], NULL, thrd_func, (void*)no);
        if (res != 0) {
            printf("Create thread %d failed\n", no);
            exit(res);
        }
    }
 
    printf("Create treads success\n Waiting for threads to finish...\n");
    sem_post(&sem[THREAD_NUMBER - 1]);
    for (no = THREAD_NUMBER - 1; no >= 0; no--) {
        res = pthread_join(thread[no], &thrd_ret);
        if (!res) {
            printf("Thread %d joined\n", no);
        } else {
            printf("Thread %d join failed\n", no);
        }
        sem_post(&sem[(no + THREAD_NUMBER - 1) % THREAD_NUMBER]);           
    }
 
    for (no = 0; no < THREAD_NUMBER; no++) {
        sem_destroy(&sem[no]);      
    }
    return 0;        
}

 

執行結果，仍然是建立3條執行緒，每條執行緒執行時休眠隨機時長：

$ gcc thread_sem.c -lpthread 
$ ./a.out 
Create treads success
 Waiting for threads to finish...
Thread 2 is starting
        Thread 2: job 0 delay = 9
        Thread 2: job 1 delay = 9
        Thread 2: job 2 delay = 5
Thread 2 finished
Thread 2 joined
Thread 1 is starting
        Thread 1: job 0 delay = 5
        Thread 1: job 1 delay = 7
        Thread 1: job 2 delay = 4
Thread 1 finished
Thread 1 joined
Thread 0 is starting
        Thread 0: job 0 delay = 3
        Thread 0: job 1 delay = 9
        Thread 0: job 2 delay = 8
Thread 0 finished
Thread 0 joined

執行結果與第2個例程非常相似，只不過教材中進行倒序執行而已； 
那麼這種方式其實與使用互斥鎖相比，程式碼量可讀性基本持平不相上下；

 

相關推薦

C/C++ 多執行緒機制

一、C/C++多執行緒操作說明 C/C++多執行緒基本操作如下： 1. 執行緒的建立結束 2. 執行緒的互斥和同步 3. 使用訊號量控制執行緒 4. 執行緒的基本屬性配置  在C/C++程式碼編寫時，使用多執行緒機制，首先需要做的事情就是宣告引用，具體如下

C++中多執行緒的加鎖機制

問題來源於某面試題： 編寫一個單例模式的類。 #include<iostream> #include<cstdio> #include<cstdlib> using namespace std; class singleStance{

C++實現多執行緒物件記憶體池帶垃圾回收機制

#include <Windows.h> #include <iostream> #include <map> #include <string> #include <assert.h> #include <

C語言之多執行緒機制(程式可以同時被執行而不會相互干擾)

接觸過linux的人或多或少知道，linux有多執行緒的機制，也就是說程式可以同時執行，不受干擾，關於這個在我以前的博文裡有過類似模擬的時間片輪轉程式，跟這個其實是類似的。其實在window上，執行緒的標頭檔案也是可以包含進來使用的，我這裡用DevC++這個軟體來測試，看看

linux下C開發多執行緒程式

轉：https://blog.csdn.net/lingfemg721/article/details/6574804   linux下用C開發多執行緒程式，Linux系統下的多執行緒遵循POSIX執行緒介面，稱為pthread。   #

[轉]c++11 多執行緒 future/promise

[轉自 https://blog.csdn.net/jiange_zh/article/details/51602938] 1. < future >標頭檔案簡介 Classes std::future std::future_error std::packaged_task std::pro

C#非同步多執行緒總結（delegate、Thread、Task、ThreadPool、Parallel、async、cancel）

同步與非同步多執行緒的區別： 1、同步方法卡介面（UI執行緒忙於計算）；非同步多執行緒不卡介面（主執行緒閒置，子執行緒在計算） 2、同步方法慢（CPU利用率低、資源耗費少）；非同步多執行緒快（CPU利用率高、資源耗費多） 3、同步方法是有序的；非同步方法是無序的（啟動無序、執行時間不確定、結

c++11多執行緒 thread

 1.thread建構函式 default (1) thread() noexcept; initialization (2) template <class Fn, class... Args> explicit

C++11 多執行緒執行緒共享資料

共享資料的問題 這些在作業系統中都有詳細的介紹，可以回顧作業系統課程。。很典型的就是資料競爭問題。 互斥量保護資料 最原始的方式：使用std::mutex建立互斥量，使用成員lock()加鎖，使用成員unlock()解鎖。但是這種方式需要我們在每個函數出口都呼叫一次unloc

C#關於多執行緒及執行緒同步 lock鎖的應用

Form1.cs using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq;

C++：多執行緒與鎖

多執行緒是小型軟體開發必然的趨勢。C++11將多執行緒相關操作全部整合到標準庫中了，省去了某些坑庫的編譯，真是大大的方便了軟體開發。多執行緒這個庫簡單方便實用，下面給出簡單的例子     #include <iostream> #inc

C語言多執行緒

將按鍵 和LED燈的控制放在兩個執行緒，因為通過按鍵檢測是阻塞 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <pthread.h> #include <

C語言多執行緒目錄操作

#include <stdio.h>#include <pthread.h>#include <stdlib.h>#include <sys/types.h>#include <dirent.h> #define NUM 2 void threa

c++11多執行緒與執行緒池

最近需要開發一個高效能運算庫，涉及到c++多執行緒的應用，上次做類似的事情已經是4年多以前了，印象中還頗有些麻煩。悔當初做了就算了，也沒想著留點記錄什麼的。這次又研究了一番，發現用上c++11特性之後，現在已經比較簡單了，在此記錄一下。   最簡單的多執行緒情況，不涉及公共變數，各個執行緒之間獨

C++11多執行緒（1）

        C++11中添加了duox多執行緒類，編寫C++程式可以直接使用C++11中的多執行緒庫，不必依賴於平臺多執行緒，這樣可以方便寫出誇平臺的多執行緒程式。多執行緒可以最大化利用計算機資源，提高程式碼的執行效率。         C++11中thread類提供兩

C++ 11 多執行緒下std::unique_lock與std::lock_guard的區別和用法

這裡主要介紹std::unique_lock與std::lock_guard的區別用法 先說簡單的 一、std::lock_guard的用法 std::lock_guard其實就是簡單的RAII封裝，在建構函式中進行加鎖，解構函式中進行解鎖，這樣可以保證函式退出時，鎖一定被釋放。 簡單來說，就是防止開

C++11多執行緒------std::async

std::async可以認為是封裝了一個std::promise，該函式返回一個std::future，用於獲取其他執行緒的資料。 一般有兩種模式： std::lanch::async：最常用的非同步模式，每次都要執行一遍 std::lanch::defer：只在第

C++11多執行緒---互斥量、鎖、條件變數的總結

關於互斥量std::mutex的總結 互斥量用於組成程式碼的臨界區。C++的多執行緒模型是基於記憶體的，或者說是基於程式碼片段的，這和我們作業系統學習的臨界區概念基本一致，但是與Golang不同，Golang是基於訊息模型的。 一個std::mutex的lock()和unlock

C++11多執行緒的原子操作

原子操作是同時只能有一個執行緒執行一個操作，不用使用互斥量即可實現，但是速度慢，而且一般只支援原生的型別，不夠靈活。更多的用處是作為訊號量進行使用。 示例程式碼，以int為例子： #include <atomic> #include <thread> #i

C++ 11 多執行緒--執行緒管理

說到多執行緒程式設計，那麼就不得不提並行和併發，多執行緒是實現併發（並行）的一種手段。並行是指兩個或多個獨立的操作同時進行。注意這裡是同時進行，區別於併發，在一個時間段內執行多個操作。在單核時代，多個執行緒是併發的，在一個時間段內輪流執行；在多核時代，多個執行緒可以實現真正的並行，在多核上真正獨立的並行執行。