std::mutex mtx;
mtx.lock();
....
mtx.unlock();

std::shared_mutex mutex;
int sharedData = 0;

void readerThread()
{
    std::shared_lock<std::shared_mutex> lock(mutex);
}

void writerThread()
{
    std::unique_lock<std::shared_mutex> lock(mutex);
    sharedData += 1;
}

std::atomic<int> i;

/// 线程安全
void set()
{
    i++;
}

/// 线程安全
int get()
{
    return i;
}

HANDLE hMutex;

// 创建互斥量
hMutex = CreateMutex(NULL, FALSE, NULL);
if (hMutex == NULL)
{
    return 0;
}

// 加锁
WaitForSingleObject(hMutex, INFINITE);

...

// 解锁
ReleaseMutex(hMutex);

// 关闭互斥量
CloseHandle(hMutex);

CRITICAL_SECTION cs;
// 初始化临界区
InitializeCriticalSection(&cs);
// 加锁
EnterCriticalSection(&cs);
...
// 解锁
LeaveCriticalSection(&cs);
// 删除临界区
DeleteCriticalSection(&cs);

HANDLE mutex_ = gos_mutex_init();
gos_mutex(mutex_);

...

gos_unmutex(mutex_);
gos_mutex_free(mutex_);

class NTPClient
{
public:
    /// 进行NTP同步, 后台线程周期运行
    void ntp_sync();
    /// 获取NTP是否成功, 业务线程调用
    bool get_ntp_valid();
};

NTPClient client;

void ntp_sync_thread()
{
    while (true)
    {
        client.ntp_sync();
        std::this_thread::sleep_for(std::chrono::seconds(10));
    }
}

std::thread t(ntp_sync_thread);
/// 分离线程
t.detach();

pthread_attr_t      stAttr;

/// 设置 pthread 属性
pthread_attr_init(&stAttr);
pthread_attr_setdetachstate(&stAttr, PTHREAD_CREATE_DETACHED);

/// 初始化线程
pthread_t thread_id;
pthread_create(&thread_id, NULL, threadFunction, &client);

/// 1. Windows API:
HANDLE hThread = CreateThread(NULL, 0, threadFunction, &client, 0, NULL);
// 分离线程
CloseHandle(hThread);

/// 2. Vistual C++ CRT 版本
uintptr_t hThread = _beginthreadex(NULL, 0, threadFunction, &client, 0, NULL);

class NTPClientThread: public GThread
{
public :
    NTPClientThread()
    {
        Start();
    }

    virtual GOS_THREAD_RET ThreadEntry(void* pPara)
    {
        while (true)
        {
            client.ntp_sync();
            GThread::Sleep(10000);
        }
        return 0;
    }

private:
    NTPClient client;
};

int i = 0;

std::thread t([&i](){
    i = 1;
});

// 等待后台线程结束
t.join();

// 获取线程函数结果
std::cout << i << std::endl;

int i = 0;

// 使用 std::async 在后台执行函数并获取结果
auto future = std::async(std::launch::async, [&i]() {
    i = 1;
    return i;
});

// 等待后台线程结束并获取结果
i = future.get();

// 输出线程函数结果
std::cout << i << std::endl;

int i = 0;

DWORD WINAPI f(LPVOID lpParam)
{
    i = 1;
    return 0;
}

HANDLE hThread = CreateThread(NULL, 0, f, NULL, 0, NULL);

// 等待后台线程结束
WaitForSingleObject(hThread, INFINITE);

// 关闭线程句柄
CloseHandle(hThread);

// 获取线程函数结果
std::cout << i << std::endl;

int i = 0;

void f()
{
    i = 1;
}

pthread_t t;
pthread_create(&t, NULL, f, NULL);

// 等待后台线程结束
pthread_join(t, NULL);

// 获取线程函数结果
std::cout << i << std::endl;

class ThreadPlayAndRec : public GThread
{};

