简体中文(ZH-CN) English(EN) 繁体中文(ZH-TW) 日本語(JA) 한국어(KO) Melayu(MS) Français(FR) Deutsch(DE)
首頁 > 運維 > linux運維 > 主體

linux多執行緒同步的幾種方式是什麼

青灯夜游
發布： 2023-03-10 10:44:35
原創
2269 人瀏覽過

同步方式有：1、互斥鎖，是一個特殊全域變量，擁有lock和unlock兩種狀態，unlock互斥鎖可由某個執行緒取得，當互斥鎖由某個執行緒持有後，這個互斥鎖會鎖上變成lock狀態，此後只有該線程有權力打開該鎖；2、自旋鎖，就是一個死循環，不停的輪詢；3、信號量，是一個計數器，用於控制存取有限共享資源的執行緒數；4、條件變數；5、讀寫鎖；6、屏障，是使用者協調多個執行緒並行工作的同步機制。

linux多執行緒同步的幾種方式是什麼

本教學操作環境：linux7.3系統、Dell G3電腦。

執行緒同步指的是當一個執行緒在對某個臨界資源進行操作時，其他執行緒都不可以對這個資源進行操作，直到該執行緒完成操作，其他執行緒才能操作，也就是協同步調，讓執行緒依預定的先後次序進行運行。執行緒同步的方法有6種：互斥鎖、自旋鎖、信號量、條件變數、讀寫鎖、屏障。

linux執行緒同步的方法

#下面是一個執行緒不安全的例子：

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

int ticket_num=10000000;

void *sell_ticket(void *arg) {
    while(ticket_num>0) {
	ticket_num--;
    }
}

