2. 程式人生 > >linux系統——POSIX執行緒模型

linux系統——POSIX執行緒模型

阿新 • • 發佈：2019-01-30

一、執行緒基礎

1、定義：
當在程序中建立一個新的執行緒時，新執行執行緒將擁有自己棧空間隱刺也有自己的區域性變數），但是它與建立者共享全域性變數、檔案描述符、訊號處理函式和當前的目錄狀態
2、優點：
3、缺點：
4、執行緒有一套完整的與其有關額函式庫，它們中大多數函式名都以pthread_開頭，為了使用這些函式庫，必須定義巨集_REENTRANT，標頭檔案為pthread.h，編譯程式額時候用選項-lpthread來連結執行緒庫

二、執行緒函式

1、建立執行緒



2、退出執行緒

3、等待執行緒

4、執行緒簡單例子：

例子char message[]主執行緒和子執行緒共享的變數

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

void *thread_function(void *arg);

char message[] = "Hello World";

int main() {
    int res;
    pthread_t a_thread;
    void *thread_result;
    res = pthread_create(&a_thread, NULL, thread_function, (void *)message);
    if (res != 0) {
        perror("Thread creation failed");
        exit(EXIT_FAILURE);
    }
    printf("Waiting for thread to finish...\n");
    res = pthread_join(a_thread, &thread_result);
    if (res != 0) {
        perror("Thread join failed");
        exit(EXIT_FAILURE);
    }
    printf("Thread joined, it returned %s\n", (char *)thread_result);
    printf("Message is now %s\n", message);
    exit(EXIT_SUCCESS);
}

void *thread_function(void *arg) {
    printf("thread_function is running. Argument was %s\n", (char *)arg);
    sleep(3);
    strcpy(message, "Bye!");
    pthread_exit("Thank you for the CPU time");
}

三、執行緒同步

1、變數條件同步：

子執行緒建立後，父子執行緒是通過CPU線上程快速切換來完成“看起來像是同時執行”的動作，除了執行緒區域性變數外，所有其他的變數都將在一個程序中的所有執行緒間共享，例子如下：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>

void *thread_function(void *arg);
int run_now = 1;
char message[] = "Hello World";

int main() {
    int res;
    pthread_t a_thread;
    void *thread_result;
    int print_count1 = 0;

    res = pthread_create(&a_thread, NULL, thread_function, (void *)message);
    if (res != 0) {
        perror("Thread creation failed");
        exit(EXIT_FAILURE);
    }

    while(print_count1++ < 20) {
        if (run_now == 1) {
            printf("1");
            run_now = 2;
        }
        else {
            sleep(1);
        }
    }

    printf("\nWaiting for thread to finish...\n");
    res = pthread_join(a_thread, &thread_result);
    if (res != 0) {
        perror("Thread join failed");
        exit(EXIT_FAILURE);
    }
    printf("Thread joined\n");
    exit(EXIT_SUCCESS);
}

void *thread_function(void *arg) {
    int print_count2 = 0;

    while(print_count2++ < 20) {
        if (run_now == 2) {
            printf("2");
            run_now = 1;
        }
        else {
            sleep(1);
        }
    }

    sleep(3);
}

2、計數訊號量同步

計數訊號量：有更多的取值

在這裡插入圖片描述

計數訊號量同步例子：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <semaphore.h>

void *thread_function(void *arg);
sem_t bin_sem;

#define WORK_SIZE 1024
char work_area[WORK_SIZE];

