线程

// 代码段1：
void thread_func()
{
    int global_g = 1; 	// mov     DWORD PTR [rbp-4], 1
    global_g++;			// add     DWORD PTR [rbp-4], 1
    return;
}
// 代码1中 global_g 是局部变量，因此会往栈中压入1，然后再执行+1操作

// 代码段2：
int global_g = 1;
void thread_func()
{
    global_g++; // mov     eax, DWORD PTR global_g[rip]
                // add     eax, 1
                // mov     DWORD PTR global_g[rip], eax
    return;
}
// 代码2中 global_g 是全局变量，因此是从rip存储的指令地址（指向的是全局变量存储区，地址是在编译之后就固定的）中获取到变量，然后+1之后，再写回

// 代码段3：
thread_local int global_g = 1;
void thread_func()
{
    global_g++; // mov     eax, DWORD PTR fs:global_g@tpoff
                // add     eax, 1
                // mov     DWORD PTR fs:global_g@tpoff, eax
    return;
}
// 代码3中 global_g 是根据 FS 寄存器指向的地址再加上一定的偏移量获取到的

struct task_struct {
    //... 忽略代码
    struct thread_struct		thread;
};

struct thread_struct {
	/* Cached TLS descriptors: */
	struct desc_struct	tls_array[GDT_ENTRY_TLS_ENTRIES];
    //... 忽略代码
};

/*
 * The layout of the per-CPU GDT under Linux:
 // ..... 忽略
 *  ------- start of TLS (Thread-Local Storage) segments:
 *
 *   6 - TLS segment #1			[ glibc's TLS segment ] // glibc用这个段存储TLS，fs寄存器指向的就是这个段
 *   7 - TLS segment #2			[ Wine's %fs Win32 segment ]
 *   8 - TLS segment #3							<=== cacheline #3
 // .... 忽略
*/

/*
 * Set a given TLS descriptor:
 */
int do_set_thread_area(struct task_struct *p, int idx,
		       struct user_desc __user *u_info,
		       int can_allocate)
{
    // .... 忽略代码
	set_tls_desc(p, idx, &info, 1);
    // .... 忽略代码
}

static void set_tls_desc(struct task_struct *p, int idx,
			 const struct user_desc *info, int n)
{
	struct thread_struct *t = &p->thread;
	struct desc_struct *desc = &t->tls_array[idx - GDT_ENTRY_TLS_MIN];
	int cpu;

	/*
	 * We must not get preempted while modifying the TLS.
	 */
	cpu = get_cpu();

	while (n-- > 0) {
		if (LDT_empty(info) || LDT_zero(info))
			memset(desc, 0, sizeof(*desc));
		else
			fill_ldt(desc, info);
		++info;
		++desc;
	}

	if (t == &current->thread)
		load_TLS(t, cpu); // 将TLS内容载入到CPU中

	put_cpu();
}

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);

// linux 平台的底层线程函数
// g++ thread_test.cpp -o thread_test -lpthread
#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
#include <iostream>
void threadfunc(void* args)
{
    while(1)
    {
        sleep(1);
        std::cout << "Linux thread func" << std::endl;
        break;
    }
    return NULL;
}

int main()
{
    pthread_t threadid;
    pthread_create(&threadid, NULL, threadfunc, NULL);
    pthread_join(threadid, NULL);
    return 0;
}

#include <stdio.h>
#include <thread>
#include <iostream>
void threadproc1()
{
    std::cout << "C++ std::thread 1" << std::endl;
}

void threadproc2(int a, int b)
{
    std::cout << "C++ std::thread 2" << std::endl;
}

int main()
{
    std::thread t1(threadproc1); // 这里是普通函数，因此直接使用函数名即可，函数名就是函数指针，如果是类的成员函数那么要用&A::func
    std::thread t2(threadproc2, 1, 2); 
    t1.join(); // 主线程执行到这里会阻塞，直到t1线程执行完毕，注意此时t2是已经在运行的了！！！
    t2.join(); // 主线程执行到这里会阻塞，直到t2线程执行完毕，这样就可以保证main线程退出时t1和t2线程都已经执行完毕
    return 0;
}

void start_fun()
{
    for (int i = 0; i < 5; ++i)
    {
        std::thread t(threadproc1);
        t.join();
    }
}