ThreadPlayAndRec* p = new ThreadPlayAndRec();
p->Start();
...
p->Stop();
/// 通知线程结束后需要等待多久，线程函数才会结束
delete p;

VOID ThreadPlayAndRec::Free()
{
    m_ulThreadState = THREAD_STATE_CLOSING;
    Stop();
    while(1)
    {
        if (m_ulThreadState == THREAD_STATE_FREE)
        {
            break;
        }

        gos_sleep_1ms(1);
    }

}

ThreadPlayAndRec* p = new ThreadPlayAndRec();
p->Start(); ///< 通知线程开始
...
p->Stop(); ///< 通知线程结束
p->Free(); ///< 阻塞等待线程结束
delete p;

/// 初始化
sem_init()

/// 等待信号量唤醒
sem_wait()

/// 信号量唤醒
sem_post()

/// 回收资源
sem_destroy()

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int flag = 0;

void* threadFunction(void* arg) {
    pthread_mutex_lock(&mutex);
    while (!flag) {
        pthread_cond_wait(&cond, &mutex);
    }
    printf("Thread received signal\n");
    pthread_mutex_unlock(&mutex);

    ...

    return NULL;
}

int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, threadFunction, NULL);

    /// 主线程等待一段时间后发送信号
    sleep(2);
    pthread_mutex_lock(&mutex);
    flag = 1;
    /// 唤醒线程
    pthread_cond_signal(&cond);
    pthread_mutex_unlock(&mutex);

    pthread_join(thread, NULL);

    return 0;
}

void producers()
{
    std::unique_lock<std::mutex> lock(queue_mutex);
    /// 这个封装好的函数放入任务列表中
    tasks.emplace(&f);

    /// 通知一个阻塞中的线程，任务队列中有任务了
    condition.notify_one();
}

void consumer()
{
    std::unique_lock<std::mutex> lock(this->queue_mutex);
    /// 阻塞等待直到函数返回 true
    this->condition.wait(lock, [this] { return !this->tasks.empty(); });
    /// 从任务队列中拿出来一个任务
    task = this->tasks.front();
    this->tasks.pop();
}

ThreadPlayAndRec g_ThreadPlayAndRec; ///< 全局变量,在程序启动时线程不安全

ThreadPlayAndRec* p = NULL;

if(!p)
{
    p = new ThreadPlayAndRec();
}

ThreadPlayAndRec* p = NULL;
std::mutex mtx;

if(!p) // 第一次检查
{
    std::lock_guard<std::mutex> guard(mtx);
    if(!p) // 第二次检查
    {
        p = new ThreadPlayAndRec();
    }
}

std::once_flag flag;
ThreadPlayAndRec* p = NULL;
std::call_once(flag, []() { p = new ThreadPlayAndRec(); });

ThreadPlayAndRec* p = NULL;
std::mutex mtx;

std::lock_guard<std::mutex> guard(mtx);
if(!p)
{
    p = new ThreadPlayAndRec();
}

pthread_once_t once_control = PTHREAD_ONCE_INIT;

void init_function()
{
    std::cout << "Initialization function executed" << std::endl;
}

/// 只会执行一次
pthread_once(&once_control, init_function);

EnterCriticalSection(&cs);
if (!initialized)
{
    init_function();
    initialized = true;
}
LeaveCriticalSection(&cs);

std::mutex mutex_;
std::condition_variable cv_;
bool ready_ = false;

std::jthread j([this]() mutable
                {
                    std::unique_lock<std::mutex> mutex(mutex_);
                    /// 等待同步开始
                    cv_.wait(mutex, [this] { return ready_; });
                    /// 执行函数
                    f();
                }));

/// 锁定互斥量，以修改 ready_
mutex_.lock();
ready_ = true;
/// 发送给所有的线程，可以开始运行
cv_.notify_all();
mutex_.unlock();

#include <msgpack.hpp>
#include <vector>
#include <string>
#include <iostream>

