#include <stdio.h>
#include <pthread.h>
int counter = 0;
void* increment(void* arg) {
    for (int i = 0; i < 100000; i++) {
        counter++; // 非原子操作}
    return NULL;}
int main() {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, increment, NULL);
    pthread_create(&t2, NULL, increment, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    // 理論結果為：200000
    printf("Final counter: %d\n", counter); // 實際輸出通常小于200000
    return 0;
}

// 初始化（靜態(tài)）
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
// 初始化（動態(tài)）
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
// 加鎖/解鎖
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
// 銷毀
int pthread_mutex_destroy(pthread_mutex_t *mutex);

#pragma once

#include <iostream>
#include <string>
#include <pthread.h>
#include <cassert>

// 參數(shù)、返回值為 void 的函數(shù)類型
typedef void *(*func_t)(void *);
const int num = 1024;
class Thread
{
public:
    Thread(func_t func, void *args = nullptr, int number = 0)
        : _func(func), _args(args)
    {
        // 根據(jù)編號寫入名字
        char buf[128];
        snprintf(buf, sizeof buf, "thread-%d", num);
        _name = buf;
        int n = pthread_create(&_tid, nullptr, runHelper, this); // this->Thread*
        assert(n == 0);
        (void)n;
    }
    // 回調方法
    static void *runHelper(void *args)
    {
        Thread *_this = static_cast<Thread *>(args);
        return _this->callback();
    }
    // 獲取 ID
    pthread_t getTID() const
    {
        return _tid;
    }
    // 獲取線程名
    std::string getName() const
    {
        return _name;
    }
    // 啟動線程
    void run()
    {
        int ret = pthread_create(&_tid, nullptr, runHelper, this );//this 是一個指向當前類類型的常量指針
        if (ret != 0)
        {
            std::cerr << "create thread fail!" << std::endl;
            exit(1); // 創(chuàng)建線程失敗，直接退出
        }
    }
    // 線程等待
    void join()
    {
        int ret = pthread_join(_tid, nullptr);
        if (ret != 0)
        {
            std::cerr << "thread join fail!" << std::endl;
            exit(1); // 等待失敗，直接退出
        }
    }
    void *callback()
    { // 亦指在外調用的線程處理函數(shù)，_args與是否返回值有關
        return _func(_args);
    }

private:
    pthread_t _tid;    // 線程 ID
    std::string _name; // 線程名
    func_t _func;      // 線程回調函數(shù)
    void *_args;       // 傳遞給回調函數(shù)的參數(shù)
};

#include "thread.hpp"
// 1：線程創(chuàng)建和運行
void *basic_task(void *arg){
    int *val = static_cast<int *>(arg);
    std::cout << "線程正在運行，初始值為: " << *val << std::endl;
    *val *= 2; // 修改傳入的值
    return nullptr;}
// 2：帶返回值
void *task_with_return(void *arg){
    std::string *msg = new std::string("Hello！");
    return msg;}
int main(){{
        int value = 42;
        Thread t1(basic_task, &value);
        t1.join();
        std::cout << "修改后旳值為: " << value << std::endl; // 應該輸出84}
    std::cout << "---------------: " << std::endl;{
        Thread t2(task_with_return);
        void *ret_val = nullptr;
        pthread_join(t2.getTID(), &ret_val); // 直接使用pthread_join獲取返回值
        if (ret_val){
            std::string *msg = static_cast<std::string *>(ret_val);
            std::cout << *msg << std::endl; // 輸出線程返回的消息
            delete msg;                     // 記得釋放內存
        }}  return 0;}

#pragma once
#include <iostream>
#include <pthread.h>
class Mutex
{
public:
    Mutex(const Mutex &) = delete;
    const Mutex &operator=(const Mutex &) = delete;
    Mutex(){
        int n = pthread_mutex_init(&_lock, nullptr);
    }
    void Lock(){
        int n = pthread_mutex_lock(&_lock);
    }
    void Unlock(){
        int n = pthread_mutex_unlock(&_lock);
    }
    pthread_mutex_t *LockPtr() { return &_lock; }
    ~Mutex(){
        int n = pthread_mutex_destroy(&_lock);
    }

private:
    pthread_mutex_t _lock;
};
class LockGuard{
public:
    LockGuard(Mutex &mutex)
        : _mutex(mutex){
        _mutex.Lock();
    }
    ~LockGuard(){
        _mutex.Unlock();
    }
private:
    Mutex &_mutex; // 在該類下面定義了一個Mutex類型的引用成員變量，_mutex為變量名
};

// 初始化
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

// 等待條件滿足（自動釋放關聯(lián)互斥鎖）
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

// 通知條件
int pthread_cond_signal(pthread_cond_t *cond);      // 喚醒一個線程
int pthread_cond_broadcast(pthread_cond_t *cond);   // 廣播。。喚醒所有線程

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

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;//靜態(tài)初始化
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int data_ready = 0;  // 共享條件

void* consumer(void* arg) {
    pthread_mutex_lock(&mutex);
    while (data_ready == 0) {
        printf("Consumer: Waiting...\n");
        pthread_cond_wait(&cond, &mutex); // 阻塞并釋放鎖
    }
    printf("Consumer: Processing data.\n");
    data_ready = 0;
    pthread_mutex_unlock(&mutex);
    return NULL;
}

void* producer(void* arg) {
    sleep(1); // 模擬數(shù)據(jù)準備時間
    pthread_mutex_lock(&mutex);
    printf("Producer: Data ready.\n");
    data_ready = 1;
    pthread_cond_signal(&cond); // 喚醒消費者
    pthread_mutex_unlock(&mutex);
    return NULL;
}

int main() {
    pthread_t tid1, tid2;
    pthread_create(&tid1, NULL, consumer, NULL);
    pthread_create(&tid2, NULL, producer, NULL);
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    return 0;
}