2. 程式人生 > >LInux C++多執行緒程式設計基礎(彙總)

LInux C++多執行緒程式設計基礎(彙總)

阿新 • • 發佈：2019-02-19

1. 前言

    本次來寫一篇關於C++多執行緒的基本使用。前面有一篇是互斥鎖的入門，學了兩天，做一下總結。

2. 多執行緒

    (1) 建立

多執行緒的表示pthread_t：

/* Thread identifiers.  The structure of the attribute type is not
   exposed on purpose.  */
typedef unsigned long int pthread_t;

在原始碼中，pthread_t實際上就只是一個無符號的long int變數，用於執行緒的唯一識別符號。

下面是pthread_create的原型：

/* Create a new thread, starting with execution of START-ROUTINE
   getting passed ARG.  Creation attributed come from ATTR.  The new
   handle is stored in *NEWTHREAD.  */
extern int pthread_create (pthread_t *__restrict __newthread,
			   const pthread_attr_t *__restrict __attr,
			   void *(*__start_routine) (void *),
			   void *__restrict __arg) __THROWNL __nonnull ((1, 3));

引數介紹：

    __newthread表示執行緒的唯一識別符號

    __attr表示執行緒的屬性，之後會介紹幾個小方面的

    __*(*__start_rountine)(void *)這個實際上就是一個函式的指標

    __arg表示函式的引數，需要將其轉化成void*指標才可以傳值

執行緒建立之後如果不進行其他的操作，那麼執行緒會在主執行緒結束的時候就結束，主執行緒不會等到所有執行緒結束後才結束，例如下面的程式碼：

#include <iostream>
#include <pthread.h>
#include <stdio.h>
#include <semaphore.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t count_nonzero;
unsigned count;

void* decrement_count(void* data)
{
    pthread_mutex_lock(&mut);

    while(count == 0)
    {
        printf("1\n");
        pthread_cond_wait(&count_nonzero,&mut);
    }

    count = count -1;
    printf("Dec\n");

    pthread_mutex_unlock(&mut);
}

void* increment_count(void* data)
{
    pthread_mutex_lock(&mut);

    if(count == 0)
        pthread_cond_signal(&count_nonzero);

    count = count + 1;
    printf("inc\n");
    pthread_mutex_unlock(&mut);
}


int main()
{
    count = 0;
    pthread_t tid[2];
    pthread_create(&tid[0],NULL,decrement_count,NULL);
    pthread_create(&tid[1],NULL,increment_count,NULL);

    printf("main\n");
}

其執行結果可以為下面的一種：

第一種
1
main

第二種
inc
main

第三種
1
inc
main
...

當然後面那些需要你的執行緒搶到主執行緒的資源，否則你會發現永遠是第一種情況。

第一種是什麼情況呢？

很簡單，主執行緒建立了新的執行緒，執行緒的執行順序是沒有保證的，這個時候第一個執行緒就先執行，但是又發現count = 0，執行緒就把鎖釋放。然後回到主執行緒，主執行緒又因為在main之後就結束了，使得這兩個執行緒根本就沒有時間執行，導致輸出以這種結果。

    (2) 執行緒的屬性

屬性物件主要包括是否繫結，是否分離，堆疊地址，堆疊大小，優先順序等。

分離屬性(detachstate)：

    分離：執行緒自己執行結束，則馬上釋放資源。

    不分離：如果加入pthread_join中，則需要等待pthread_join執行完畢之後才算結束，並且釋放資源。

所對應的巨集定義為：

    分離：PTHREAD_CREATE_DETACHED

    不分離：PTHREAD_CREATE_JOINABLE

設定函式為：

/* Set detach state attribute.  */
extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
					int __detachstate)
     __THROW __nonnull ((1));

注意，如果設定執行緒為分離的時候，執行緒的可能回現在pthread_create函式之前已經完成，導致返回錯誤的執行緒識別符號。可以新增pthread_cond_timewait()來讓執行緒等待一段時間，不能使用wait()，這個會使得整個程序都進入等待，並不能解決問題。