void start_fun()
{
    std::vector<std::thread> threads;
    for (int i = 0; i < 5; ++i)
    {
        threads.emplace_back(std::thread(threadproc1));
    }
    for (int i = 0; i < 5; ++i)
    {
        threads[i].join();
    }
}

void start_fun()
{
    for (int i = 0; i < 5; ++i)
    {
        std::thread t(threadproc1); // 没有传递局部变量，因此这样写没问题
        t.detach();
    }
}

void start_fun()
{
    for (int i = 0; i < 5; ++i)
    {
        std::thread t(threadproc1, i); // 传递了局部变量，会造成异常！
        t.detach();
    }
}

#include <sys/syscall.h>
#include <unistd.h>
#include <stdio.h>
#include <pthread.h>
void* thread_proc(void* args)
{
    pthread_t* tid1 = (pthread_t*) args; // 输出指向线程的内存地址，不是全系统唯一的，因为可能不同进程共享了同一块内存。同个进程中调用这种方式没有问题，但是不同进程就可能得到相同的输出
    int tid2 = syscall(SYS_gettid); // 全系统唯一，是LWP的ID（轻量级进程，早期linux系统的线程是通过进程实现的），getpid是获取线程所属进程的pid，要获取线程的唯一id就必须要通过这个方法，实际获取的是线程对应task_struct的pid。
    pthread_t tid3 = pthread_self(); // 输出指向线程的内存地址，不是全系统唯一的，因为可能不同进程共享了同一块内存
    pid_t pid = getpid(); // 这里得到的是当前线程所归属的进程的pid，与主线程的pid1一致
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, NULL, thread_proc, &tid);
    pthread_join(tid, NULL);
    pid_t pid1 = getpid();
    int tid2 = syscall(SYS_gettid); // 由于主线程实际就是当前进程，因此此处的tid2与pid1是一致的。
    return 0;
}

void* threadFunc(void* arg);

void* threadFunc(Obj* this, void* arg);

class Thread
{
public:
    Thread(){}
    ~Thread(){}
    void Start()
    {
        m_stopped = false;
        m_spThread.reset(new std::thread(&Thread::threadFunc, this, 1, 2)); // 注意, 这是类成员函数指针，因此需要使用&Thread::threadFunc
    }
    void Stop()
    {
        m_stopped = true;
        if (m_spThread)
        {
            if (m_spThread->joinable())
            {
                m_spThread->join();
            }
        }
    }

private:
    void threadFunc(int arg1, int arg2)
    {
        while (!m_stopped)
        {
            std::cout << "Thread function use instance method." << std::endl;
        }
    }
    std::shared_ptr<std::thread> m_spThread;
    bool m_stopped;
};

int main()
{
    Thread myThread;
    myThread.Start();
}

#include <pthread.h>
// 方式1
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER; // 默认属性，这种方式不需要手动销毁

// 方式2
int pthread_mutex_init(pthread_mutex_t* restrict mutex, const pthread_mutexattr_t* restrict attr); // 可以指定属性，一般属性直接使用 NULL 即可，即默认属性
// restrict 是C的一个关键字，用以修饰后面的指针是指向的变量在本作用域中的唯一指向，当然这只是建议而已~
// 与 restrict 相似的还有 register 关键字，修饰的是变量，建议可以直接从寄存器读取

int pthread_mutexattr_init(pthread_mutexattr_t* attr); // 创建属性对象
int pthread_mutexattr_destory(pthread_mutexattr_t* attr); // 当设置属性之后需要进行销毁
int pthread_mutexattr_settype(pthread_mutexattr_t* attr, int type); // 设置属性
int pthread_mutexattr_gettype(const pthread_mutexattr_t* restrict attr, int* restrict type); // 获取属性

int pthread_mutex_destory(pthread_mutex_t* mutex); // 执行成功会返回0

int pthread_mutex_lock(pthread_mutex_t* mutex); // 尝试加锁，如果失败会一直阻塞
int pthread_mutex_trylock(pthread_mutex_t* mutex); // 尝试加锁，如果失败会立即放回
int pthread_mutex_unlock(pthread_mutex_t* mutex);

// 加锁成功后返回0

#include <pthread.h>
#include <stdio.h>
#include <errno.h>
#include <iostream>
#include <unistd.h>

pthread_mutex_t mymutex;

