#include <pthread.h>
int pthread_create(
	  pthread_t *thread
	, const pthread_attr_t *attr
	, void *(*start_routine) (void *)
	, void *arg);

#include <iostream>
#include <pthread.h>
#include <unistd.h>
void* working(void* arg) {
    std::cout << "子線程" << pthread_self() << std::endl;
    for (int i = 0; i < 3; i++) {
        std::cout << "chiled say: " << i << std::endl;
    }
}
int main () {
    pthread_t tid;
    pthread_create(&tid, NULL, working, NULL);
    sleep(1); //為啥這里一定要睡一會(huì)兒？
    std::cout << "parent say：" << tid << std::endl;
    return 0;
}
//輸出：
子線程140470444414528
chiled say: 0
chiled say: 1
chiled say: 2
parent say：140470444414528

#include <pthread.h>
void pthread_exit(void *retval);

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
void* child_thread(void* arg) {
    sleep(1);
    printf("Child thread is running.\n");
    // 子線程執(zhí)行一些工作
    pthread_exit(NULL); // 正常退出子線程
}
int main() {
    pthread_t tid;
    // 創(chuàng)建子線程
    if (pthread_create(&tid, NULL, child_thread, NULL) != 0) {
        perror("Failed to create thread");
        return 1;
    }
    // 主線程立即退出，子線程繼續(xù)運(yùn)行
    printf("Main thread is exiting.\n");
    pthread_exit(NULL);
    return 0; // 這行代碼不會(huì)執(zhí)行，因?yàn)橹骶€程已經(jīng)退出
}

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
void* child_thread(void* arg) {
    int* data = (int*)arg;
    printf("Child thread is processing data.\n");
    // 模擬計(jì)算
    *data = 42;
    pthread_exit(data); // 子線程結(jié)束，并返回?cái)?shù)據(jù)指針
}
int main() {
    pthread_t tid;
    int result;
    // 分配內(nèi)存用于存儲(chǔ)子線程的結(jié)果，該數(shù)據(jù)位于堆上
    int* data = (int*)malloc(sizeof(int));
    // 創(chuàng)建子線程
    pthread_create(&tid, NULL, child_thread, data);
	//主線程在干自己的任務(wù)，把修改data數(shù)據(jù)的任務(wù)交給了子線程
    // 等待子線程結(jié)束，并獲取返回狀態(tài)
    pthread_join(tid, (void**)&data);
    // 檢查子線程的返回值
    if (data != NULL) {
        printf("Child thread returned: %d\n", *data);
        free(data);
    } else {
        printf("Child thread failed to return data.\n");
        free(data);
    }
    return 0;
}

#include <pthread.h>
// 這是一個(gè)阻塞函數(shù), 子線程在運(yùn)行這個(gè)函數(shù)就阻塞
// 子線程退出, 函數(shù)解除阻塞, 回收對(duì)應(yīng)的子線程資源, 類似于回收進(jìn)程使用的函數(shù) wait()
int pthread_join(pthread_t thread, void **retval);
pthread_join(tid, (void**)&data);

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <iostream>
void* child_thread(void* arg) {
    std::string* str = new std::string("hello world"); // 在堆上分配內(nèi)存
    pthread_exit((void*)str); // 返回指向堆上字符串的指針
}
int main() {
    pthread_t tid;
    // 創(chuàng)建子線程
    pthread_create(&tid, NULL, child_thread, NULL);
    void* ptr = nullptr;
    //主線程執(zhí)行自己的業(yè)務(wù)邏輯，把寫一個(gè)hello world字符串的任務(wù)交給子線程
    // 等待子線程結(jié)束，并獲取返回狀態(tài)
    pthread_join(tid, &ptr);
    // 將void*指針轉(zhuǎn)換為std::string*指針，并打印字符串
    std::string* str_ptr = static_cast<std::string*>(ptr);
    std::cout << *str_ptr << std::endl;
    // 釋放堆上分配的內(nèi)存
    delete str_ptr;
    return 0;
}