int main() {
    pthread_t t1,t2,t3;
    pthread_create(&t1, NULL, &sell_ticket, NULL);
    pthread_create(&t2, NULL, &sell_ticket, NULL);
    pthread_create(&t3, NULL, &sell_ticket, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    printf("ticket_num=%d\n", ticket_num);
    return 0;
}
登入後複製

運行結果如下：

# gcc no_lock_demo.c -o no_lock_demo.out -pthread
# ./no_lock_demo.out 
ticket_num=-2
登入後複製

最後運行的結果不是固定的，有可能是0、-1，如果有這個ticket_num變數代表是庫存的話，那麼就會出現庫存為負數的情況，所以需要引入線程同步來保證線程安全。

Linux下方提供了多種方式來處理執行緒同步，最常用的是互斥鎖、自旋鎖、訊號量。

1、互斥鎖

互斥鎖本質就是一個特殊的全域變量，擁有lock和unlock兩種狀態，unlock的互斥鎖可以由某個執行緒獲得，當互斥鎖由某個執行緒持有後，這個互斥鎖會鎖上變成lock狀態，此後只有該執行緒有權力打開該鎖，其他想要獲得該互斥鎖的執行緒都會阻塞，直到互斥鎖解鎖。

互斥鎖的類型：

  • 普通鎖定（PTHREAD_MUTEX_NORMAL）：互斥鎖定預設類型。當一個執行緒對一個普通鎖加鎖以後，其餘請求該鎖的執行緒將形成一個 等待隊列，並在該鎖解鎖後按照優先順序獲得它，這種鎖類型保證了資源分配的公平性。一個線程如果對一個已經加鎖的普通鎖再次加鎖，將引發死鎖；對一個已經被其他線程加鎖的普通鎖解鎖，或者對一個已經解鎖的普通鎖再次解鎖，將導致不可預期的後果。

  • 檢錯鎖（PTHREAD_MUTEX_ERRORCHECK）：一個執行緒如果對一個已經加鎖的檢錯鎖再次加鎖，則加鎖操作會傳回EDEADLK；對一個已經被其他執行緒加鎖的檢錯鎖解鎖或對一個已經解鎖的檢錯鎖再次解鎖，則解鎖操作返回EPERM。

  • 巢狀鎖定（PTHREAD_MUTEX_RECURSIVE）：此鎖定允許一個執行緒在釋放鎖定之前多次對它加鎖而不發生死鎖；其他執行緒要取得這個鎖，則目前鎖定的擁有者必須執行多次解鎖操作；對一個已經被其他線程加鎖的嵌套鎖解鎖，或者對一個已經解鎖的嵌套鎖再次解鎖，則解鎖操作返回EPERM。

  • 預設鎖（PTHREAD_MUTEX_ DEFAULT）：一個執行緒如果對一個已經加鎖的預設鎖再次加鎖，或者雖一個已經被其他執行緒加鎖的預設鎖解鎖，或者對一個解鎖的預設鎖解鎖，將導致不可預期的後果；這種鎖實現的時候可能被映射成上述三種鎖之一。

相關方法：

// 静态方式创建互斥锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 

// 动态方式创建互斥锁，其中参数mutexattr用于指定互斥锁的类型，具体类型见上面四种，如果为NULL，就是普通锁。
int pthread_mutex_init (pthread_mutex_t* mutex,const pthread_mutexattr_t* mutexattr);

int pthread_mutex_lock(pthread_mutex_t *mutex); // 加锁，阻塞
int pthread_mutex_trylock(pthread_mutex_t *mutex); // 尝试加锁，非阻塞
int pthread_mutex_unlock(pthread_mutex_t *mutex); // 解锁
登入後複製

範例：

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

int ticket_num=10000000;

pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;

void *sell_ticket(void *arg) {
    while(ticket_num>0) {
	pthread_mutex_lock(&mutex);
	if(ticket_num>0) {
	    ticket_num--;
	}
	pthread_mutex_unlock(&mutex);
    }
}

int main() {
    pthread_t t1,t2,t3;
    pthread_create(&t1, NULL, &sell_ticket, NULL);
    pthread_create(&t2, NULL, &sell_ticket, NULL);
    pthread_create(&t3, NULL, &sell_ticket, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    printf("ticket_num=%d\n", ticket_num);
    return 0;
}
登入後複製

2、自旋鎖定

自旋鎖顧名思義就是一個死循環，不停的輪詢，當一個線程未獲得自旋鎖時，不會像互斥鎖一樣進入阻塞休眠狀態，而是不停的輪詢獲取鎖，如果自旋鎖能夠很快就被釋放，那麼性能就會很高，如果自旋鎖長時間不能夠被釋放，甚至裡面還有大量的IO阻塞，就會導致其他獲取鎖的線程一直空輪詢，導致CPU使用率達到100%，特別CPU時間。

相關方法：

int pthread_spin_init(pthread_spinlock_t *lock, int pshared); // 创建自旋锁

int pthread_spin_lock(pthread_spinlock_t *lock); // 加锁，阻塞
int pthread_spin_trylock(pthread_spinlock_t *lock); // 尝试加锁，非阻塞
int pthread_spin_unlock(pthread_spinlock_t *lock); // 解锁
登入後複製

範例：

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

int ticket_num=10000000;

pthread_spinlock_t spinlock;

void *sell_ticket(void *arg) {
    while(ticket_num>0) {
	pthread_spin_lock(&spinlock);
	if(ticket_num>0) {
	    ticket_num--;
	}
	pthread_spin_unlock(&spinlock);
    }
}

int main() {
    pthread_spin_init(&spinlock, 0);
    pthread_t t1,t2,t3;
    pthread_create(&t1, NULL, &sell_ticket, NULL);
    pthread_create(&t2, NULL, &sell_ticket, NULL);
    pthread_create(&t3, NULL, &sell_ticket, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    printf("ticket_num=%d\n", ticket_num);
    return 0;
}
登入後複製

#3、信號量

訊號量是一個計數器，用來控制存取有限共享資源的執行緒數。

相關方法：

// 创建信号量
// pshared：一般取0，表示调用进程的信号量。非0表示该信号量可以共享内存的方式，为多个进程所共享(Linux暂不支持)。
// value：信号量的初始值，可以并发访问的线程数。
int sem_init (sem_t* sem, int pshared, unsigned int value);

int sem_wait (sem_t* sem); // 信号量减1，信号量为0时就会阻塞

int sem_trywait (sem_t* sem); // 信号量减1，信号量为0时返回-1，不阻塞

int sem_timedwait (sem_t* sem, const struct timespec* abs_timeout); // 信号量减1，信号量为0时阻塞，直到abs_timeout超时返回-1

int sem_post (sem_t* sem); // 信号量加1
登入後複製

範例：

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

int ticket_num=10000000;

sem_t sem;

void *sell_ticket(void *arg) {
    while(ticket_num>0) {
	sem_wait(&sem);
	if(ticket_num>0) {
	    ticket_num--;
	}
	sem_post(&sem);
    }
}

int main() {
    sem_init(&sem, 0, 1); // value=1表示最多1个线程同时访问共享资源，与互斥量等价
    pthread_t t1,t2,t3;
    pthread_create(&t1, NULL, &sell_ticket, NULL);
    pthread_create(&t2, NULL, &sell_ticket, NULL);
    pthread_create(&t3, NULL, &sell_ticket, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    printf("ticket_num=%d\n", ticket_num);
    return 0;
}
登入後複製

#4、條件變數

條件變數可以讓呼叫執行緒在滿足特定條件的情況下運行，不滿足條件時阻塞等待被喚醒，必須與互斥鎖搭配使用。

條件變數常用於生產者與消費者模型。

相關方法：

pthread_cond_t cond=PTHREAD_COND_INITIALIZER; // 创建条件变量，一个互斥锁可以对应多个条件变量

int pthread_cond_wait (pthread_cond_t* cond,pthread_mutex_t* mutex); // 阻塞等待条件满足，同时释放互斥锁mutex

int pthread_cond_timedwait (pthread_cond_t* cond,
    pthread_mutex_t* mutex,
    const struct timespec* abstime); // 带超时的阻塞等待条件满足，同时释放互斥锁mutex

// 从条件变量cond中唤出一个线程，令其重新获得原先的互斥锁
// 被唤出的线程此刻将从pthread_cond_wait函数中返回，但如果该线程无法获得原先的锁，则会继续阻塞在加锁上。
int pthread_cond_signal (pthread_cond_t* cond);

// 从条件变量cond中唤出所有线程
int pthread_cond_broadcast (pthread_cond_t* cond);
登入後複製

範例：

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

int max_buffer=10;
int count=0;

pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t notempty=PTHREAD_COND_INITIALIZER;
pthread_cond_t notfull=PTHREAD_COND_INITIALIZER;

void *produce(void *args) {
    while(1) {
        pthread_mutex_lock(&mutex);
        while(count == max_buffer) {
            printf("buffer is full, wait...\n");
            pthread_cond_wait(&notfull, &mutex);
        }
        printf("produce ...\n");
        count++;
        sleep(1);
        pthread_cond_signal(&notempty);
        pthread_mutex_unlock(&mutex);
    }

}

void *consumer(void *args) {
    while(1) {
        pthread_mutex_lock(&mutex);
        while(count == 0) {
            printf("buffer is empty, wait...\n");
            pthread_cond_wait(&notempty, &mutex);
        }
        printf("consumer ...\n");
        count--;
        sleep(1);
        pthread_cond_signal(&notfull);
        pthread_mutex_unlock(&mutex);
    }

}

int main() {
    pthread_t t1,t2,t3,t4;
    pthread_create(&t1, NULL, &produce, NULL);
    pthread_create(&t2, NULL, &produce, NULL);

    pthread_create(&t3, NULL, &consumer, NULL);
    pthread_create(&t4, NULL, &consumer, NULL);

    pthread_join(t1, NULL);
    return 0;
}
登入後複製

5、读写锁

读写锁可以有三种状态：读模式下加锁状态，写模式下加锁状态，不加锁状态。一次只有一个线程可以占有写模式的读写锁，但是多个线程可以同时占有读模式的读写锁。读写锁也叫做共享-独占锁，当读写锁以读模式锁住时，它是以共享模式锁住的，当它以写模式锁住时，它是以独占模式锁住的，读读共享，读写互斥。

相关方法：

// 创建读写锁
pthread_rwlock_t rwlock=PTHREAD_RWLOCK_INITIALIZER;

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); // 加读锁，阻塞
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock); // 加写锁，阻塞
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock); // 释放读锁或者写锁

int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock); // 尝试加读锁，非阻塞
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock); // 尝试加写锁，非阻塞
登入後複製