void* thread_fun(void* args)
{
    pthread_mutex_lock(&mymutex);
    pthread_t* threadID = (pthread_t*) args;
    std::cout << threadID << ": thread running" << std::endl;
    sleep(3);
    
    // 尝试销毁被锁定的mutex对象
    int  ret = pthread_mutex_destroy(&mymutex);
    if (ret != 0)
    {
        if (ret == EBUSY)
        {
            std::cout << "EBUSY" << std::endl;
            std::cout << "Failed to destory mutex." << std::endl;
        }
    }
    pthread_mutex_unlock(&mymutex);
    return NULL;
}

int main()
{
    pthread_mutex_init(&mymutex, NULL); // 一般不用检查初始化结果
    pthread_t threadID1, threadID2, threadID3;
    pthread_create(&threadID1, NULL, thread_fun, &threadID1);
    pthread_create(&threadID2, NULL, thread_fun, &threadID2);
    pthread_create(&threadID3, NULL, thread_fun, &threadID3);
    pthread_join(threadID1, NULL);
    pthread_join(threadID2, NULL);
    pthread_join(threadID3, NULL);
    // 尝试销毁已经解锁的mutex对象
    int ret = pthread_mutex_destroy(&mymutex);
    if (ret == 0)
    {
        std::cout << "Successed to destory mutex." << std::endl;
    }
    return 0;
}

#include <semaphore.h>
int sem_init(sem_t* sem, int pshared, unsigned int value); 
// pshared代表的是是否可以被不同进程共享，0否，非0是
// value代表初始时的资源量

int sem_destory(sem_t* sem);

int sem_post(sem_t* sem);
// 使信号量的资源数+1,且唤醒所有因sem_wait函数被阻塞的其他线程都会被唤醒

int sem_wait(sem_t* sem);
// 当信号量为0时会阻塞，当信号量大于0时会被唤醒，唤醒后会把资源计数-1,然后立即返回执行后面的操作

int sem_trywait(sem_t* sem);
// 当信号量为0时会立即返回，返回值是-1,错误码errno == EAGAIN

int sem_timedwait(sem_t* sem, const struct timespec* abs_timeout);
// 带有等待时间的等待，超时后返回-1,错误码 errno == ETIMEDOUT


// 三个wait函数都会被系统中断，会立即返回，返回值-1,错误码 errno == EINTR

struct timespec
{
    time_t tv_sec; // 秒
    long tv_nsec; // 纳秒
}
// 注意temespec是绝对时间

#include <pthread.h>
#include <errno.h>
#include <unistd.h>
#include <list>
#include <semaphore.h>
#include <iostream>

class Task
{
public:
    Task(int myTaskID): taskID(myTaskID){}

    void doTask()
    {
        std::cout << "handle a task, taskID: " << taskID << ", threadID: " << pthread_self() << std::endl;
    }

private:
    int taskID;
};

pthread_mutex_t mymutex;
std::list<Task*> tasks;
sem_t mysemapthore;

void* consumer_thread(void* param)
{
    Task* pTask = NULL;
    while (true)
    {
        if (sem_wait(&mysemapthore) != 0) // 本身方法是阻塞的，但是有可能会被系统中断，因此需要判断是否为0，且外层使用loop循环尝试
            continue;
        if (tasks.empty())
            continue;

        pthread_mutex_lock(&mymutex);
        pTask = tasks.front();
        tasks.pop_front();
        pthread_mutex_unlock(&mymutex);

        pTask->doTask();
        delete pTask;
    }
    return NULL;
}

void* producer_thread(void* param)
{
    int taskID = 0;
    Task* pTask = NULL;

    while (true)
    {
        pthread_mutex_lock(&mymutex);
        pTask = new Task(taskID);
        tasks.push_back(pTask);
        std::cout << "produce a task, taskID: " << taskID << ", threadID: " << pthread_self() << std::endl;
        pthread_mutex_unlock(&mymutex);

        // 释放信号量，通知消费者
        sem_post(&mysemapthore);
        taskID++;
        sleep(1);
    }
    return NULL;
}