int main(void) {
        // serializes this object.
        std::vector<std::string> vec;
        vec.push_back("Hello");
        vec.push_back("MessagePack");

        // serialize it into simple buffer.
        msgpack::sbuffer sbuf;
        msgpack::pack(sbuf, vec);

        // deserialize it.
        msgpack::object_handle oh =
            msgpack::unpack(sbuf.data(), sbuf.size());

        // print the deserialized object.
        msgpack::object obj = oh.get();
        std::cout << obj << std::endl;  //=> ["Hello", "MessagePack"]

        // convert it into statically typed object.
        std::vector<std::string> rvec;
        obj.convert(rvec);
}

#include <msgpack.hpp>
#include <iostream>
#include <string>

int main() {
        // serializes multiple objects using msgpack::packer.
        msgpack::sbuffer buffer;

        msgpack::packer<msgpack::sbuffer> pk(&buffer);
        pk.pack(std::string("Log message ... 1"));
        pk.pack(std::string("Log message ... 2"));
        pk.pack(std::string("Log message ... 3"));

        // deserializes these objects using msgpack::unpacker.
        msgpack::unpacker pac;

        // feeds the buffer.
        pac.reserve_buffer(buffer.size());
        memcpy(pac.buffer(), buffer.data(), buffer.size());
        pac.buffer_consumed(buffer.size());

        // now starts streaming deserialization.
        msgpack::object_handle oh;
        while(pac.next(oh)) {
            std::cout << oh.get() << std::endl;
        }

        // results:
        // $ g++ -Ipath_to_msgpack/include stream.cc -o stream
        // $ ./stream
        // "Log message ... 1"
        // "Log message ... 2"
        // "Log message ... 3"
}

#include <msgpack.hpp>
#include <iostream>
#include <string>

int main() {
        // serializes multiple objects into one message containing an array using msgpack::packer.
        msgpack::sbuffer buffer;

        msgpack::packer<msgpack::sbuffer> pk(&buffer);
        pk.pack_array(3);
        pk.pack(std::string("Log message ... 1"));
        pk.pack(std::string("Log message ... 2"));
        pk.pack(std::string("Log message ... 3"));

        // serializes multiple objects into one message containing a map using msgpack::packer.
        msgpack::sbuffer buffer2;

        msgpack::packer<msgpack::sbuffer> pk2(&buffer2);
        pk2.pack_map(2);
        pk2.pack(std::string("x"));
        pk2.pack(3);
        pk2.pack(std::string("y"));
        pk2.pack(3.4321);

}

#include <msgpack.hpp>
#include <vector>
#include <string>

class myclass {
private:
    std::string m_str;
    std::vector<int> m_vec;
public:
    MSGPACK_DEFINE(m_str, m_vec);
};

int main() {
        std::vector<myclass> vec;
        // add some elements into vec...

        // you can serialize myclass directly
        msgpack::sbuffer sbuf;
        msgpack::pack(sbuf, vec);

        msgpack::object_handle oh =
            msgpack::unpack(sbuf.data(), sbuf.size());

        msgpack::object obj = oh.get();

        // you can convert object to myclass directly
        std::vector<myclass> rvec;
        obj.convert(rvec);
}

#include <msgpack.hpp>
#include <vector>
#include <iostream>
#include <string>
#include <random>

/// 获取随机整数
int GetRandomInt(int min = 0, int max = 1000000)
{
    static std::random_device rd;
    static std::mt19937 gen(rd());
    static std::uniform_int_distribution<> dis(min, max);
    return dis(gen);
}

/// 获取随机字符串
std::string GetRandomString(size_t len = 10)
{
    static std::random_device rd;
    static std::mt19937 gen(rd());
    static std::uniform_int_distribution<> dis(0, 25);

    std::string str;
    for (int i = 0; i < len; ++i)
    {
        str.push_back('a' + dis(gen));
    }

    return str;
}

