Deliver/include/CcosLock.h

#pragma once

#include <pthread.h>
#include <signal.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <cstdint>
#include <ctime>
#include <atomic>
#include <map>
#include <algorithm>
#include <cerrno>
#include <cstdio>

// 类型别名
using DWORD = unsigned long;  
using UINT64 = uint64_t;      // 64位无符号整数

// 常量定义
#ifndef INFINITE
#define INFINITE 0xFFFFFFFF
#endif

#ifndef WAIT_OBJECT_0
#define WAIT_OBJECT_0 0
#endif

#ifndef WAIT_TIMEOUT
#define WAIT_TIMEOUT 258
#endif


// 原子操作函数
inline DWORD AtomicCompareExchange(std::atomic<DWORD>* dest, DWORD exchange, DWORD compare) {
    DWORD expected = compare;
    dest->compare_exchange_strong(expected, exchange, std::memory_order_acq_rel);
    return expected;
}

class CcosLock {
protected:
    std::atomic<DWORD> m_LockThreadId{ 0 };  // 持有锁的线程ID
    std::atomic<DWORD> m_RefCount{ 0 };      // 引用计数
    std::atomic<DWORD> m_InterLock{ 0 };     // 内部锁状态
    pthread_mutex_t m_Mutex;               // 互斥锁
    pthread_cond_t m_Cond;                 // 条件变量
    std::atomic<bool> m_IsDestroyed{ false };// 销毁标志

    bool CcosInternal_EnterCriticalSection(DWORD TryCount);
    void CcosInternal_LeaveCriticalSection();
    bool Try_Clear_DeadThread();
    int FindProcessThreads(DWORD dwOwnerTID);
    DWORD Thread_WaitUnlockNotify(DWORD timeout = INFINITE);

public:
    CcosLock();
    virtual ~CcosLock();

    DWORD Thread_Lock(DWORD timeout = INFINITE);
    void Thread_UnLock();
    bool Thread_Clear(DWORD Tid);
    bool IsDestroyed() const { return m_IsDestroyed; }
};

// 全局清理函数
void CleanupForThread(DWORD Tid);

// C接口函数
extern "C" {
    struct ThreadLock {
        std::atomic<DWORD> thread_id{ 0 };
        std::atomic<DWORD> ref_count{ 0 };
    };

    bool Ccos_ThreadLock(ThreadLock* pLock);
    void Ccos_ThreadUnLock(ThreadLock* pLock);
    void Ccos_ThreadClearForTid(ThreadLock* pLock, DWORD Tid);
    DWORD Proc_Lock(DWORD timeout);
    void Proc_UnLock();
    DWORD Thread_GetUniqTick();
}

// Linux 辅助函数

inline DWORD GetCurrentThreadId() {
    return static_cast<DWORD>(syscall(SYS_gettid));
}

inline DWORD GetTickCount() {
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    return static_cast<DWORD>(ts.tv_sec * 1000 + ts.tv_nsec / 1000000);
}

inline bool IsThreadAlive(DWORD tid) {
    char path[64];
    snprintf(path, sizeof(path), "/proc/%lu", tid);  
    return access(path, F_OK) == 0;  // 线程存在则/proc/[tid]目录存在
}