#include <iostream>
#include <pthread.h>
#include <unistd.h>
void* working(void *arg) {
    for (int i = 0; i < 10; i ++) {
        std::cout << "child say: "  << i << std::endl;
    }
}
int main () {
    pthread_t tid;
    pthread_create(&tid, NULL, working, NULL);
    //子線程與主線程分離
    pthread_detach(tid);
    //主線程執(zhí)行自己的邏輯
    for (int i = 100; i < 110; i++) {
        std::cout << "parent say: " << i << std::endl;
    }
    std::cout << "task done!!!" << std::endl;
    return 0;
}

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
// 定義一個(gè)互斥鎖
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
// 共享數(shù)據(jù)
int shared_data = 0;
// 線程函數(shù)
void* thread_function(void* arg) {
    // 鎖定互斥鎖
    pthread_mutex_lock(&mutex);
    // 對(duì)共享數(shù)據(jù)進(jìn)行操作
    shared_data++;
    // 打印共享數(shù)據(jù)
    printf("Thread %ld - shared_data: %d\n", pthread_self(), shared_data);
    // 解鎖互斥鎖
    pthread_mutex_unlock(&mutex);
    return NULL;
}
int main() {
    pthread_t tid1, tid2;
    // 創(chuàng)建兩個(gè)線程
    pthread_create(&tid1, NULL, thread_function, NULL);
    pthread_create(&tid2, NULL, thread_function, NULL);
    // 等待線程結(jié)束
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    // 銷毀互斥鎖
    pthread_mutex_destroy(&mutex);
    return 0;
}

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
// 定義一個(gè)讀寫鎖
pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;
// 共享數(shù)據(jù)
int shared_data = 0;
// 讀取共享數(shù)據(jù)的線程函數(shù)
void* reader(void* arg) {
    (void)arg; // 未使用的參數(shù)
    // 讀取鎖
    pthread_rwlock_rdlock(&rwlock);
    printf("Reader: shared_data = %d\n", shared_data);
    // 釋放讀取鎖
    pthread_rwlock_unlock(&rwlock);
    return NULL;
}
// 寫入共享數(shù)據(jù)的線程函數(shù)
void* writer(void* arg) {
    (void)arg; // 未使用的參數(shù)
    // 寫入鎖
    pthread_rwlock_wrlock(&rwlock);
    // 修改共享數(shù)據(jù)
    shared_data++;
    printf("Writer: updated shared_data to %d\n", shared_data);
    // 釋放寫入鎖
    pthread_rwlock_unlock(&rwlock);
    return NULL;
}
int main() {
    pthread_t r1, r2, w1;
    // 創(chuàng)建讀者線程
    pthread_create(&r1, NULL, reader, NULL);
    // 創(chuàng)建另一個(gè)讀者線程
    pthread_create(&r2, NULL, reader, NULL);
    // 等待讀者線程完成
    pthread_join(r1, NULL);
    pthread_join(r2, NULL);
    // 創(chuàng)建寫入者線程
    pthread_create(&w1, NULL, writer, NULL);
    // 等待寫入者線程完成
    pthread_join(w1, NULL);
    // 銷毀讀寫鎖
    pthread_rwlock_destroy(&rwlock);
    return 0;
}

// 讀取鎖
pthread_rwlock_rdlock(&rwlock);
// 寫入鎖
pthread_rwlock_wrlock(&rwlock);
//釋放讀取鎖或者寫入鎖
pthread_rwlock_unlock(&rwlock);

#include <pthread.h>
//定義條件變量類型變量
pthread_cond_t cond;
//初始化
//第一個(gè)傳參&cond
//第二個(gè)參數(shù)為條件變量屬性，一般使用默認(rèn)屬性，指定為NULL
int pthread_cond_init(pthread_cond_t *cond, NULL) 
//釋放資源
int pthread_cond_destroy(pthread_cond_t *cond);
//線程阻塞函數(shù)：它的工作流程如下
//1. 釋放與條件變量cond關(guān)聯(lián)的互斥鎖mutex
//2. 之后，調(diào)用線程會(huì)被阻塞，并從運(yùn)行狀態(tài)中移除，進(jìn)入等待條件變量的狀態(tài)。
//3. 直到另一個(gè)線程執(zhí)行了對(duì)應(yīng)的 pthread_cond_signal 或 pthread_cond_broadcast 操作來喚醒它
//4. 被喚醒后重新獲取互斥鎖
//5.解除阻塞
int pthread_cond_wait(pthread_cond_t *restrict cond
	, pthread_mutex_t *restrict mutex);