/// 序列化函数基类
template <typename T>
class MsgPackSerialization
{
 public:
    virtual ~MsgPackSerialization() = default;
    bool operator==(const MsgPackSerialization&) const = default;

    /// 序列化
    std::vector<char> Serialization()
    {
        msgpack::sbuffer sbuf;
        msgpack::pack(sbuf, *(static_cast<T*>(this)));
        std::vector<char> vec(sbuf.data(), sbuf.data() + sbuf.size());
        return vec;
    }

    /// 反序列化
    void Deserialization(const std::vector<char>& vec)
    {
        msgpack::object_handle oh = msgpack::unpack(vec.data(), vec.size());
        msgpack::object obj = oh.get();
        obj.convert(*(static_cast<T*>(this)));
    }
};

/// 集成序列化类
class myclass : public MsgPackSerialization<myclass>
{
 public:
    bool operator==(const myclass&) const = default;
    myclass& operator=(const myclass& rhs)
    {
        if (this != &rhs)
        {
            m_str = rhs.m_str;
            m_vec = rhs.m_vec;
        }
        return *this;
    }

    /// 获取随机对象
    static myclass GetRandomObj()
    {
        myclass obj;
        obj.m_str = GetRandomString(10);
        auto num = GetRandomInt(0, 10);
        for (int i = 0; i < num; ++i)
        {
            obj.m_vec.push_back(GetRandomInt(0, 1000));
        }

        return obj;
    }

public:
    /// 为 msgpack 定义序列化和反序列化的字段
    MSGPACK_DEFINE(m_str, m_vec);

private:
    std::string m_str;
    std::vector<int> m_vec;
};

int main()
{
    /// 获取随机对象
    auto obj = myclass::GetRandomObj();
    decltype(obj) obj2;
    /// 序列化
    auto vec = obj.Serialization();
    /// 反序列化
    obj2.Deserialization(vec);

    if (obj2 == obj)
    {
        std::cout << "obj2 == obj" << std::endl;
    }
    else
    {
        std::cout << "obj2 != obj" << std::endl;
    }

    return 0;
}

class myclass2 : public MsgPackSerialization<myclass2>
{
 public:
    bool operator==(const myclass2&) const
    {
        return m_str == m_str && m_vec == m_vec
            && m_class == m_class && m_vec_class == m_vec_class;
    }

    /// 获取本类的随机对象
    static myclass2 GetRandomObj()
    {
        myclass2 obj;
        obj.m_str = GetRandomString(10);
        auto num = GetRandomInt(0, 10);

        for (int i = 0; i < num; ++i)
        {
            obj.m_vec.push_back(GetRandomInt(0, 1000));
            obj.m_vec_class.push_back(myclass::GetRandomObj());
        }

        obj.m_class = myclass::GetRandomObj();

        return obj;
    }

public:
    /// 为 msgpack 定义序列化和反序列化的字段
    MSGPACK_DEFINE(m_str, m_vec, m_class, m_vec_class);

private:
    std::string m_str;
    std::vector<int> m_vec;
    myclass m_class;
    std::vector<myclass> m_vec_class;
};

int main()
{
    /// 获取随机对象
    auto obj = myclass2::GetRandomObj();
    decltype(obj) obj2;
    /// 序列化
    auto vec = obj.Serialization();
    /// 反序列化
    obj2.Deserialization(vec);

    if (obj2 == obj)
    {
        std::cout << "obj2 == obj" << std::endl;
    }
    else
    {
        std::cout << "obj2 != obj" << std::endl;
    }

    return 0;
}

#define MSGPACK_DEFINE(...) ...\
    std::shared_ptr<std::vector<char>> Serialization()                                      \
    {                                                                                       \
        msgpack::sbuffer sbuf;                                                              \
        msgpack::pack(sbuf, *this);                                                         \
        return std::make_shared<std::vector<char>>(sbuf.data(), sbuf.data() + sbuf.size()); \
    }                                                                                       \
    void Deserialization(const std::shared_ptr<std::vector<char>>& vec)                     \
    {                                                                                       \
        msgpack::object_handle oh = msgpack::unpack(vec->data(), vec->size());               \
        msgpack::object obj = oh.get();                                                     \
        obj.convert(*this);                                                                  \
    }