int main()
{
    pthread_mutex_init(&mymutex, NULL); // 用以保证tasks列表操作的安全性
    sem_init(&mysemapthore, 0, 0);

    // 五个消费线程
    pthread_t consumerThreadID[5];
    for (int i = 0; i < 5; i++)
        pthread_create(&consumerThreadID[i], NULL, consumer_thread, NULL);

    // 一个生产者线程
    pthread_t producerThreadID;
    pthread_create(&producerThreadID, NULL, producer_thread, NULL);

    pthread_join(producerThreadID, NULL);

    for (int i = 0; i < 5; ++i)
        pthread_join(consumerThreadID[i], NULL);

    sem_destroy(&mysemapthore);
    pthread_mutex_destroy(&mymutex);

    return 0;
}

int pthread_cond_init(pthread_cond_t* cond, const pthread_condattr_t* attr);
// 或者：
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

int pthread_cond_destory(pthread_cond_t* cond);

int pthread_cond_wait(pthread_cond_t* restrict cond, pthread_mutex_t* restrict mutex);
int pthread_cond_timewait(pthread_cond_t* restrict cond, pthred_mutex_t* restrict mutex, const struct timespec* restrict abstime);
// 条件变量的方法需要同时传入互斥体，因为信号变量必须在信号发出时，线程已经有调用wait操作，因此需要把wait和互斥体的unlock变成一个原子操作。否则可能出现互斥体刚unlock，然后失去了时间片，而另外的线程发出信号，切换回本线程之后已经失去了信号了，造成永久阻塞
// 当条件未满足时，线程会一直等待
// 注意temespec是绝对时间

int pthread_cond_signal(pthread_cond_t* cond);  // 一次唤醒一个线程
int pthread_cond_broadcast(pthread_cond_t* cond); // 同时唤醒所有的线程

// threadA
pthread_mutex_lock(&mutex);
while (!ready) // 这里的条件判断和pthread_cond_wait通过mutex形成了原子性语句
    pthread_cond_wait(&cond, &mutex);
pthread_mutex_unlocK(&mutex);

// threadB
pthread_mutex_lock(&mutex);
ready = true;
pthread_mutex_unlock(&mutex);
pthread_cond_signal(&cond);

#include <pthread.h>
#include <errno.h>
#include <unistd.h>
#include <list>
#include <semaphore.h>
#include <iostream>

class Task
{
public:
    Task(int myTaskID): taskID(myTaskID){}

    void doTask()
    {
        std::cout << "handle a task, taskID: " << taskID << ", threadID: " << pthread_self() << std::endl;
    }

private:
    int taskID;
};

pthread_mutex_t mymutex;
std::list<Task*> tasks;
pthread_cond_t mycv;

void* consumer_thread(void* param)
{
    Task* pTask = NULL;
    while (true)
    {
        pthread_mutex_lock(&mymutex);

        // 这里使用while的原因是可能会被虚假唤醒，因此当wait被唤醒之后，还需要判断tasks是否为空
        while (tasks.empty())
            // 如果获得了互斥锁，但是条件不合适，则pthread_cond_wait 会释放锁，不往下执行，所以在这语句之前有lock的操作
            // 发生变化后，如果条件合适，则pthread_cond_wait会阻塞到获得锁，可能此时有多个线程都进入到这里，在 wait 条件的达成，而且 post 可能会同时唤醒所有线程，但是这些线程只会有一个线程拿到这个互斥体锁，也就只有一个线程会得到运行的机会。由于有加锁的动作，因此在这语句之后有unlock的操作
            pthread_cond_wait(&mycv, &mymutex);


        pTask = tasks.front();
        tasks.pop_front();

        pthread_mutex_unlock(&mymutex);

        if (pTask == NULL)
            continue;

        pTask->doTask();
        delete pTask;
        pTask = NULL;
    }

    return NULL;
}

void* producer_thread(void* param)
{
    int taskID = 0;
    Task* pTask = NULL;

    while (true)
    {
        pTask = new Task(taskID);
        pthread_mutex_lock(&mymutex);
        tasks.push_back(pTask);
        std::cout << "produce a task, taskID: " << taskID << ", threadID: " << pthread_self() << std::endl;
        pthread_mutex_unlock(&mymutex);

        pthread_cond_signal(&mycv);
        taskID++;
        sleep(1);
    }
    return NULL;
}