//有超時(shí)時(shí)間的線程阻塞函數(shù)，時(shí)間到達(dá)之后，解除阻塞
int pthread_cond_timedwait(pthread_cond_t *restrict cond
	, pthread_mutex_t *restrict mutex
	, const struct timespec *restrict abstime);
// 喚醒阻塞在條件變量上的線程, 至少有一個(gè)被解除阻塞
int pthread_cond_signal(pthread_cond_t *cond);
// 喚醒阻塞在條件變量上的線程, 被阻塞的線程全部解除阻塞
int pthread_cond_broadcast(pthread_cond_t *cond);

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
// 鏈表的節(jié)點(diǎn)
struct Node
{
    int number;
    struct Node* next;
};
// 定義條件變量, 控制消費(fèi)者線程
pthread_cond_t cond;
// 互斥鎖變量
pthread_mutex_t mutex;
// 指向頭結(jié)點(diǎn)的指針
struct Node * head = NULL;
void* producer(void *arg) {
    while(1) {
        //模擬生產(chǎn)時(shí)間
        sleep(rand() % 3); 
        pthread_mutex_lock(&mutex);
        Node* pnew = (struct Node*)malloc(sizeof(Node));
        pnew->number = rand() % 1000;
        pnew->next = head; 
        head = pnew;
        printf("producer, number = %d, tid=%ld\n"
            , pnew->number
            , pthread_self());
        pthread_mutex_unlock(&mutex);
        //生產(chǎn)了任務(wù)，通知消費(fèi)者消費(fèi)
        pthread_cond_broadcast(&cond);
    }
    return nullptr;
}
void* consumer(void *arg) {
    while(1) {
        pthread_mutex_lock(&mutex);
        while(head == nullptr) {
            pthread_cond_wait(&cond, &mutex);
        }
        //消費(fèi)過程
        Node* pnode = head;
        printf("consumer, number = %d, tid = %ld\n"
            , pnode->number
            , pthread_self());
        head = pnode->next;
        free(pnode);
        pthread_mutex_unlock(&mutex);
        //模擬消費(fèi)時(shí)間
        sleep(rand() % 3);
    }
    return nullptr;
}
int main()
{
    pthread_cond_init(&cond, nullptr);
    pthread_mutex_init(&mutex, nullptr);
    //創(chuàng)建5個(gè)生產(chǎn)者，5個(gè)消費(fèi)者
    pthread_t ptid[5];
    pthread_t ctid[5];
    //啟動(dòng)線程
    for (int i = 0; i < 5; i++) {
        pthread_create(&ptid[i], nullptr, producer, nullptr);
    }
    for (int i = 0; i < 5; i++) {
        pthread_create(&ptid[i], nullptr, consumer, nullptr);
    }
    //釋放資源
    for (int i = 0; i < 5; i++) {
        pthread_join(ptid[i], nullptr);
    }
    for (int i = 0; i < 5; i++) {
        pthread_join(ctid[i], nullptr);
    }
    //銷毀互斥鎖和條件變量
    pthread_cond_destroy(&cond);
    pthread_mutex_destroy(&mutex);
}

#include <semaphore.h>
//定義變量
sem_t sem;
//初始化
// pshared = 0 線程同步
// pshared 非 0 進(jìn)程同步
// value：初始化當(dāng)前信號(hào)量擁有的資源數(shù)（>=0），如果資源數(shù)為0，線程就會(huì)被阻塞了。
int sem_init(sem_t *sem, int pshared, unsighed int val);
//釋放資源
int sem_destroy(sem_t *sem);
//線程阻塞函數(shù):如果資源數(shù)被耗盡，則函數(shù)阻塞
// 函數(shù)被調(diào)用, sem中的資源就會(huì)被消耗1個(gè), 資源數(shù)-1
int sem_wait(sem_t *sem);
//如果資源被耗盡，直接返回錯(cuò)誤號(hào)，用于處理獲取資源失敗之后的情況
int sem_trywait(sem_t *sem);
//超時(shí)阻塞：就算被阻塞了，超過某時(shí)間解除阻塞
int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
//調(diào)用該函數(shù)給sem中的資源數(shù)+1
int sem_post(sem_t *sem);