優先順序屬性(SCHED_PARAM)：

    就是執行緒執行的優先順序，優先順序高的先執行，當然，這在併發程式設計中也是沒有保證的。

設定函式：

/* Return in *PARAM the scheduling parameters of *ATTR.  */
extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
				       struct sched_param *__restrict __param)
     __THROW __nonnull ((1, 2));

/* Set scheduling parameters (priority, etc) in *ATTR according to PARAM.  */
extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
				       const struct sched_param *__restrict
				       __param) __THROW __nonnull ((1, 2));

設定樣例：

pthread_t tid[2];

pthread_attr_t attr;
sched_param param;
pthread_attr_init(&attr);
pthread_attr_getschedparam(&attr,¶m);
param.__sched_priority = 20;
pthread_attr_setschedparam(&attr,¶m);
pthread_create(&tid[0],&attr,decrement_count,NULL);

        (3) pthread_join/pthread_exit

/* Make calling thread wait for termination of the thread TH.  The
   exit status of the thread is stored in *THREAD_RETURN, if THREAD_RETURN
   is not NULL.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
extern int pthread_join (pthread_t __th, void **__thread_return);

pthread_join：可以將不分離的執行緒連線起來，直到這個函式呼叫結束的時候，執行緒才釋放資源。這樣也就可以解決前面的出現那種主執行緒結束了，執行緒沒有執行完成就結束的情況。當然，這個會阻塞當前執行緒，直到所有的執行緒結束為止。

/* Terminate calling thread.

   The registered cleanup handlers are called via exception handling
   so we cannot mark this function with __THROW.*/
extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));

pthread_exit退出執行緒。這個後面的引數是返回值，返回值可以在__thread_return中。

下面是之前的程式碼：

#include <iostream>
#include <pthread.h>
#include <stdio.h>
#include <semaphore.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t count_nonzero;
unsigned count;

void* decrement_count(void* data)
{
    pthread_mutex_lock(&mut);

    while(count == 0)
    {
        printf("1\n");
        pthread_cond_wait(&count_nonzero,&mut);
    }

    count = count -1;
    printf("Dec\n");

    pthread_mutex_unlock(&mut);
    pthread_exit(NULL);
}

void* increment_count(void* data)
{
    pthread_mutex_lock(&mut);

    if(count == 0)
        pthread_cond_signal(&count_nonzero);

    count = count + 1;
    printf("inc\n");
    pthread_mutex_unlock(&mut);
    pthread_exit(NULL);
}


int main()
{
    count = 0;
    pthread_t tid[2];

    pthread_attr_t attr;
    sched_param param;
    pthread_attr_init(&attr);
    pthread_attr_getschedparam(&attr,¶m);
    param.__sched_priority = 20;
    pthread_attr_setschedparam(&attr,¶m);
    pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_JOINABLE);
    pthread_create(&tid[0],&attr,decrement_count,NULL);
    pthread_create(&tid[1],&attr,increment_count,NULL);

    pthread_join(tid[0],NULL);
    pthread_join(tid[1],NULL);

    printf("main\n");
}

執行結果為：

1
inc
Dec
main

到這裡，執行緒的知識基本上就這些了。

3. C++11 thread類

C++11中新添加了一個執行緒的類，在<thread>標頭檔案中。

使用示例：

#include <iostream>
#include <pthread.h>
#include <stdio.h>
#include <semaphore.h>
#include <stdlib.h>
#include <string.h>
#include <thread>
using namespace std;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t count_nonzero;
unsigned count;

void decrement_count()
{
    pthread_mutex_lock(&mut);

    while(count == 0)
    {
        printf("1\n");
        pthread_cond_wait(&count_nonzero,&mut);
    }

    count = count -1;
    printf("Dec\n");

    pthread_mutex_unlock(&mut);
    pthread_exit(NULL);
}