例子：

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

pthread_rwlock_t rwlock=PTHREAD_RWLOCK_INITIALIZER;

void *read(void *arg) {
    while(1) {
        pthread_rwlock_rdlock(&rwlock);
        rintf("read message.\n");
        sleep(1);
        pthread_rwlock_unlock(&rwlock);
        sleep(1);
    }
}
void *write(void *arg) {
    while(1) {
        pthread_rwlock_wrlock(&rwlock);
        printf("write message.\n");
        sleep(1);
        pthread_rwlock_unlock(&rwlock);
        sleep(1);
    }
}

int main(int argc,char *argv[]) {
    pthread_t t1,t2,t3;
    pthread_create(&t1, NULL, &read, NULL);
    pthread_create(&t2, NULL, &read, NULL);

    pthread_create(&t3, NULL, &write, NULL);

    pthread_join(t1, NULL);
    return 0;
}
登入後複製

6、屏障

屏障（barrier)是用户协调多个线程并行工作的同步机制。屏障允许每个线程等待，直到所有的合作线程都到达某一点，然后所有线程都从该点继续执行。pthread_join函数就是一种屏障，允许一个线程等待，直到另一个线程退出。但屏障对象的概念更广，允许任意数量的线程等待，直到所有的线程完成处理工作，而线程不需要退出，当所有的线程达到屏障后可以接着工作。

