#include <iostream>
#include <stdio.h>
#include <pthread.h>
#include <vector>
#include <string>
#include <unistd.h>
using namespace std;

#define NUM 5                                              // 定义线程数量
int tickets = 100;                                         // 全局共享变量：票数（多个线程将同时访问这个变量，临界资源）

class thread_data
{
public:
    thread_data(int number)                                // 构造函数：根据线程编号初始化线程名称
    {
        thread_name = "线程" + to_string(number);
    }
public:
    string thread_name;                                    // 线程名称
};

void* getticket(void* arg)
{
    thread_data* data = static_cast<thread_data*>(arg);    // 将传入的参数转换为 threadData 类型指针
    const char* name = data->thread_name.c_str();          // 获取线程名称

    while(true)                                            // 无限循环买票，竞态条件发生在这里！
    {
        if(tickets > 0)                                    // 票数大于 0 时，买票
        {
            usleep(1000);                                  // 模拟票务系统延时

            printf("%s 获得 1 张票，剩余 %d 张票\n", name, tickets);    // 打印票数信息
            tickets--;                                     // 票数减 1
        }
        else                                               // 票数不足时，跳出循环
        {
            break;
        }
    }

    cout << "线程" << name << "执行结束！" << endl;
    return nullptr;
}

int main()
{
    vector<pthread_t> tids;                                // 存储线程 ID 的向量容器
    vector<thread_data*> thread_datas;                     // 存储线程数据的向量容器

    cout << "多线程买票演示程序" << endl;
    cout << "总票数: " << tickets << " 张" << endl;
    cout << "创建 " << NUM << " 个线程同时买票..." << endl << endl;

    for(int i = 0; i < NUM; i++)
    {
        pthread_t tid;                                      // 线程 ID 变量
        thread_data* data = new thread_data(i);             // 为每个线程创建独立的数据对象
        thread_datas.push_back(data);                       // 保存数据对象指针

        pthread_create(&tid, nullptr, getticket, data);     // 创建线程，传入参数为线程数据对象指针
        tids.push_back(tid);                                // 保存线程 ID
    }

    cout << "所有线程创建完成，开始并发买票..." << endl;
    sleep(3);                                               // 等待 3 秒，让主进程等待子进程结束

    for(auto data : thread_datas)
    {
        delete data;                                        // 释放每个线程的数据对象
    }

    return 0;
}

#include <iostream>
#include <stdio.h>
#include <pthread.h>
#include <vector>
#include <string>
#include <unistd.h>
using namespace std;

#define NUM 5                                              // 定义线程数量
int tickets = 10000;                                       // 全局共享变量：票数（多个线程将同时访问这个变量）
pthread_mutex_t ticket_mutex = PTHREAD_MUTEX_INITIALIZER;  // 互斥锁（全局）

class thread_data
{
public:
    thread_data(int number)                                // 构造函数：根据线程编号初始化线程名称
    {
        thread_name = "线程" + to_string(number);
    }
public:
    string thread_name;                                    // 线程名称
};

void* getticket(void* arg)
{
    thread_data* data = static_cast<thread_data*>(arg);    // 将传入的参数转换为 threadData 类型指针
    const char* name = data->thread_name.c_str();          // 获取线程名称

    while(true)                                            // 无限循环买票，竞态条件发生在这里！
    {
        pthread_mutex_lock(&ticket_mutex);                 // 加锁，进入临界区

        if(tickets > 0)                                    // 票数大于 0 时，买票
        {
            usleep(1000);                                  // 模拟票务系统延时

            printf("%s 获得 1 张票，剩余 %d 张票\n", name, tickets);    // 打印票数信息
            tickets--;                                     // 票数减 1
        }
        else                                               // 票数不足时，跳出循环
        {
            pthread_mutex_unlock(&ticket_mutex);           // 解锁，防止死锁
            break;
        }

        pthread_mutex_unlock(&ticket_mutex);               // 解锁，退出临界区
    }

    cout << data->thread_name << "执行结束！" << endl;
    return nullptr;
}

