线程安全

1，原子操作

通常cpu的最小执行单元是一条指令，是不会被打断的。我们把单条指令的操作成为是原子的，但是像自增或自减这样的操作由几条指令组成，是非原子操作。window提供了一些专门的原子操作的API：

 

2，同步与锁

a，二元信号量（线程间共享）

b，互斥量（mutex）

c，临界区（Critical Section）

d，读写锁（read-write lock）

 

e，条件变量

3，可重入函数

一个函数被重入有两种情况：

a，多个线程同时执行这个函数

b，函数自身（可能进过多层调用）调用自身

可重入函数是线程并发安全的强力保障，多线程环境下可以放心使用

4，线程安全

没有绝对安全的多线程程序

a，过度优化，编译器对代码执行优化导致非线程安全，如编译器为提高对变量x的访问速度，将其放入寄存器而不回写。可以使用volatile修饰避免这样的问题

b，CPU动态调度，导致乱序执行

5，线程安全的singleton

#ifdef _WIN32
#include <windows.h>
#include <process.h>
#define barrier() NULL
class CMutex
{
public:
    CMutex()
    {
        InitializeCriticalSection(&m_CriticalSetion);
    }
    ~CMutex()
    {
        DeleteCriticalSection(&m_CriticalSetion);
    }
    bool Lock()
    {
        EnterCriticalSection(&m_CriticalSetion);
        return true;
    }
    bool Unlock()
    {
        LeaveCriticalSection(&m_CriticalSetion);
        return true;
    }
private:
    CRITICAL_SECTION m_CriticalSetion;
};
#else
#include <pthread.h>
#define barrier() __asm__ __volatile__("":::"memory")
class CMutex
{
public:
    CMutex()
    {
        pthread_mutex_init(&m_Mutex, NULL);
    }
    ~CMutex()
    {
        pthread_mutex_destroy(&m_Mutex);
    }
    bool Lock()
    {
        return pthread_mutex_lock(&m_Mutex) == 0;
    }
    bool Unlock()
    {
        return pthread_mutex_unlock(&m_Mutex) == 0;
    }
private:
    pthread_mutex_t m_Mutex;
};
#endif

template <typename T>
class singleton
{
public:
    static T* GetInstance()
    {
        if (!m_pInst)
        {
            m_Mutex.Lock();
            if (!m_pInst)
            {
                T* p = new T;
                barrier(); //barrier()执行完成之前内存被初始化
                m_pInst = p;
            }
            m_Mutex.Unlock();
        }
        return m_pInst;
    }
protected:
    singleton(){}
    virtual ~singleton(){}
    static T* m_pInst;
    static CMutex m_Mutex;

private:
    class C1234567
    {
        ~C1234567()
        {
            delete m_pInst;
            m_pInst = NULL;
        }
    };
    static C1234567 m_C1234567;
};

template<typename T> T* singleton<T>::m_pInst = NULL;
template<typename T> CMutex singleton<T>::m_Mutex;
template<typename T> typename singleton<T>::C1234567 singleton<T>::m_C1234567;

#include <stdio.h>
#include <stdlib.h>
#ifndef _WIN32
#include <unistd.h>
#endif

class CTest : public singleton<CTest>
{
public:
    CTest()
    {
        printf("----------CTest construct----------\n");
    }
    ~CTest()
    {
        printf("----------CTest destruct-----------\n");
    }
    void print()
    {
        printf("CTest call print()\n");
    }
};

// 可重入函数
void* work(void * arg)
{
    CTest* p = CTest::GetInstance();
    if (p)
    {
        printf("CTest pointer = %p\n", p);
        p->print();
    }

    return NULL;
}

int main(int argc, char* argv[])
{
    const int MAX_COUNT = 10;
#ifndef _WIN32
    pthread_t p_id[MAX_COUNT];
    for (int i = 0; i < MAX_COUNT; i ++)
    {
        if (pthread_create(&p_id[i], NULL, work, NULL) != 0)
        {
            perror("pthread_create");
            exit(0);
        }
        printf("create thread id = %d\n", p_id[i]);
    }
    for (int i = 0; i < MAX_COUNT; i ++)
        pthread_join(p_id[i], NULL);
#else
    HANDLE hThread[MAX_COUNT];
    for (int i = 0; i < MAX_COUNT; i++)
    {
        hThread[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)work, NULL, 0, NULL);
        printf("create thread id = %d\n", hThread[i]);
    }
    WaitForMultipleObjects(MAX_COUNT, hThread, TRUE, INFINITE);
#endif

    return 0;
}