#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); //為啥這里一定要睡一會兒？
    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ù)運行
    printf("Main thread is exiting.\n");
    pthread_exit(NULL);
    return 0; // 這行代碼不會執(zhí)行，因為主線程已經退出
}

#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");
    // 模擬計算
    *data = 42;
    pthread_exit(data); // 子線程結束，并返回數據指針
}
int main() {
    pthread_t tid;
    int result;
    // 分配內存用于存儲子線程的結果，該數據位于堆上
    int* data = (int*)malloc(sizeof(int));
    // 創(chuàng)建子線程
    pthread_create(&tid, NULL, child_thread, data);
	//主線程在干自己的任務，把修改data數據的任務交給了子線程
    // 等待子線程結束，并獲取返回狀態(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>
// 這是一個阻塞函數, 子線程在運行這個函數就阻塞
// 子線程退出, 函數解除阻塞, 回收對應的子線程資源, 類似于回收進程使用的函數 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"); // 在堆上分配內存
    pthread_exit((void*)str); // 返回指向堆上字符串的指針
}
int main() {
    pthread_t tid;
    // 創(chuàng)建子線程
    pthread_create(&tid, NULL, child_thread, NULL);
    void* ptr = nullptr;
    //主線程執(zhí)行自己的業(yè)務邏輯，把寫一個hello world字符串的任務交給子線程
    // 等待子線程結束，并獲取返回狀態(tài)
    pthread_join(tid, &ptr);
    // 將void*指針轉換為std::string*指針，并打印字符串
    std::string* str_ptr = static_cast<std::string*>(ptr);
    std::cout << *str_ptr << std::endl;
    // 釋放堆上分配的內存
    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>
// 定義一個互斥鎖
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
// 共享數據
int shared_data = 0;
// 線程函數
void* thread_function(void* arg) {
    // 鎖定互斥鎖
    pthread_mutex_lock(&mutex);
    // 對共享數據進行操作
    shared_data++;
    // 打印共享數據
    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)建兩個線程
    pthread_create(&tid1, NULL, thread_function, NULL);
    pthread_create(&tid2, NULL, thread_function, NULL);
    // 等待線程結束
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    // 銷毀互斥鎖
    pthread_mutex_destroy(&mutex);
    return 0;
}

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
// 定義一個讀寫鎖
pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;
// 共享數據
int shared_data = 0;
// 讀取共享數據的線程函數
void* reader(void* arg) {
    (void)arg; // 未使用的參數
    // 讀取鎖
    pthread_rwlock_rdlock(&rwlock);
    printf("Reader: shared_data = %d\n", shared_data);
    // 釋放讀取鎖
    pthread_rwlock_unlock(&rwlock);
    return NULL;
}
// 寫入共享數據的線程函數
void* writer(void* arg) {
    (void)arg; // 未使用的參數
    // 寫入鎖
    pthread_rwlock_wrlock(&rwlock);
    // 修改共享數據
    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)建另一個讀者線程
    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;
//初始化
//第一個傳參&cond
//第二個參數為條件變量屬性，一般使用默認屬性，指定為NULL
int pthread_cond_init(pthread_cond_t *cond, NULL) 
//釋放資源
int pthread_cond_destroy(pthread_cond_t *cond);
//線程阻塞函數：它的工作流程如下
//1. 釋放與條件變量cond關聯的互斥鎖mutex
//2. 之后，調用線程會被阻塞，并從運行狀態(tài)中移除，進入等待條件變量的狀態(tài)。
//3. 直到另一個線程執(zhí)行了對應的 pthread_cond_signal 或 pthread_cond_broadcast 操作來喚醒它
//4. 被喚醒后重新獲取互斥鎖
//5.解除阻塞
int pthread_cond_wait(pthread_cond_t *restrict cond
	, pthread_mutex_t *restrict mutex);
//有超時時間的線程阻塞函數，時間到達之后，解除阻塞
int pthread_cond_timedwait(pthread_cond_t *restrict cond
	, pthread_mutex_t *restrict mutex
	, const struct timespec *restrict abstime);
// 喚醒阻塞在條件變量上的線程, 至少有一個被解除阻塞
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é)點
struct Node
{
    int number;
    struct Node* next;
};
// 定義條件變量, 控制消費者線程
pthread_cond_t cond;
// 互斥鎖變量
pthread_mutex_t mutex;
// 指向頭結點的指針
struct Node * head = NULL;
void* producer(void *arg) {
    while(1) {
        //模擬生產時間
        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);
        //生產了任務，通知消費者消費
        pthread_cond_broadcast(&cond);
    }
    return nullptr;
}
void* consumer(void *arg) {
    while(1) {
        pthread_mutex_lock(&mutex);
        while(head == nullptr) {
            pthread_cond_wait(&cond, &mutex);
        }
        //消費過程
        Node* pnode = head;
        printf("consumer, number = %d, tid = %ld\n"
            , pnode->number
            , pthread_self());
        head = pnode->next;
        free(pnode);
        pthread_mutex_unlock(&mutex);
        //模擬消費時間
        sleep(rand() % 3);
    }
    return nullptr;
}
int main()
{
    pthread_cond_init(&cond, nullptr);
    pthread_mutex_init(&mutex, nullptr);
    //創(chuàng)建5個生產者，5個消費者
    pthread_t ptid[5];
    pthread_t ctid[5];
    //啟動線程
    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);
}