int main() {
    int res;
    pthread_t a_thread;
    void *thread_result;

    res = sem_init(&bin_sem, 0, 0);
    if (res != 0) {
        perror("Semaphore initialization failed");
        exit(EXIT_FAILURE);
    }
    res = pthread_create(&a_thread, NULL, thread_function, NULL);
    if (res != 0) {
        perror("Thread creation failed");
        exit(EXIT_FAILURE);
    }
    printf("Input some text. Enter 'end' to finish\n");
    while(strncmp("end", work_area, 3) != 0) {
        fgets(work_area, WORK_SIZE, stdin);
        sem_post(&bin_sem);//訊號量+1表示，共享變數可操作
    }
    /*以下可應對：連續快速的給出兩組資料而導致的子執行緒沒有時間處理，訊號量的邏輯運算錯誤問題/*
    /*
   while(strncmp("end", work_area, 3) != 0) {
      if (strncmp(work_area, "FAST", 4) == 0) {
        sem_post(&bin_sem);
        strcpy(work_area, "Wheeee...");
      } else {
        fgets(work_area, WORK_SIZE, stdin);
    }
    */  
      sem_post(&bin_sem);
    }
    printf("\nWaiting for thread to finish...\n");
    res = pthread_join(a_thread, &thread_result);
    if (res != 0) {
        perror("Thread join failed");
        exit(EXIT_FAILURE);
    }
    printf("Thread joined\n");
    sem_destroy(&bin_sem);
    exit(EXIT_SUCCESS);
}

void *thread_function(void *arg) {
    sem_wait(&bin_sem);//執行緒阻塞，直到訊號量不為0
    while(strncmp("end", work_area, 3) != 0) {
        printf("You input %d characters\n", strlen(work_area) -1);
        sem_wait(&bin_sem);//執行緒阻塞，直到訊號量不為0
    }
    pthread_exit(NULL);
}

補充說明：
在這裡插入圖片描述
以上程式是有缺陷的，應考慮主執行緒連續快速的給出兩組資料而導致的子執行緒沒有時間處理，訊號量的邏輯運算錯誤問題

3、互斥訊號量同步

二值訊號量：只有0-1取值
函式：

互斥訊號量例子：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <semaphore.h>

void *thread_function(void *arg);
pthread_mutex_t work_mutex; /* protects both work_area and time_to_exit */

#define WORK_SIZE 1024
char work_area[WORK_SIZE];
int time_to_exit = 0;

int main() {
    int res;
    pthread_t a_thread;
    void *thread_result;
    res = pthread_mutex_init(&work_mutex, NULL);
    if (res != 0) {
        perror("Mutex initialization failed");
        exit(EXIT_FAILURE);
    }
    res = pthread_create(&a_thread, NULL, thread_function, NULL);
    if (res != 0) {
        perror("Thread creation failed");
        exit(EXIT_FAILURE);
    }
    pthread_mutex_lock(&work_mutex);
    printf("Input some text. Enter 'end' to finish\n");
    while(!time_to_exit) {
        fgets(work_area, WORK_SIZE, stdin);
        pthread_mutex_unlock(&work_mutex);
        while(1) {
            pthread_mutex_lock(&work_mutex);
            if (work_area[0] != '\0') {
                pthread_mutex_unlock(&work_mutex);
                sleep(1);
            }
            else {
                break;
            }
        }
    }
    pthread_mutex_unlock(&work_mutex);
    printf("\nWaiting for thread to finish...\n");
    res = pthread_join(a_thread, &thread_result);
    if (res != 0) {
        perror("Thread join failed");
        exit(EXIT_FAILURE);
    }
    printf("Thread joined\n");
    pthread_mutex_destroy(&work_mutex);
    exit(EXIT_SUCCESS);
}

void *thread_function(void *arg) {
    sleep(1);
    pthread_mutex_lock(&work_mutex);//新執行緒試圖加鎖，如果鎖已被鎖住，則阻塞直到鎖被釋放
    while(strncmp("end", work_area, 3) != 0) {
        printf("You input %d characters\n", strlen(work_area) -1);
        work_area[0] = '\0';
        pthread_mutex_unlock(&work_mutex);
        sleep(1);//解鎖後等待主執行緒執行
        pthread_mutex_lock(&work_mutex);//試圖加鎖，如果鎖已被鎖住，則阻塞直到鎖被釋放
        while (work_area[0] == '\0' ) {
            pthread_mutex_unlock(&work_mutex);
            sleep(1);
            pthread_mutex_lock(&work_mutex);
        }
    }
    time_to_exit = 1;//有申請退出程式的請求，置標誌
    work_area[0] = '\0';
    pthread_mutex_unlock(&work_mutex);
    pthread_exit(0);
}

四、執行緒屬性

執行緒屬性作用於如下 ：在這裡插入圖片描述