int main()
{
    vector<pthread_t> tids;                                // 存储线程 ID 的向量容器
    vector<thread_data*> thread_datas;                     // 存储线程数据的向量容器

    cout << "多线程买票演示程序" << endl;
    cout << "总票数: " << tickets << " 张" << endl;
    cout << "创建 " << NUM << " 个线程同时买票..." << endl << endl;

    for(int i = 0; i < NUM; i++)
    {
        pthread_t tid;                                      // 线程 ID 变量
        thread_data* data = new thread_data(i);             // 为每个线程创建独立的数据对象
        thread_datas.push_back(data);                       // 保存数据对象指针

        pthread_create(&tid, nullptr, getticket, data);     // 创建线程，传入参数为线程数据对象指针
        tids.push_back(tid);                                // 保存线程 ID
    }

    cout << "所有线程创建完成，开始并发买票..." << endl;

    for (int i = 0; i < NUM; ++i)
    {
        pthread_join(tids[i], nullptr);                     // 等待第 i 个线程执行完毕
    }

    for(auto data : thread_datas)
    {
        delete data;                                        // 释放每个线程的数据对象
    }

    return 0;
}

#include <iostream>
#include <stdio.h>
#include <pthread.h>
#include <vector>
#include <string>
#include <unistd.h>
using namespace std;

#define NUM 5                                              // 定义线程数量
int tickets = 10000;                                       // 全局共享变量：票数
pthread_mutex_t ticket_mutex;                              // 动态互斥锁（全局）

class thread_data
{
public:
    thread_data(int number)                                // 构造函数
    {
        thread_name = "线程" + to_string(number);
    }
public:
    string thread_name;                                    // 线程名称
};

void* getticket(void* arg)
{
    thread_data* data = static_cast<thread_data*>(arg);
    const char* name = data->thread_name.c_str();

    while(true)
    {
        pthread_mutex_lock(&ticket_mutex);                 // 加锁

        if(tickets > 0)
        {
            usleep(1000);                                  // 模拟延时
            
            // 为了减少输出量，只显示关键信息
            if(tickets % 1000 == 0 || tickets <= 10)       // 每 1000 张票或最后 10 张票时显示
            {
                printf("%s 获得 1 张票，剩余 %d 张票\n", name, tickets);
            }
            
            tickets--;
        }
        else
        {
            pthread_mutex_unlock(&ticket_mutex);           // 解锁防止死锁
            break;
        }

        pthread_mutex_unlock(&ticket_mutex);               // 解锁
    }

    cout << data->thread_name << "执行结束！" << endl;
    return nullptr;
}

int main()
{
    // 初始化动态互斥锁（不使用属性）
    if(pthread_mutex_init(&ticket_mutex, nullptr) != 0)
    {
        cerr << "互斥锁初始化失败！" << endl;
        return -1;
    }

    vector<pthread_t> tids;
    vector<thread_data*> thread_datas;

    cout << "多线程买票演示程序" << endl;
    cout << "总票数: " << tickets << " 张" << endl;
    cout << "创建 " << NUM << " 个线程同时买票..." << endl << endl;

    for(int i = 0; i < NUM; i++)
    {
        pthread_t tid;
        thread_data* data = new thread_data(i);
        thread_datas.push_back(data);

        if(pthread_create(&tid, nullptr, getticket, data) != 0)
        {
            cerr << "线程创建失败：" << i << endl;
            delete data;
            continue;
        }
        
        tids.push_back(tid);
    }

    cout << "所有线程创建完成，开始并发买票..." << endl;

    // 等待所有线程执行完毕
    for (size_t i = 0; i < tids.size(); ++i)
    {
        if(pthread_join(tids[i], nullptr) != 0)
        {
            cerr << "等待线程 " << i << " 失败！" << endl;
        }
    }

    cout << "\n最终剩余票数: " << tickets << " 张" << endl;
    cout << "买票结束！" << endl;

    // 释放线程数据内存
    for(auto data : thread_datas)
    {
        delete data;
    }

    // 销毁互斥锁
    pthread_mutex_destroy(&ticket_mutex);

    return 0;
}

#include <iostream>
#include <pthread.h>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
using namespace std;

// uint64_t: 64 位无符号整数类型，用于确保能存储 64 位的线程 ID 或大数值
// uintptr_t: 足够大以容纳指针值的无符号整数类型，用于安全的指针到整数转换