相关方法：

// 创建屏障
int pthread_barrier_init(pthread_barrier_t *barrier,const pthread_barrrierattr_t *attr,unsigned int count)

// 阻塞等待，直到所有线程都到达
int pthread_barrier_wait(pthread_barrier_t *barrier)
登入後複製

例子：

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

pthread_barrier_t barrier;

void *go(void *arg){
    sleep (rand () % 10);
    printf("%lu is arrived.\n", pthread_self());
    pthread_barrier_wait(&barrier);
    printf("%lu go shopping...\n", pthread_self());
}

int main() {
    pthread_barrier_init(&barrier, NULL, 3);

    pthread_t t1,t2,t3;
    pthread_create(&t1, NULL, &go, NULL);
    pthread_create(&t2, NULL, &go, NULL);
    pthread_create(&t3, NULL, &go, NULL);

    pthread_join(t1, NULL);
    return 0;
}
登入後複製

相关推荐：《Linux视频教程》

以上是linux多執行緒同步的幾種方式是什麼的詳細內容。更多資訊請關注PHP中文網其他相關文章！

相關標籤：
linux 多執行緒同步
來源：php.cn
上一篇：linux 宕機日誌在哪 下一篇：linux磁碟大小單位有哪些
本網站聲明
本文內容由網友自願投稿，版權歸原作者所有。本站不承擔相應的法律責任。如發現涉嫌抄襲或侵權的內容，請聯絡admin@php.cn
作者最新文章
最新問題
Linux Bash：輕鬆刪除 HTML 表資料塊 我有一個使用bash腳本處理的html文件，並且想要刪除空表。該檔案是從sql語句產生的，但在未找到記錄時包含表頭。我想刪除沒有找到記錄的標題。 <tableborder=&...
來自於 2024-04-02 09:13:43
0
1
332
相關專題
更多>
熱門推薦
熱門教學
更多>
相關教學
熱門推薦
最新課程
最新下載
更多>
網站特效
網站源碼
網站素材
前端模板
關於我們 免責聲明 Sitemap
PHP中文網：公益線上PHP培訓，幫助PHP學習者快速成長！