1、脫線執行緒

假設我們在主執行緒繼續為使用者提供服務的同時建立了第二個執行緒，新執行緒的作用是將使用者正在編輯的資料檔案進行備份存貯，備份工作技術後，第二個執行緒就可以直接終止了，它沒必要再回到主執行緒中，此時我們就可以建立脫線執行緒

2、執行緒屬性設定函式

3、執行緒屬性例子——脫線屬性、執行緒排程策略

->該例子中，子執行緒是脫線執行緒，開始後獨立結束，並沒有返回執行緒狀態給主執行緒
->排程策略設定後，需要設定排程策略引數，該策略決定誰獲取cpu的執行權重比例

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>

void *thread_function(void *arg);

char message[] = "Hello World";
int thread_finished = 0;

int main() {
    int res;
    pthread_t a_thread;
    void *thread_result;
    pthread_attr_t thread_attr;

    **int max_priority;
    int min_priority;
    struct sched_param scheduling_value;**

    res = pthread_attr_init(&thread_attr);//初始化執行緒屬性物件
    if (res != 0) {
        perror("Attribute creation failed");
        exit(EXIT_FAILURE);
    }
    res = pthread_attr_setschedpolicy(&thread_attr, SCHED_OTHER);//設定執行緒排程策略
    if (res != 0) {
        perror("Setting schedpolicy failed");
        exit(EXIT_FAILURE);
    }
    res = pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED);//設定執行緒脫線屬性
    if (res != 0) {
        perror("Setting detached attribute failed");
        exit(EXIT_FAILURE);
    }
    res = pthread_create(&a_thread, &thread_attr, thread_function, (void *)message);//建立執行緒
    if (res != 0) {
        perror("Thread creation failed");
        exit(EXIT_FAILURE);
    }
    max_priority = sched_get_priority_max(SCHED_OTHER);//獲取可用的最大優先順序級別
    min_priority = sched_get_priority_min(SCHED_OTHER);//獲取可用的最小優先順序級別
    scheduling_value.sched_priority = min_priority;
    res = pthread_attr_setschedparam(&thread_attr, &scheduling_value);//設定排程引數
    if (res != 0) {
        perror("Setting schedpolicy failed");
        exit(EXIT_FAILURE);
    }
    (void)pthread_attr_destroy(&thread_attr);//銷燬執行緒屬性物件
    while(!thread_finished) {
        printf("Waiting for thread to say it's finished...\n");
        sleep(1);
    }
    printf("Other thread finished, bye!\n");
    exit(EXIT_SUCCESS);
}

void *thread_function(void *arg) {
    printf("thread_function is running. Argument was %s\n", (char *)arg);
    sleep(4);
    printf("Second thread setting finished flag, and exiting now\n");
    thread_finished = 1;
    pthread_exit(NULL);
}

五、取消執行緒

1、取消執行緒物件相關函式

2、取消執行緒物件例子

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>

void *thread_function(void *arg);

int main() {
    int res;
    pthread_t a_thread;
    void *thread_result;

    res = pthread_create(&a_thread, NULL, thread_function, NULL);
    if (res != 0) {
        perror("Thread creation failed");
        exit(EXIT_FAILURE);
    }
    sleep(3);
    printf("Canceling thread...\n");
    **res = pthread_cancel(a_thread);//主執行緒內取消子執行緒**
    if (res != 0) {
        perror("Thread cancelation failed");
        exit(EXIT_FAILURE);
    }
    printf("Waiting for thread to finish...\n");
    res = pthread_join(a_thread, &thread_result);
    if (res != 0) {
        perror("Thread join failed");
        exit(EXIT_FAILURE);
    }
    exit(EXIT_SUCCESS);
}

void *thread_function(void *arg) {
    int i, res, j;
    **res = pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);//設定子執行緒被取消使**能位
    if (res != 0) {
        perror("Thread pthread_setcancelstate failed");
        exit(EXIT_FAILURE);
    }
    **res = pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);//設定子執行緒被取消的時候的動作型別**
    if (res != 0) {
        perror("Thread pthread_setcanceltype failed");
        exit(EXIT_FAILURE);
    }
    printf("thread_function is running\n");
    for(i = 0; i < 10; i++) {
        printf("Thread is still running (%d)...\n", i);
        sleep(1);
    }
    pthread_exit(0);
}