int cnt = 0;                                            // 临界资源，全局计数器，多个线程共享访问
int tid_cnt = 5;                                        // 线程数量
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;      // 互斥锁，保护临界资源的访问，防止数据竞争
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;         // 条件变量，用于线程间通信，控制线程的等待和唤醒

void* Count(void* arg)
{
    pthread_detach(pthread_self());                     // 分离线程，这样线程结束时会自动回收资源
    uint64_t number = (uint64_t)(uintptr_t)arg;         // 修复指针到整数的转换警告，两次类型转换确保安全
    cout << "[创建]线程" << number << "创建成功！" << endl;

    while(true)
    {
        // 1. 加锁进入临界区
        pthread_mutex_lock(&mutex);                     // 加锁
        cout << "[等待]线程" << number << "获取锁，准备等待信号！" << endl;

        // 这里隐含了一个判断："是否收到了主线程的信号？"
        // 如果没有收到信号，临界资源状态就是 "不就绪"，所以线程选择等待

        // 2. 等待条件满足
        cout << "[阻塞]线程" << number << "调用pthread_cond_wait，即将释放锁并进入等待！" << endl;
        pthread_cond_wait(&cond, &mutex);               // 等待信号（临界资源就绪）
        // pthread_cond_wait 的内部工作原理：
        // a. 释放 mutex 锁（让其他线程可以获取锁）
        // b. 将当前线程加入等待队列并阻塞
        // c. 等待被 pthread_cond_signal 或 pthread_cond_broadcast 唤醒
        // d. 被唤醒后自动重新获取 mutex 锁
        // e. 返回（此时线程重新持有锁）

        cout << "[唤醒]线程" << number << "被唤醒并重新获得锁！开始处理任务！" << endl;

        // 3. 被唤醒后执行的代码，此时已经重新获得了锁，可以安全地访问临界资源 cnt
        cout << "[执行]线程" << number << "收到信号，执行任务！cnt = " << cnt++ << endl;

        // 4. 解锁 - 离开临界区
        pthread_mutex_unlock(&mutex);
        cout << "[完成]线程" << number << "释放锁，任务完成，重新进入等待循环中！" << endl;
    }

    pthread_exit(nullptr);                              // 线程结束，释放资源（显式）
    // return nullptr;                                  // 线程结束，释放资源（隐式）
}

void Demo_cond_init()                                   // 这个函数没有实际意义，只是为了演示条件变量的初始化
{
    pthread_cond_t cond1;

    // 方式 1: 静态初始化（推荐用于全局变量）
    // pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

    // 方式 2: 动态初始化（推荐用于局部变量）
    int result = pthread_cond_init(&cond1, nullptr);
    if (result != 0)
    {
        cerr << "初始化条件变量失败！" << strerror(result) << endl;     // cerr: 标准错误输出流，用于输出错误信息
    }

    pthread_cond_destroy(&cond1);                      // 使用完后需要销毁
}

int main()
{
    Demo_cond_init();

    for(uint64_t i = 0; i < tid_cnt; i++)
    {
        pthread_t tid;
        int result = pthread_create(&tid, nullptr, Count, (void*)(uintptr_t)i);
        if(result != 0)
        {
            cerr << "创建线程失败！" << strerror(result) << endl;
        }

        usleep(1000);
    }

    sleep(3);                                           // 等待所有线程进入等待状态
    cout << "主线程控制开始！" << endl;
    cout << "控制规则：每1秒唤醒一个线程，每3秒唤醒全部线程！" << endl;

    int count = 0;
    // while(count < 自定义 value)                        // 限制循环次数，避免无限运行
    while(true)
    {
        sleep(1);
        count++;

        if (count % 3 == 0)
        {
            // 使用 pthread_cond_broadcast 唤醒所有等待的线程
            cout << "[广播]唤醒所有线程！" << endl;
            pthread_cond_broadcast(&cond);
        }
        else
        {
            // 使用 pthread_cond_signal 唤醒一个等待的线程
            cout << "[单播]唤醒一个线程！" << endl;
            pthread_cond_signal(&cond);
        }

        cout << "信号已经发出！count = " << count << endl;

        // 显示当前计数器值
        pthread_mutex_lock(&mutex);
        cout << "当前计数值：" << cnt << endl;
        pthread_mutex_unlock(&mutex);
    }

    cout << "主线程结束！" << endl << "最终计数值：" << cnt << endl;

    return 0;
}