#include <iostream>
#include <thread>

int main()
{
    /// 创建线程
    std::thread t([]() {
        while (true)
        {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            std::cout << "Hello World!" << std::endl;
        }
        });

    /// 线程从主线程分离
    t.detach();

    /// 阻止主线程退出
    while (true)
    {
    }
    return 0;
}

#include <iostream>
#include <future>
#include <thread>

int main()
{
    /// 函数对象递归调用自己
    std::function<void(int)> f = [&](int i) {
            /// 休息1秒
            std::this_thread::sleep_for(std::chrono::seconds(1));
            std::cout << "Hello World!" << i << std::endl;
            f(i);
        };

    std::async(std::launch::async, f, 43);

    /// 阻止主线程退出
    while (true)
    {
    }
    return 0;
}

#include <iostream>
#include <filesystem>

int main()
{
    std::filesystem::path p1("C:\\Windows\\System32\\drivers\\etc\\hosts");
    std::filesystem::path p2("C:/Windows/System32/drivers/etc/hosts");
    std::filesystem::path p3("C:", std::filesystem::path::format::generic_format);
    std::filesystem::path p4("Windows/System32/drivers/etc/hosts", std::filesystem::path::format::generic_format);
    std::filesystem::path p5("hosts", std::filesystem::path::format::generic_format);
    std::filesystem::path p6("C:\\Windows\\System32\\drivers\\etc\\hosts", std::filesystem::path::format::native_format);
    std::filesystem::path p7("C:/Windows/System32/drivers/etc/hosts", std::filesystem::path::format::native_format);
    std::filesystem::path p8("C:", std::filesystem::path::format::native_format);
    std::filesystem::path p9("Windows/System32/drivers/etc/hosts", std::filesystem::path::format::native_format);
    std::filesystem::path p10("hosts", std::filesystem::path::format::native_format);

    std::cout << p1 << std::endl;
    std::cout << p2 << std::endl;
    std::cout << p3 << std::endl;
    std::cout << p4 << std::endl;
    std::cout << p5 << std::endl;
    std::cout << p6 << std::endl;
    std::cout << p7 << std::endl;
    std::cout << p8 << std::endl;
    std::cout << p9 << std::endl;
    std::cout << p10 << std::endl;

    std::cout << p1.string() << std::endl;
    std::cout << p2.string() << std::endl;
    std::cout << p3.string() << std::endl;
    std::cout << p4.string() << std::endl;
    std::cout << p5.string() << std::endl;
    std::cout << p6.string() << std::endl;
    std::cout << p7.string() << std::endl;
    std::cout << p8.string() << std::endl;
    std::cout << p9.string() << std::endl;
    std::cout << p10.string() << std::endl;

    return 0;
}

#include <iostream>
#include <filesystem>

int main()
{
    std::filesystem::path p = std::filesystem::current_path();
    std::cout << p << std::endl;

    auto str = p.str();
    std::cout << str << std::endl;
    return 0;
}

#include <iostream>
#include <filesystem>

int main()
{
    std::filesystem::path p = std::filesystem::absolute("hosts");
    std::cout << p << std::endl;

    auto str = p.str();
    std::cout << str << std::endl;
    return 0;
}

#include <iostream>
#include <filesystem>

int main()
{
    std::filesystem::path p("hosts");
    if (std::filesystem::exists(p))
    {
        std::cout << "exists" << std::endl;
    }
    else
    {
        std::cout << "not exists" << std::endl;
    }
    return 0;
}

#include <iostream>
#include <filesystem>

int main()
{
    std::filesystem::path p("test");
    /// 递归创建文件夹
    if (std::filesystem::create_directories(p))
    {
        std::cout << "create directory success" << std::endl;
    }
    else
    {
        std::cout << "create directory failed" << std::endl;
    }
    return 0;
}

