學習環境 ：　 Centos6.5 Linux 核心 2.6

Linux執行緒部分總結分為兩部分：（1）執行緒的使用 ，（2）執行緒的同步與互斥。

第一部分執行緒的使用主要介紹，執行緒的概念，建立執行緒，執行緒退出，以及執行緒的終止與分離。【完成】 地址：【Linux】執行緒總結：初識、建立、等待、終止、分離

第二部分主要介紹在多執行緒環境下，使用同步與互斥保護共享資源，有互斥鎖，條件變數，訊號量，以及讀寫鎖。

第二部分開始 （第二部分，拖了快三個月，終於要出生了）

互斥量

描述

互斥變數用來保證同一時刻只有一個執行緒訪問需要保護的程式碼，用來保證臨界資源的資料一致性。本質上可理解為是一把鎖，在訪問共享資源之前申請鎖，只有你一個拿著鑰匙，別人要進入就必須等你出去後把鑰匙交給他們才可以。一旦使用完畢就要釋放鎖資源，給別人一個機會。 在使用的時候要注意，申請鎖資源與釋放鎖資源的順序，避免死鎖的產生。

介面

#include<pthread>
/* 動態初始化 */
int pthread_mutex_init(       pthread_mutex_t* mutex, 
                        const pthread_mutexattr_t* mutexattr);
/* 銷燬 */
int pthread_mutex_destroy( pthread_mutex_t* mutex);
/* 申請鎖資源 */
int pthread_mutex_lock   ( pthread_mutex_t* mutex);
/* 非阻塞申請鎖資源 */
int
 
 pthread_mutex_trylock( pthread_mutex_t* mutex);
/* 釋放鎖資源 */
int pthread_mutex_unlock ( pthread_mutex_t* mutex);

上述介面的第一個引數 mutex 都是定義的 pthread_mutex_t結構體指標，用來操作目標互斥鎖。

互斥鎖在使用之前必須初始化，pthread_mutex_init函式用於動態初始化互斥鎖，mutexattr 引數指定互斥鎖的屬性。還可以靜態分配，設定為常量 PTHREAD_MUTEX_INITALIZER。如果是動態初始化則在使用完成後需要呼叫pthread_mutex_destory

pthread_mutex_lock函式以原子操作的方式給一個互斥鎖加鎖。如果目標互斥鎖已經被鎖上，該函式的其餘呼叫者將被阻塞，直到互斥鎖的佔有者將其解鎖。

pthread_mutex_trylock函式非阻塞式加鎖，如果已經被加鎖時，該函式立即返回錯誤碼 EBUSY。

pthread_mutex_unlock函式以原子操作的方式的給一個互斥鎖解鎖。如果此時有其他執行緒在等待這個互斥鎖，解鎖後將會有一個執行緒獲得該鎖。

具體使用方法可參照部落格：執行緒安全與執行緒不安全，有一個互斥量的簡單示例。

條件變數

互斥鎖用於同步執行緒對共享資料的訪問，而條件變數用於線上程之間同步共享資料的值，給多個執行緒提供了一個會合的場所。

條件變數本身是由互斥量保護的。執行緒在改變條件狀態之前必須先鎖住。

介面

#include <pthread.h>

/* 動態初始化 */
int pthread_cond_init(pthread_cond_t* cond, const pthread_condattr_t* cond_attr);
/* 銷燬資源*/
int pthread_cond_destroy(pthread_cond_t* cond);
/* 等待cond 條件發生 */
int pthread_cond_wait(pthread_cond_t* cond, pthread_mutex_t* mutex);
/* 通知 cond 條件發生，只通知一個執行緒 */
int pthread_cond_signal(pthread_cond_t* cond);
/* 通知cond條件發生，通知所有程序 */
int pthread_cond_broadcast(pthread_cond_t* cond);

靜態初始化， 設定巨集 PTHREAD_COND_INITIALIZER。

使用例項：基於互斥鎖和條件變數單緩衝區（一次只能有一個物件操作）多生產者多消費者模型

有一個連結串列，限制最多可插入10個結點，
一個互斥鎖保護對連結串列的操作，
兩個條件變數通知滿 10 以及 為空。

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

/* 靜態初始化 鎖 和 條件變數*/
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t not_full = PTHREAD_COND_INITIALIZER;
pthread_cond_t not_empty  = PTHREAD_COND_INITIALIZER;

#define MAXSIZE  10
int count = 0;

typedef struct node
{
    int data;
    struct node* next;
} node_t, *pnode_t, **ppnode_t;


/* 初始化連結串列的頭結點 */
void list_init(ppnode_t pphead)
{
    assert(pphead);
    *pphead = (pnode_t)malloc(sizeof(node_t));
    (*pphead)->next = NULL;
}

/* 頭插 */
void list_push(pnode_t phead, int data)
{
    assert(phead);
    pnode_t temp = (pnode_t)malloc(sizeof(node_t));
    if(temp){
        temp->data = data;
        temp->next = phead->next;
        phead->next = temp;
    }
}

int list_empty(pnode_t phead)
{
    return phead->next == NULL ? 1 : 0;
}
/* 頭刪並通過引數返回被刪除的元素 */ 
void list_pop(pnode_t phead, int* data)
{
    assert(phead);
    if(!list_empty(phead))
    {
        pnode_t temp = phead->next;
        phead->next = temp->next;
        *data = temp->data;
        free(temp);
    }
}

void list_clear(pnode_t phead)
{
    while(!list_empty)
    {
        int data;
        list_pop(phead, &data);
    }
}