int main()
{
    pthread_mutex_init(&mymutex, NULL); // 用以保证tasks列表操作的安全性
    pthread_cond_init(&mycv, NULL);

    // 五个消费线程
    pthread_t consumerThreadID[5];
    for (int i = 0; i < 5; i++)
        pthread_create(&consumerThreadID[i], NULL, consumer_thread, NULL);

    // 一个生产者线程
    pthread_t producerThreadID;
    pthread_create(&producerThreadID, NULL, producer_thread, NULL);

    pthread_join(producerThreadID, NULL);

    for (int i = 0; i < 5; ++i)
        pthread_join(consumerThreadID[i], NULL);

    pthread_cond_destroy(&mycv);
    pthread_mutex_destroy(&mymutex);

    return 0;
}

int pthread_rwlock_init(pthread_rwlock_t* rwlock, const pthread_rwlockattr_t* attr); // 属性一般为NULL即可
// 或者:
pthread_rwlock_t myrwlock = PTHREAD_RWLOCK_INITIALIZED;

int pthread_rwlockattr_setkind_np(pthread_rwlockattr_t* attr, int pref);
int pthread_rwlockattr_getkind_np(const pthread_rwlockattr_t* attr, int* pref);

// pref参数用于设置读写锁的类型，取值如下：
enum
{
    // 读者优先
    PTHREAD_RWLOCK_PREFER_READER_NP,
    PTHREAD_RWLOCK_PREFER_WRITER_NP,

    // 写者优先
    PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,

    PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP //（默认属性，依然是读者优先）
}

// 属性初始化和销毁
int pthread_rwlockattr_init(pthread_rwlockattr_t* attr);
int pthread_rwlockattr_destory(pthread_rwlockattr_t* attr);

int pthread_rwlock_destory(pthread_rwlock_t* rwlock);

int pthread_rwlock_rdlock(pthread_rwlock_t* rwlock);
int pthread_rwlock_tryrdlock(pthread_rwlock_t* rwlock); // 当不能获取锁时返回-1,errno == EBUSY
int pthread_rwlock_timedrdlock(pthread_rwlock_t* rwlock, const struct timespec* abstime); // 超时后返回 -1 && errno == ETIMEOUT

int pthread_rwlock_wrlock(pthread_rwlock_t* rwlock);
int pthread_rwlock_trywrlock(pthread_rwlock_t* rwlock); // 当不能获取锁时返回-1,errno == EBUSY
int pthread_rwlock_timedwrlock(pthread_rwlock_t* rwlock, const struct timespec* abstime); //超时后返回 -1 && errno == ETIMEOUT

int pthread_rwlock_unlock(pthread_rwlock_t* rwlock);

#include <pthread.h>
#include <unistd.h>
#include <iostream>

int resourceID = 0;
pthread_rwlock_t myrwlock;

void* read_thread(void* param)
{
    while (true)
    {
        pthread_rwlock_rdlock(&myrwlock);
        std::cout << "read thread ID: " << pthread_self() << ", resourceID: " << resourceID << std::endl;

        sleep(1);
        pthread_rwlock_unlock(&myrwlock);
    }
    return NULL;
}

void* write_thread(void* parm)
{
    while (true)
    {
        pthread_rwlock_wrlock(&myrwlock);

        ++resourceID;
        std::cout << "write thread ID: " << pthread_self() << ", resourceID: " << resourceID << std::endl;

        sleep(1);
        pthread_rwlock_unlock(&myrwlock);
    }

    return NULL;
}

int main()
{
    pthread_rwlock_init(&myrwlock, NULL); // 由于默认是读优先，因此写线程很难获得机会执行
    pthread_t readThreadID[5];
    for (int i = 0; i < 5; ++i)
        pthread_create(&readThreadID[i], NULL, read_thread, NULL);

    pthread_t writeThreadID;
    pthread_create(&writeThreadID, NULL, write_thread, NULL);
    pthread_join(writeThreadID, NULL);
    for (int i = 0; i < 5; ++i)
        pthread_join(readThreadID[i], NULL);

    pthread_rwlock_destroy(&myrwlock);
    return 0;
}

lock_guard      // 基于作用域的互斥体管理,即使用{}划定范围,当调用时会自动调用 std::mutex 的lock方法,当出了作用域时会自动调用 std::mutex 的unlock方法
// 示例：
std::mutex m;
std::lock_guard<std::mutex> guard(m);
        
unique_lock     // 灵活的互斥体管理,可以转让控制权等，用在条件变量的wait时，因为锁要在wait内部释放，所以需要转让管理权。同时读写锁的写锁也是通过他管理
// 示例：
std::mutex m;
std::unique_lock<std::mutex> unique(m);
std::shared_mutex m2;
std::unique_lock<std::shared_mutex> unique2(m2);