六、多執行緒

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

#define NUM_THREADS 6

void *thread_function(void *arg);

int main() {
  
  int res;
  pthread_t a_thread[NUM_THREADS];
  void *thread_result;
  int lots_of_threads;
  

  for(lots_of_threads = 0; lots_of_threads < NUM_THREADS; lots_of_threads++) {

    res = pthread_create(&(a_thread[lots_of_threads]), NULL, thread_function, (void *)lots_of_threads);
    if (res != 0) {
      perror("Thread creation failed");
      exit(EXIT_FAILURE);
    }
    /*    sleep(1); */
  }

  printf("Waiting for threads to finish...\n");
  for(lots_of_threads = NUM_THREADS - 1; lots_of_threads >= 0; lots_of_threads--) {
    res = pthread_join(a_thread[lots_of_threads], &thread_result);
    if (res == 0) {
      printf("Picked up a thread\n");
    } else {
      perror("pthread_join failed");
    }
  }

  printf("All done\n");
  
  exit(EXIT_SUCCESS);
}

void *thread_function(void *arg) {
    int my_number = (int)arg;
    int rand_num;

    printf("thread_function is running. Argument was %d\n", my_number);
    rand_num=1+(int)(9.0*rand()/(RAND_MAX+1.0));
    sleep(rand_num);
    printf("Bye from %d\n", my_number);
    
    pthread_exit(NULL);
}

相關推薦

linux系統——POSIX執行緒模型

一、執行緒基礎 1、定義： 當在程序中建立一個新的執行緒時，新執行執行緒將擁有自己棧空間隱刺也有自己的區域性變數），但是它與建立者共享全域性變數、檔案描述符、訊號處理函式和當前的目錄狀態 2、優點： 3、缺點： 4、執行緒有一套完整的與其有關額函式庫，它們中大多

Linux系統程式設計——執行緒私有資料

在多執行緒程式中，經常要用全域性變數來實現多個函式間的資料共享。由於資料空間是共享的，因此全域性變數也為所有執行緒共有。 測試程式碼如下： #include <stdio.h> #include <pthread.h> #include <unis

Linux系統程式設計 | 執行緒概念

什麼是執行緒 在早期，unix其實是沒有執行緒的概念，因為它的程序已經做的足夠優秀了。但是，隨著作業系統行業的發展，其他作業系統，比如windows，都有了執行緒的存在。於是，很多開發人員就呼籲unix也提供執行緒功能。unix為了順應開發人員的呼籲，於是也開發出執行緒。

Linux系統程式設計 —執行緒同步概念

##**同步概念** 同步，指對在一個系統中所發生的事件之間進行協調，在時間上出現一致性與統一化的現象。 但是，對於不同行業，對於同步的理解略有不同。比如：裝置同步，是指在兩個裝置之間規定一個共同的時間參考；資料庫同步，是指讓兩個或多個數據庫內容保持一致，或者按需要部分保持一致；檔案同步，是指讓兩個或多個

Linux — POSIX 執行緒基礎

執行緒對於Linux後臺程式設計師來說並不陌生，執行緒帶給我們併發能力的提升，也提高了軟體開發和問題定位的難度，本文 嘗試結合GlibC 程式碼， 對POSIX的執行緒做一個簡單說明，重點介紹執行緒的建立，釋放和連線上需要注意的問題。 多程序和多執行緒的都只有一個目的，並行處理，提高CP

Linux系統下編寫shell指令碼傳入引數列印系統當前執行緒數到指定檔案

　　最近在做效能測試，要檢視系統執行過程中執行緒數，很簡單輸入命令：netstat -anp |grep java |wc -l，可以查詢。但是如何在執行過程定時列印系統執行緒數且將結果輸出到指定檔案呢？也很簡單我們直接寫一個shell指令碼執行下就可以了。以

多程序與多執行緒（五）--Linux 執行緒模型的比較：LinuxThreads 和 NPTL(轉)