void list_destory(ppnode_t phead)
{
    assert(phead);
    list_clear(*phead);
    free(phead);
    phead = NULL;
}


void list_print(pnode_t phead)
{
    pnode_t start = phead->next;
    while(start)
    {
        printf("%d ", start->data);
        start = start->next;
    }
    printf("\n");
}

void* producer(void* arg)
{
    pnode_t phead = (pnode_t)arg;
    while(1)
    {
        pthread_mutex_lock(&mutex);
        while(count == MAXSIZE)
        {
            pthread_cond_wait(&not_full ,&mutex);
        }
        int data = 0;
        data =  rand()%100;
        list_push(phead,data);
        printf("producer : %d\n", data);
        count++;
        pthread_cond_signal(&not_empty);
        pthread_mutex_unlock(&mutex);
    }

}
void* consumer(void* arg)
{
    pnode_t phead = (pnode_t)arg;
    while(1)
    {
        pthread_mutex_lock(&mutex);
        while(count == 0)
        {
             pthread_cond_wait(&not_empty, &mutex);
        }

        int data = 0;
        list_pop(phead, &data);
        printf("consumer: %d \n", data);
        count--;
        pthread_cond_signal(&not_full);
        pthread_mutex_unlock(&mutex);
        sleep(1);
    }
}


int main()
{
    pnode_t phead;
    list_init(&phead);

    //pthread_mutex_init(&mutex, NULL);
    //pthread_cond_init(&cond, NULL);
    //pthread_cond_init(&empty, NULL);
    //
    /* 建立生產者執行緒和消費者執行緒 */
    pthread_t id1, id2, id3, id4;
    pthread_create(&id1, NULL, producer, (void*)phead);
    pthread_create(&id2, NULL, producer, (void*)phead);
    pthread_create(&id3, NULL, consumer, (void*)phead);
    pthread_create(&id4, NULL, consumer, (void*)phead);

    /* 執行緒等待回收資源 */
    pthread_join(id1, NULL);
    pthread_join(id2, NULL);
    pthread_join(id3, NULL);
    pthread_join(id4, NULL);

    /* 銷燬鎖和條件變數資源 */
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&not_empty);
    pthread_cond_destroy(&not_full);

    return 0;
}

訊號量

介面：

#include <semaphore.h>

/*初始化訊號量， pshared 為0表示在同一程序的執行緒間同步，value 指定訊號量的初始值*/
int sem_init(sem_t* sem, int pshared, unsigned int value);
/* 釋放訊號量佔有的核心資源 */
int sem_destory (sem_t* sem);
/* 讓訊號量-1 相當於 P 操作 申請資源 */
int sem_wait    (sem_t* sem);
/* sem_wait 的非阻塞版本 */
int sem_trywait (sem_t* sem);
/* 讓訊號量+1 相當於 V 操作 釋放資源*/
int sem_post    (sem_t* sem);

使用例項：基於環形佇列的多生產者多消費者模型：

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>


/* 環形佇列可分配資源數目 */
#define RESOURCE 6

int queue[RESOURCE];
int in = 0;
int out = 0;


/* 可生產數目訊號量 , 初始值為環形佇列大小*/
sem_t sem_p;
/* 可消費數目訊號線 ， 初始值為 0  */
sem_t sem_c;

/* 生產者與生產者之間的鎖 */
pthread_mutex_t mutex_p = PTHREAD_MUTEX_INITIALIZER;
/* 消費者與消費者之間的鎖 */
pthread_mutex_t mutex_c = PTHREAD_MUTEX_INITIALIZER;

/* 生產者數目，消費者數目*/
#define PRODUCER 5
#define CONSUMER 5


void* producer(void* arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex_p);
        sem_wait(&sem_p);
        printf("producer begin ...\n");
        queue[in] = rand()%100;
        int data = queue[in];
        in = (in+1) % RESOURCE;
        printf("producer %d  [done] \n", data);
        sem_post(&sem_c);
        pthread_mutex_unlock(&mutex_p);
    }
}
void* consumer(void* arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex_c);
        sem_wait(&sem_c);
        printf("consumer begin ...\n");
        int data = queue[out];
        queue[out] = -1;
        out = (out+1) % RESOURCE;
        sleep(1);
        printf("consumer %d [done]\n", data);
        sem_post(&sem_p);
        pthread_mutex_unlock(&mutex_c);
    }
}

int main()
{

    sem_init(&sem_p, 0, RESOURCE);
    sem_init(&sem_c, 0, 0);
    pthread_mutex_init(&mutex_c, NULL);
    pthread_mutex_init(&mutex_p, NULL);
    pthread_t p[10];
    pthread_t c[10];

    /* 建立執行緒 */
    int i = 0;
    for(; i < PRODUCER; i++){
        pthread_create(&p[i], NULL, producer, NULL);
    }
    i = 0;
    for(; i < CONSUMER; i++){
        pthread_create(&c[i], NULL, consumer, NULL);
    }


    /* 回收執行緒  */
    i = 0;
    for(; i < PRODUCER ; i++){
        pthread_join(p[i], NULL);
    }
    i = 0;
    for(; i < CONSUMER ; i++){
        pthread_join(c[i], NULL);
    }

    sem_destroy(&sem_p);
    sem_destroy(&sem_c);
    pthread_mutex_destroy(&mutex_p);
    pthread_mutex_destroy(&mutex_c);
    return 0;

}

擴充套件

還有讀寫鎖，用來處理讀者與寫者模型。讀者與寫者互斥與同步關係，讀者之間沒有關係，寫者之間互斥。

第二部分完