shared_lock     // 共享互斥体管理，只适用于读写锁里面的读锁
// 示例：
std::shared_mutex m;
std::shared_lock<std::shared_mutex> shared(m);

scoped_lock     // 多互斥体避免死锁管理，可以同时申请多个互斥体，并且不会造成死锁
// 示例：
std::mutex m1, m2;
std::scoped_lock<std::mutex, std::mutex> scoped(m1, m2);

void fun()
{
    std::mutex m; // 这种方法是错的,因为std::mutex的作用域一定要超过fun()的作用域
    std::lock_guard<std::mutex> guard(m);
}

#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
#include <atomic>

int g_num = 0;
std::mutex g_num_mutex;

void slow_increment(int id)
{
    for (int i = 0; i < 3; ++i)
    {
        g_num_mutex.lock(); // lock要和unlock配对使用，否则如果连续重复加锁会导致阻塞
        ++g_num;
        std::cout << id << " => " << g_num << std::endl;
        g_num_mutex.unlock();

        std::this_thread::sleep_for(std::chrono::seconds(1)); // 休眠1秒
    }
}

int main()
{
    std::thread t1(slow_increment, 0);
    std::thread t2(slow_increment, 1);
    t1.join();
    t2.join();
    return 0;
}

lock / unlock // 用来获取写锁和解除写锁(排他锁)
lock_shared / unlock_shared // 用来获取读锁和解除读锁(共享锁)
unique_lock / shared_lock // 用来以RAII方式自动对std::shared_mutex加锁和解锁

#define READER_THREAD_COUNT 8
#define LOOP_COUNT 5000000

#include <iostream>
#include <mutex> // 互斥体
#include <shared_mutex> // 共享互斥体
#include <thread>

class shared_mutex_counter
{
public:
    shared_mutex_counter() = default;
    ~shared_mutex_counter() = default;

    unsigned int get() const
    {
        std::shared_lock<std::shared_mutex> lock(m_mutex); // 共享锁，退出函数之后会自动释放锁
        return m_value;
    }

    void increment()
    {
        std::unique_lock<std::shared_mutex> lock(m_mutex); // 排他锁
        m_value++;
    }

    void reset()
    {
        std::unique_lock<std::shared_mutex> lock(m_mutex);
        m_value = 0;
    }

private:
    mutable std::shared_mutex m_mutex;
    unsigned int m_value = 0;
};                                       

class mutex_counter
{
public:
    mutex_counter() = default;
    ~mutex_counter() = default;

    unsigned int get() const
    {
        std::unique_lock<std::mutex> lock(m_mutex); // 互斥体,相当于排他锁，当退出该函数后会自动释放锁
        return m_value;
    }

    void increment()
    {
        std::unique_lock<std::mutex> lock(m_mutex);
        m_value++;
    }

    void reset()
    {
        std::unique_lock<std::mutex> lock(m_mutex);
        m_value = 0;
    }

private:
    mutable std::mutex m_mutex;
    unsigned int m_value = 0;
};

void test_shared_mutex()
{
    shared_mutex_counter counter;
    int temp;

    // 写线程函数
    auto writer = [&counter]() {
        for (int i = 0; i < LOOP_COUNT; i++)
            counter.increment();
    };

    // 读线程函数
    auto reader = [&counter, &temp]() {
        for (int i = 0; i < LOOP_COUNT; i++)
            temp = counter.get();
    };

    // 存放读线程对象指针的数组
    std::thread** tarray = new std::thread* [READER_THREAD_COUNT];
    
    clock_t start = clock();
    for (int i = 0; i < READER_THREAD_COUNT; i++)
        tarray[i] = new std::thread(reader);
    std::thread tw(writer);
    for (int i = 0; i < READER_THREAD_COUNT; i++)
        tarray[i]->join();
    tw.join();

    clock_t end = clock();
    std::cout << "[test_shared_mutex]" << std::endl;
    std::cout << "thread count: " << READER_THREAD_COUNT << std::endl;
    std::cout << "result: " << counter.get() << ", cost: " << end - start << ", temp: " << temp << std::endl;
}