當 Linux 最初開發時，在核心中並不能真正支援執行緒。但是它的確可以通過 clone() 系統呼叫將程序作為可排程的實體。這個呼叫建立了呼叫程序（calling process）的一個拷貝，這個拷貝與呼叫程序共享相同的地址空間。LinuxThreads 專案使用這個呼叫來完全在使用者空間模擬對執行緒的支援

【Linux】高併發伺服器模型（多程序模型和多執行緒模型）

多程序併發伺服器 使用多程序併發伺服器時要考慮以下幾點：             1.      父程序最大檔案描述個數(父程序中需要close關閉accept返回的新檔案描述符)             2.      系統內建立程序個數(與記憶體大小相關)      

linux執行緒模型

  /*thread_example.c :  c multiple thread programming in linux   *author : falcon   *E-mail : [email protected]   */ #include <pt

從 0 開始學習 Linux 系列之「25.Posix 執行緒」

多執行緒概念 多執行緒技術是應用開發中非常重要的技術之一，幾乎大型的應用軟體都使用這個技術，這次一起來學習下 Linux 中的多執行緒開發基礎（其他的系統中概念也是類似的）。 在 Linux 中，一個簡單的程序可以看成只有一個單執行緒（主執行緒），因為只有一

POSIX 執行緒取消點的 Linux 實現

摘要： 這篇文章主要從一個 Linux 下一個 pthread_cancel 函式引起的多執行緒死鎖小例子出發來說明 Linux 系統對 POSIX 執行緒取消點的實現方式，以及如何避免因此產生的執行緒死鎖。 目錄： 1. 一個 pthread_cancel 引起

linux網路程式設計之posix 執行緒（四）：posix 條件變數與互斥鎖 示例生產者--消費者問題

#include <unistd.h>#include <sys/types.h>#include <pthread.h>#include <semaphore.h>#include <stdlib.h>#include <stdio.h>

C 程序實現密碼隱秘輸入 linux系統可執行

用戶輸入 tdi code mar main ltr const 鍵盤輸入 dir 讀寫用戶輸入，屏幕不回顯 char *getpass( const char *prompt); getpass用於從鍵盤讀取用戶輸入，但屏幕不回顯。 參數prompt為屏幕提示字

Java執行緒模型總結

1. 計算機系統 使用快取記憶體來作為記憶體與處理器之間的緩衝，將運算需要用到的資料複製到快取中，讓計算能快速進行；當運算結束後再從快取同步回記憶體之中，這樣處理器就無需等待緩慢的記憶體讀寫了。 快取一致性：多處理器系統中，因為共享同一主記憶體，當多個處理器的運算任務都設計到同一塊記憶體區域

Android執行緒模型--在子執行緒中更新UI

       Android是支援多執行緒的。主執行緒也稱UI執行緒，子執行緒也稱工作執行緒。一般耗時操作在子執行緒中進行，更新UI操作在主執行緒中進行。在主執行緒中執行耗時操作容易發生ANR錯誤，即應用程式無響應。而Android中又規定只有建立UI的執行緒

OSG 多執行緒模型 設計思想

A New Processing Model for Multithreaded, Multidisplay Scene Graphs Copyright © 2001 Don Burns (DB - Apr 28, 2004) This article

linux 下多執行緒1

舉例UNIX International 執行緒 UNIX International 執行緒的標頭檔案是<thread.h> [1]  ，僅適用於Sun Solaris作業系統。所以UNIX International執行緒也常被俗稱為Solaris執

linux c 多執行緒開發

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

【轉】Leader-Follower執行緒模型

上圖就是L/F多執行緒模型的狀態變遷圖，共6個關鍵點： （1）執行緒有3種狀態：領導leading，處理processing，追隨following （2）假設共N個執行緒，其中只有1個leading執行緒（等待任務），x個processing執行緒（處理），餘下有N-1-x個following執行緒

Linux pthread_creat() 建立執行緒失敗問題總結

Linux pthread_creat() 建立執行緒失敗問題總結 目錄 問題場景 問題詳細描述 問題分析定位 1）pthread_create() 函式原型 2）實測系統最多可建立的執行緒數 3）測試結果 4）檢視shell啟動程序所佔