面试题：C++常对象在多线程环境下的基础特性

Question

在C++多线程环境中，简述常对象的成员函数调用规则，以及这种规则在多线程场景下可能带来的问题及解决思路。

Answer 1

常对象的成员函数调用规则

1. 常对象只能调用常成员函数：常对象是指被const修饰的对象，在C++中，常对象只能调用类的常成员函数。这是因为非常成员函数可能会修改对象的数据成员，而常对象的状态是不允许被修改的。例如：

class MyClass {
public:
    void normalFunction() {
        // 可以修改成员变量
    }
    void constFunction() const {
        // 不能修改成员变量
    }
};

const MyClass obj;
// obj.normalFunction(); // 错误，常对象不能调用非常成员函数
obj.constFunction(); // 正确，常对象可以调用常成员函数

2. 非常对象可以调用常成员函数和非常成员函数：非常对象（未被const修饰的对象）既可以调用常成员函数，也可以调用非常成员函数。因为非常对象的状态可以被修改，调用非常成员函数符合其特性，同时也可以调用常成员函数以保证一定的灵活性。

多线程场景下可能带来的问题

1. 数据竞争：虽然常成员函数在语义上承诺不修改对象的状态，但在多线程环境下，如果常成员函数访问了共享的可修改数据（例如通过指针或引用访问了类外的共享数据），而其他线程也在同时修改这些共享数据，就可能发生数据竞争。例如：

class SharedData {
public:
    int value;
};

class MyClass {
public:
    SharedData* shared;
    void constFunction() const {
        // 虽然MyClass对象状态未变，但shared指向的共享数据可能被其他线程修改
        int localVar = shared->value; 
    }
};

2. 不一致的视图：不同线程对常对象的访问可能由于缓存一致性等问题，看到不一致的数据状态。例如，一个线程修改了常对象中共享数据的一部分，而另一个线程在一段时间内仍然看到旧的值，导致逻辑错误。

解决思路

1. 使用互斥锁：在常成员函数中，如果访问共享数据，使用互斥锁（如std::mutex）来保护共享数据的访问。例如：

class SharedData {
public:
    int value;
    std::mutex mtx;
};

class MyClass {
public:
    SharedData* shared;
    void constFunction() const {
        std::lock_guard<std::mutex> lock(shared->mtx);
        int localVar = shared->value; 
    }
};

2. 使用原子操作：对于简单的共享数据类型（如int），可以使用原子类型（如std::atomic<int>），原子操作保证了在多线程环境下的原子性和顺序一致性，避免数据竞争。例如：

class MyClass {
public:
    std::atomic<int>* sharedValue;
    void constFunction() const {
        int localVar = sharedValue->load(); 
    }
};

3. 线程本地存储：如果可能，将需要的数据存储为线程本地数据（如使用thread_local关键字），这样每个线程都有自己独立的数据副本，避免了共享数据带来的问题。例如：

class MyClass {
public:
    static thread_local int localValue;
    void constFunction() const {
        int localVar = localValue; 
    }
};
thread_local int MyClass::localValue = 0;