void test_mutex()
{
    mutex_counter counter;
    int temp;
    auto writer = [&counter]() {
        for (int i = 0; i < LOOP_COUNT; i++)
            counter.increment();
    };

    auto reader = [&counter, &temp]() {
        for (int i = 0; i < LOOP_COUNT; i++)
            temp = counter.get();
    };

    std::thread** tarray = new std::thread* [READER_THREAD_COUNT];
    clock_t start = clock();
    for (int i = 0; i < READER_THREAD_COUNT; i++)
        tarray[i] = new std::thread(reader);
    std::thread tw(writer);
    for (int i = 0; i < READER_THREAD_COUNT; i++)
        tarray[i]->join();
    tw.join();
    clock_t end = clock();
    std::cout << "[test_mutex]" << std::endl;
    std::cout << "thread count: " << READER_THREAD_COUNT << std::endl;
    std::cout << "result: " << counter.get() << ", cost: " << end - start << ", temp: " << temp << std::endl;
}

int main()
{
    test_mutex();
    // test_shared_mutex();
    return 0;
}

#include <thread>
#include <mutex>
#include <condition_variable>
#include <list>
#include <iostream>

class Task
{
public:
    Task(int myTaskID): taskID(myTaskID){}

    void doTask()
    {
        std::cout << "handle a task, taskID: " << taskID << ", threadID: " << pthread_self() << std::endl;
    }

private:
    int taskID;
};

std::mutex mymutex; // C++代码,可以同时兼容linux 和 windows
std::list<Task*> tasks;
std::condition_variable mycv;

void* consumer_thread()
{
    Task* pTask = NULL;
    while (true)
    {
        {
            std::unique_lock<std::mutex> guard(mymutex); // c++的是使用RAII封装,因此使用时需要限定使用范围,以达到退出范围时自动释放的功能
            while (tasks.empty())
            {
                mycv.wait(guard);
            }
            pTask = tasks.front();
            tasks.pop_front();
        }
        if (pTask == NULL)
            continue;

        pTask->doTask();
        delete pTask;
        pTask = NULL;
    }

    return NULL;
}

void* producer_thread()
{
    int taskID = 0;
    Task* pTask = NULL;

    while (true)
    {
        pTask = new Task(taskID);
        { // 使用{}减小作用范围
            std::lock_guard<std::mutex> guard(mymutex); // 注意mymutex的生命周期要大于guard!!!!!!!!!!!!!!
            tasks.push_back(pTask);
            std::cout << "produce a task, taskID: " << taskID << ", threadID: " << pthread_self() << std::endl;
        }
        std::cout << "is empty = " << tasks.empty() << std::endl;
        mycv.notify_one(); // 发出信号
        taskID++;
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    return NULL;
}

int main()
{
    // 五个消费线程
    std::thread consumerThreadID[5];
    for (int i = 0; i < 5; i++)
        consumerThreadID[i] = std::thread(consumer_thread);

    // 一个生产者线程
    std::thread producer(producer_thread);
    producer.join();
    for (int i = 0; i < 5; ++i)
        consumerThreadID[i].join();
    
    return 0;
}

#include <thread>
#include <mutex>
#include <condition_variable>
#include <iostream>
#include <vector>
#include <memory>

std::mutex mymutex;
std::condition_variable mycv;
bool success = false;


void thread_func(int no)
{
    {
        std::unique_lock<std::mutex> lock(mymutex); 
        success = true; // 逻辑跑到这里说明线程已经被创建成功
        mycv.notify_all();
    }
    std::cout << "thread create success, thread no: " << no << std::endl;
    while (true); // 简单死循环模拟
}

int main()
{
    std::vector<std::shared_ptr<std::thread>> threads;
    for (int i = 0; i < 5; ++i)
    {
        success = false;
        // std::shared_ptr<std::thread> spthread;
        // spthread.reset(new std::thread(thread_func, i));
        auto spthread = std::make_shared<std::thread>(thread_func, i);
        {
            std::unique_lock<std::mutex> lock(mymutex);
            while (!success)
                mycv.wait(lock); // 虽然这里在未接收到信号时会释放锁,但是该锁并不会被本线程获取到,因此本线程会一直阻塞在这里
        }
        std::cout << "start thread success: thread no: " << i << std::endl;
        threads.emplace_back(spthread);
    }

    for (auto& iter: threads)
        iter->join();

    return 0;
}