void increment_count()
{
    pthread_mutex_lock(&mut);

    if(count == 0)
        pthread_cond_signal(&count_nonzero);

    count = count + 1;
    printf("inc\n");
    pthread_mutex_unlock(&mut);
    pthread_exit(NULL);
}


int main()
{
    count = 0;
    thread t[2];
    t[0] = thread(decrement_count);
    t[1] = thread(increment_count);
    t[0].join();
    t[1].join();
}

有沒有覺得函式變得簡單易懂，而且很符合我們的程式設計習慣了= =

這個需要在執行join的時候才會執行執行緒，如果在主執行緒結束之前，沒有join，會輸出錯誤。

而且這個join是不會保證執行的順序的，也就是主執行緒和join的執行緒的執行順序是沒有保證的，join只是保證join的執行緒一定能夠執行到結束。

參考連結：

https://blog.csdn.net/stone_overlooking/article/details/78520945

http://www.runoob.com/cplusplus/cpp-multithreading.html

https://blog.csdn.net/chenxun_2010/article/details/49785611

相關推薦

LInux C++多執行緒程式設計基礎(彙總)

1. 前言    本次來寫一篇關於C++多執行緒的基本使用。前面有一篇是互斥鎖的入門，學了兩天，做一下總結。2. 多執行緒    (1) 建立多執行緒的表示pthread_t：/* Thread identifiers. The structure of the attri

Linux c多執行緒程式設計的4個例項

在主流的作業系統中，多工一般都提供了程序和執行緒兩種實現方式，程序享有獨立的程序空間，而執行緒相對於程序來說是一種更加輕量級的多工並行，多執行緒之間一般都是共享所在程序的記憶體空間的。 　　Linux也不例外，雖然從核心的角度來看，執行緒體現為一種對程序的"克隆"(clon

Linux C 多執行緒程式設計總結

執行緒的資料處理 　　和程序相比，執行緒的最大優點之一是資料的共享性，各個程序共享父程序處沿襲的資料段，可以方便的獲得、修改資料。但這也給多執行緒程式設計帶來了許多問題。我們必須當心有多個不同的程序訪問相同的變數。許多函式是不可重入的，即同時不能執行一個函式的多個拷貝（除非使用不同的資料段）。在函式中宣告的

【Linux C 多執行緒程式設計】互斥鎖與條件變數

一、互斥鎖互斥量從本質上說就是一把鎖, 提供對共享資源的保護訪問。　　1. 初始化:　　在Linux下, 執行緒的互斥量資料型別是pthread_mutex_t. 在使用前, 要對它進行初始化:　　對於靜態分配的互斥量, 可以把它設定為PTHREAD_MUTEX_INITIA

Linux C++多執行緒程式設計

1.介紹 　　相比程序，多執行緒是一種節儉的多工操作方式。在Linux系統下，啟動一個新的程序必須分配給它獨立的地址空間，建立眾多的資料表來維護它的程式碼段、堆疊段和資料段。而執行一個程序中的多個執行緒，它們彼此之間使用相同的地址空間，共享大部分資料，啟動一個

樹莓派3B Linux下C++多執行緒程式設計

下面的程式碼手動建立了兩個執行緒，一個執行緒是讀取串列埠的資料，另一個執行緒是通過UDP來讀取網路通訊收到的資料。加上main函式的執行緒，一共三個執行緒。 先簡單講一下多執行緒的建立， pthread_t serial; int ser =

C/C++ Linux下多執行緒程式設計 #include

1.最基礎，程序同時建立5個執行緒，各自呼叫同一個函式 #include <iostream> #include <pthread.h> //多執行緒相關操作標頭檔案，可移植眾多平臺   using namespa

C++11多執行緒程式設計基礎入門

1.在C++11中建立新執行緒 　　在每個c++應用程式中，都有一個預設的主執行緒，即main函式，在c++11中，我們可以通過建立std::thread類的物件來建立其他執行緒，每個std :: thread物件都可以與一個執行緒相關聯，只需包含標頭檔案&l

linux c/c++多執行緒程式設計

如何在linux 下c++中類的成員函式中建立多執行緒 linux系統中執行緒程式庫是POSIX pthread。POSIX pthread它是一個c的庫，用C語言進行多執行緒程式設計我這裡就不多說了，網上的例子很多。但是如何在C++的類中實現多執行緒程式設計呢？如果套用C語言中建立多執行緒的方式，在編譯的

Linux C/C++ 多執行緒程式設計

如果你用的是LINUX/UNIX/MacOSX，那麼我們已經可以開始了，如果你用的是WINDOWS，那麼你需要從網站上下載PTHREAD的WINDOWS開發包，所幸他非常的小。網站地址是http://sourceware.org/pthreads-win32/一、 先來看一

Java多執行緒程式設計基礎知識彙總

## 多執行緒簡介 ### 多工   現代作業系統（Windows、Linux、MacOS）都可以執行多工，多工就是同時執行多個任務。例如在我們的計算機上，一般都同時跑著多個程式，例如瀏覽器，視訊播放器，音樂播放器，Word辦公軟體等等，由於CPU執行程式碼都是一條一條順序執行的，即時是單

linux c 多執行緒開發

在開發多執行緒程式時，當建立的執行緒數量特別多的時候，就會遇到執行緒數量的瓶頸。 多執行緒設定 設定核心引數 kernel.threads-max kernel.threads-max 是 linux 系統允許建立的最大執行緒數，預設是 7767 修改 /etc/sysc

簡單的Linux C++多執行緒CLOCK（時鐘）類

剛剛加入CSDN部落格，初來乍到也不知道寫什麼，所以來分享一個自己以前學C++的時候寫的第一個類，一個關於時鐘的簡單的Linux多執行緒CLOCK（時鐘）類： /***********************************************

理解c++多執行緒程式設計

多執行緒程式設計 本篇博文不是主要介紹互斥鎖之類的，是理解執行緒的執行，以便以後有把握的寫多執行緒程式。 #include<thread> #include<iostream&g

Linux 的多執行緒程式設計的高效開發經驗

背景 Linux 平臺上的多執行緒程式開發相對應其他平臺（比如 Windows）的多執行緒 API 有一些細微和隱晦的差別。不注意這些 Linux 上的一些開發陷阱，常常會

最簡單的實現Linux C++多執行緒的互斥訪問

#include <stdlib.h> #include <string.h> #include <iostream> #include <unistd.h> #include <errno.h> #include <pthrea

C#多執行緒程式設計筆記(5.2)-在lambda表示式中使用await操作符

近來在學習Eugene Agafonov編寫的《C#多執行緒程式設計實戰》（譯），做些筆記也順便分享一下^-^using System; using System.Threading.Tasks; using System.Threading; namespace 在Lam

【C++多執行緒程式設計學習(1)】-CPU個數、CPU核心數、CPU執行緒數

轉自：CPU個數、CPU核心數、CPU執行緒數(by kimsimple)   CPU個數即CPU晶片個數。 CPU核心數是指物理上，也就是硬體上存在著幾個核心。比如，雙核就是包括2個相對獨立的CPU核心單元組，四核就包含4個相對獨立的CPU核心單元組。 CPU執行緒數是一

C++——多執行緒程式設計（二）std::mutex 執行緒同步、解決資源競爭問題

前言 執行緒同步 這裡的“同”不是同時、一起執行的意思，而是指協同、協助、互相配合。執行緒同步是指多個執行緒協同步調，按預定的先後次序進行執行。 執行緒A和B一塊配合，A執行到一定程度時要依靠B的某個結果，於是停下來，示意B執行；B依言執行，再將結果給A；

windows C++多執行緒程式設計高階篇 實現執行緒同步

    上一篇文章windows程式設計 使用C++實現多執行緒類僅僅是介紹了怎樣用類來實現多執行緒，這篇文章則重點介紹多執行緒中資料同步的問題。好了，廢話不多說，進入主題。     問題場景：這裡我們假設有這樣一個工作流水線(CWorkPipeline)，它不斷的生成一