如何判断一个类是否是线程安全（可重入）的？

答案：若一个类对外提供的接口的是原子的，或者说多线程编程时不用对该类的接口考虑同步问题，那么该类就是线程安全的类。

栗子：

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

class Array
{
public:
    Array()
    {
        memset(data_, 0, sizeof(int) * 10);
        size = 0;
    }

public:
    void push_back(const int &data)
    {
        //pthread_mutex_lock(&mtx_);
        data_[size] = data;
        usleep(10);
        size++;
        //pthread_mutex_unlock(&mtx_);
    }
    void print()
    {
        for (size_t i = 0; i < 30; i++)
            std::cout << data_[i] << " ";
        std::cout << std::endl;
    }

private:
    int data_[30];
    std::atomic<size_t> size;
    pthread_mutex_t mtx_;
};

Array g_array;
using ADDDATAFUNC = void *(*)(void *);

void *AddData1(void *arg);
void *AddData2(void *arg);
void *AddData3(void *arg);

int main()
{
    ADDDATAFUNC funcs[3] = {AddData1, AddData2, AddData3};
    pthread_t pid[3] = {0};
    for (size_t i = 0; i < 3; i++)
        pthread_create(pid + 1, nullptr, funcs[i], nullptr);
    for (size_t i = 0; i < 3; i++)
        pthread_join(*(pid + 1), nullptr);
    g_array.print();
    return 0;
}

void *AddData1(void *arg)
{
    for (size_t i = 0; i < 10; i++)
    {
        g_array.push_back(10 + i);
        usleep(100);
    }
    return 0;
}

void *AddData2(void *arg)
{
    for (size_t i = 0; i < 10; i++)
    {
        g_array.push_back(20 + i);
        usleep(100);
    }
    return 0;
}

void *AddData3(void *arg)
{
    for (size_t i = 0; i < 10; i++)
    {
        g_array.push_back(30 + i);
        usleep(100);
    }
    return 0;
}

上述的处理结果为：

30 0 0 31 0 0 32 0 23 0 0 14 0 0 15 0 0 26 0 16 0 0 28 0 17 0 0 18 0 19

如果将 push_back 的代码改为如下所示：

void push_back(const int &data)
{
    pthread_mutex_lock(&mtx_);
    data_[size] = data;
    usleep(10);
    size++;
    pthread_mutex_unlock(&mtx_);
}

 则结果如下所示：

10 20 30 11 21 12 31 13 22 32 23 14 33 15 24 16 25 34 26 17 35 27 36 18 28 19 37 29 38 39

该结果是正确的，所以后面的代码中 push_back 是线程安全的。

 

（SAW：Game Over！）