#include <pthread.h>
#include <semaphore.h>
#include <stdio.h>
#include <unistd.h>
#define MAXNUM 2
sem_t semPtr;
pthread_t a_thread, b_thread, c_thread;
int g_phreadNum = 1;
void *func1(void *arg) {
    sem_wait(&semPtr);
    printf("a_thread get a semaphore \n");
    sleep(5);
    sem_post(&semPtr);
    printf("a_thread release semaphore \n");
}
void *func2(void *arg) {
    sem_wait(&semPtr);
    printf("b_thread get a semaphore \n");
    sleep(5);
    sem_post(&semPtr);
    printf("b_thread release semaphore \n");
}
void *func3(void *arg) {
    sem_wait(&semPtr);
    printf("c_thread get a semaphore \n");
    sleep(5);
    sem_post(&semPtr);
    printf("c_thread release semaphore \n");
}
int main() {
    int taskNum;
    // 創(chuàng)建2個(gè)信號(hào)量
    sem_init(&semPtr, 0, MAXNUM);
    //線程1獲取1個(gè)信號(hào)量，5秒后釋放
    pthread_create(&a_thread, NULL, func1, NULL);
    //線程2獲取1個(gè)信號(hào)量，5秒后釋放
    pthread_create(&b_thread, NULL, func2, NULL);
    sleep(1);
    //線程3獲取信號(hào)量，只有線程1或者線程2釋放后，才能獲取到
    pthread_create(&c_thread, NULL, func3, NULL);
    sleep(10);
    //銷毀信號(hào)量
    sem_destroy(&semPtr);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <semaphore.h>
#include <pthread.h>
// 鏈表的節(jié)點(diǎn)
struct Node
{
    int number;
    struct Node* next;
};
// 生產(chǎn)者線程信號(hào)量
sem_t psem;
// 消費(fèi)者線程信號(hào)量
sem_t csem;
// 指向頭結(jié)點(diǎn)的指針
struct Node * head = NULL;
// 生產(chǎn)者的回調(diào)函數(shù)
void* producer(void* arg)
{
    // 一直生產(chǎn)
    while(1)
    {
        // 生產(chǎn)者拿一個(gè)信號(hào)量
        sem_wait(&psem);
		//生產(chǎn)過程
        struct Node* pnew = (struct Node*)malloc(sizeof(struct Node));
        pnew->number = rand() % 1000;
        pnew->next = head;
        head = pnew;
        printf("+++producer, number = %d, tid = %ld\n", pnew->number, pthread_self());
        // 通知消費(fèi)者消費(fèi), 給消費(fèi)者加一個(gè)信號(hào)量
        sem_post(&csem);
        // 生產(chǎn)慢一點(diǎn)
        sleep(rand() % 3);
    }
    return NULL;
}
// 消費(fèi)者的回調(diào)函數(shù)
void* consumer(void* arg)
{
    while(1)
    {
        sem_wait(&csem);
        // 取出鏈表的頭結(jié)點(diǎn), 將其刪除
        struct Node* pnode = head;
        printf("--consumer: number: %d, tid = %ld\n", pnode->number, pthread_self());
        head  = pnode->next;
        free(pnode);
        // 通知生產(chǎn)者生成, 給生產(chǎn)者加信號(hào)燈
        sem_post(&psem);
        sleep(rand() % 3);
    }
    return NULL;
}
int main()
{
    // 初始化信號(hào)量
    // 生產(chǎn)者和消費(fèi)者擁有的信號(hào)燈的總和為1
    sem_init(&psem, 0, 1);  // 生產(chǎn)者線程一共有1個(gè)信號(hào)燈
    sem_init(&csem, 0, 0);  // 消費(fèi)者線程一共有0個(gè)信號(hào)燈
    // 創(chuàng)建5個(gè)生產(chǎn)者, 5個(gè)消費(fèi)者
    pthread_t ptid[5];
    pthread_t ctid[5];
    for(int i=0; i<5; ++i)
    {
        pthread_create(&ptid[i], NULL, producer, NULL);
    }
    for(int i=0; i<5; ++i)
    {
        pthread_create(&ctid[i], NULL, consumer, NULL);
    }
    // 釋放資源
    for(int i=0; i<5; ++i)
    {
        pthread_join(ptid[i], NULL);
    }
    for(int i=0; i<5; ++i)
    {
        pthread_join(ctid[i], NULL);
    }
    sem_destroy(&psem);
    sem_destroy(&csem);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <semaphore.h>
#include <pthread.h>
// 鏈表的節(jié)點(diǎn)
struct Node
{
    int number;
    struct Node* next;
};
// 生產(chǎn)者線程信號(hào)量
sem_t psem;
// 消費(fèi)者線程信號(hào)量
sem_t csem;
// 互斥鎖變量
pthread_mutex_t mutex;
// 指向頭結(jié)點(diǎn)的指針
struct Node * head = NULL;
// 生產(chǎn)者的回調(diào)函數(shù)
void* producer(void* arg)
{
    // 一直生產(chǎn)
    while(1)
    {
        // 生產(chǎn)者拿一個(gè)信號(hào)燈
        sem_wait(&psem);
        // 加鎖, 這句代碼放到 sem_wait()上邊, 有可能會(huì)造成死鎖
        pthread_mutex_lock(&mutex);
        // 創(chuàng)建一個(gè)鏈表的新節(jié)點(diǎn)
        struct Node* pnew = (struct Node*)malloc(sizeof(struct Node));
        // 節(jié)點(diǎn)初始化
        pnew->number = rand() % 1000;
        // 節(jié)點(diǎn)的連接, 添加到鏈表的頭部, 新節(jié)點(diǎn)就新的頭結(jié)點(diǎn)
        pnew->next = head;
        // head指針前移
        head = pnew;
        printf("+++producer, number = %d, tid = %ld\n", pnew->number, pthread_self());
        pthread_mutex_unlock(&mutex);
        // 通知消費(fèi)者消費(fèi)
        sem_post(&csem);
        // 生產(chǎn)慢一點(diǎn)
        sleep(rand() % 3);
    }
    return NULL;
}
// 消費(fèi)者的回調(diào)函數(shù)
void* consumer(void* arg)
{
    while(1)
    {
        sem_wait(&csem);
        pthread_mutex_lock(&mutex);
        struct Node* pnode = head;
        printf("--consumer: number: %d, tid = %ld\n", pnode->number, pthread_self());
        head  = pnode->next;
        // 取出鏈表的頭結(jié)點(diǎn), 將其刪除
        free(pnode);
        pthread_mutex_unlock(&mutex);
        // 通知生產(chǎn)者生成, 給生產(chǎn)者加信號(hào)燈
        sem_post(&psem);
        sleep(rand() % 3);
    }
    return NULL;
}
int main()
{
    // 初始化信號(hào)量
    sem_init(&psem, 0, 5);  // 生成者線程一共有5個(gè)信號(hào)燈
    sem_init(&csem, 0, 0);  // 消費(fèi)者線程一共有0個(gè)信號(hào)燈
    // 初始化互斥鎖
    pthread_mutex_init(&mutex, NULL);
    // 創(chuàng)建5個(gè)生產(chǎn)者, 5個(gè)消費(fèi)者
    pthread_t ptid[5];
    pthread_t ctid[5];
    for(int i=0; i<5; ++i)
    {
        pthread_create(&ptid[i], NULL, producer, NULL);
    }
    for(int i=0; i<5; ++i)
    {
        pthread_create(&ctid[i], NULL, consumer, NULL);
    }
    // 釋放資源
    for(int i=0; i<5; ++i)
    {
        pthread_join(ptid[i], NULL);
    }
    for(int i=0; i<5; ++i)
    {
        pthread_join(ctid[i], NULL);
    }
    sem_destroy(&psem);
    sem_destroy(&csem);
    pthread_mutex_destroy(&mutex);
    return 0;
}