#include <iostream>
#include <filesystem>

int main()
{
    std::filesystem::path p("test.txt");
    if (std::filesystem::create_directory(p))
    {
        std::cout << "create file success" << std::endl;
    }
    else
    {
        std::cout << "create file failed" << std::endl;
    }
    return 0;
}

#include <iostream>
#include <filesystem>

int main()
{
    std::filesystem::path p("C:");
    std::filesystem::space_info info = std::filesystem::space(p);
    std::cout << "capacity: " << info.capacity << std::endl;
    std::cout << "free: " << info.free << std::endl;
    std::cout << "available: " << info.available << std::endl;
    return 0;
}

#include <iostream>
#include <filesystem>

int main()
{
    std::filesystem::path p("hosts");
    std::cout << "file size: " << std::filesystem::file_size(p) << std::endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <regex>
#include <string>
#include <filesystem>
#include <ranges>
#include <algorithm>

std::vector<std::string> get_directory_files(const std::string& path, const std::regex& reg = std::regex("(.*)"), bool is_recursive = false)
{
    auto p = std::filesystem::path(path);
    if (!std::filesystem::exists(p.string()))
    {
        return {};
    }

    std::vector<std::string> vec;
    auto f = [&](const auto& dir_entry)
    {
        auto fp = dir_entry.path();
        /// 过滤文件夹
        if (!std::filesystem::is_directory(std::filesystem::status(fp)))
        {
            auto file_name = fp.filename().string();
            /// 正则匹配
            if (std::regex_match(file_name, reg))
            {
                vec.push_back(fp.string());
            }
        }
    };

    if (is_recursive)
    {
        /// 递归查找
        std::ranges::for_each(std::filesystem::recursive_directory_iterator{p}, f);
    }
    else
    {
        /// 非递归查找
        std::ranges::for_each(std::filesystem::directory_iterator{p}, f);
    }

    std::ranges::sort(vec);
    return vec;
}

int main()
{

    /// 默认情况下，查找所有文件, 非递归
    auto c0 = get_directory_files(dir1.string());
    /// 非递归，查找所有文件
    auto c1 = get_directory_files(dir1.string(), std::regex("(.*)"), false);
    /// 非递归，查找特定文件 .log
    auto c2 = get_directory_files(dir1.string(), std::regex("(.*\\.log)"), false);
    /// 递归，查找所有文件
    auto c3 = get_directory_files(dir1.string(), std::regex("(.*)"), true);
    /// 递归，查找特定文件 .log
    auto c4 = get_directory_files(dir1.string(), std::regex("(.*\\.log)"), true);

    return 0;

}

#include <iostream>
#include <filesystem>

int main()
{
    std::filesystem::path p("hosts");
    std::filesystem::path new_p("hosts_new");
    std::filesystem::rename(p, new_p);
    return 0;
}

#include <iostream>
#include <filesystem>

int main()
{
    std::filesystem::path p("hosts_new_copy");
    std::filesystem::path new_p("hosts_new_copy_move");
    std::filesystem::rename(p, new_p);
    return 0;
}

#include <iostream>
#include <filesystem>

int main()
{
    std::filesystem::path p("hosts_new");
    std::filesystem::path new_p("hosts_new_copy");
    std::filesystem::copy(p, new_p);
    return 0;
}

bool copy_directory(const std::string& from, const std::string& to) noexcept
{
    if (!std::filesystem::is_directory(from))
    {
        return false;
    }

    if (!std::filesystem::exists(from))
    {
        return false;
    }

    if (std::filesystem::exists(to))
    {
        return false;
    }
    /// 文件存在的情况下则更新，文件递归拷贝
    const auto copy_options = std::filesystem::copy_options::update_existing | std::filesystem::copy_options::recursive;

    std::error_code code;
    std::filesystem::copy(from, to, copy_options, code);
    return !code;
}