#pragma once
#include<iostream>
#include<pthread.h>
#include<string>
#include<cassert>
#include<functional>
//因为如下的静态成员方法不能调用非静态成员方法和变量
//因此可以选择创建一个类，让类来调用方法后再让静态成员方法
//返回该类调用的结果
//声明下面的类
class Thread;
class Con{
public:
    Thread* _this;
    Con()
        :_this(nullptr)
    {}
};
class Thread{
public:
    typedef std::function<void*(void*)> func_;
    //构造函数
    Thread(func_ func, void* args, int number)
        :_func(func)
        ,_args(args)
    {
        _name = "thread-No.";
        _name += std::to_string(number);
        //创建辅助类对象，让其成员指向当前this
        //最后将其传入调用的函数中
        Con* con = new(Con);
        con->_this = this;
        int n = pthread_create(&_tid, nullptr, start_routine, con);
        assert(n == 0);
    }
    //线程调用方法
    //静态类内成员函数不含this指针
    static void* start_routine(void* args){
        //静态成员函数不能调用非静态成员方法和变量
        //因此使用辅助类，辅助类里的成员已经是当前this
        //直接调用即可
        Con* con = (Con*)args;
        void* res = con->_this->run();
        delete con;
        return res;
    }
    //调用函数
    void* run(){
        return _func(_args);
    }
    //线程等待
    void join(){
        int n = pthread_join(_tid, nullptr);
        assert(n == 0);
    }
    ~Thread(){
    }
private:
    std::string _name;
    pthread_t _tid;
    func_ _func;
    void* _args;
};

#include"MyThread.hpp"
#include<unistd.h>
void* thread_pp(void* args){
    char* s = (char*)args;
    while(1){
        std::cout << "I am new thread " << s << std::endl;
        sleep(1); 
    }
}
int main(){
    Thread thread1(thread_pp, (void*)"hello", 1);
    while(1){
        std::cout << "I am old thread" << std::endl;
        sleep(1);
    }
    thread1.join();
}

#include"MyThread.hpp"
#include<unistd.h>
//记录票数
int ticket = 10000;
void* getTicket(void* argc){
    char* res = (char*)argc;
    while(1){
        if(ticket > 0){
            usleep(1000);
            std::cout << res << " " << ticket << std::endl;
            --ticket;
        }
        else
            break;
    }
}
int main(){
    //创建多个线程
    Thread thread1(getTicket, (void*)"thread 1", 1);
    Thread thread2(getTicket, (void*)"thread 2", 2);
    Thread thread3(getTicket, (void*)"thread 3", 3);
    Thread thread4(getTicket, (void*)"thread 4", 4);
    thread1.join();
    thread2.join();
    thread3.join();
    thread4.join();
    return 0;
}

if(ticket > 0)
      usleep(1000);

int pthread_mutex_init(pthread_mutex_t *restrict mutex,
              const pthread_mutexattr_t *restrict attr);

//全局定义锁并初始化
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
//定义锁并初始化
pthread_mutex_t lock;
pthread_mutex_init(&lock, nullptr);

int pthread_mutex_lock(pthread_mutex_t *mutex);//申请使用锁
int pthread_mutex_trylock(pthread_mutex_t *mutex);//尝试申请锁，申请失败则立即报错返回
int pthread_mutex_unlock(pthread_mutex_t *mutex);//解锁

#include"MyThread.hpp"
#include<unistd.h>
#include<vector>
// //全局定义锁并初始化
// pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
//记录票数
int ticket = 10000;
//将线程属性封装成类，类里面包括锁
class ThreadDate{
public:
    std::string _name;
    pthread_mutex_t* _lockp;
    ThreadDate(const std::string name, pthread_mutex_t* lockp)
        :_name(name)
        ,_lockp(lockp)
    {}
};
void* getTicket(void* argc){
    ThreadDate* td = (ThreadDate*)argc;
    while(1){
        //使用锁
        pthread_mutex_lock(td->_lockp);
        if(ticket > 0){
            usleep(1000);
            std::cout << td->_name << " " << ticket << std::endl;
            --ticket;
            //循环退出前必须解锁
            pthread_mutex_unlock(td->_lockp);
        }
        else{
            //循环退出前必须解锁
            pthread_mutex_unlock(td->_lockp);
            break;
        }
        //模拟线程还会做其他事情，留点时间给其他的线程完成上面的代码
        usleep(1000);
    }
}
int main(){
    //定义锁并初始化
    pthread_mutex_t lock;
    pthread_mutex_init(&lock, nullptr);
    std::vector<pthread_t> v(4);
    //创建多个线程
    for(int i = 0; i < 4; ++i){
        std::string name("thread ");
        name += std::to_string(i + 1);
        //创建线程属性的一个对象，所有线程共用一把锁
        ThreadDate* td = new ThreadDate(name, &lock);
        //创建线程，将线程id保存到数组中，参数传入属性对象
        pthread_create(&v[i], nullptr, getTicket, (void*)td);
    }
    //对所有线程进行等待
    for(int i = 0; i < 4; ++i)
        pthread_join(v[i], nullptr);
    //删除锁
    pthread_mutex_destroy(&lock);
    return 0;
}

lock:
    movb $0, %al
    xchgb %al, mutex
    if(al寄存器的内容 > 0)
      return 0;
    else
      挂起等待;
    goto lock;
unlock:
    movb $1, mutex
    唤醒等待mutex的线程;
    return 0;

#pragma once
#include<iostream>
#include<pthread.h>
//锁的对象类
class Mutex{
public:
    Mutex(pthread_mutex_t* lockp = nullptr)
        :_lockp(lockp)
    {}
    void lock(){
        if(_lockp)
            pthread_mutex_lock(_lockp);
    }
    void unlock(){
        if(_lockp)
            pthread_mutex_unlock(_lockp);
    }
    ~Mutex(){}
private:
    pthread_mutex_t* _lockp;
};
//锁的调用类
class LockGuard{
public:
    LockGuard(Mutex* lock)
        :_lock(lock)
    {
        //在构造中直接调用
        _lock->lock();
    }
    ~LockGuard(){
        //析构中直接解锁
        _lock->unlock();
    }
private:
    Mutex* _lock;
};