Question

在多线程情况下，每个类是否共享该类的静态成员？例如，类具有静态数据成员，如下所示：

class A {
  public:
    static int count;
    ...
};
int A::count(0);

或者，处理是每个线程获取静态数据的单独实例，或者每个进程是否共同？理想情况下，它应该是每个进程一个并在线程之间共享。我有pthreads并行运行类静态成员。提前感谢您的意见。

Answer 1

class A{
public:
        static int a;
        A(int count);
        ~A();
        int inc();
        void print();
};
int A::a = 0;
A::A(int count)
{ a = count; }
A::~A()
{ a = -1; }
int A::inc()
{ a=a+1; }
void A::print()
{ cout<<"value:"<<a<<"\n"; }

void *foo(void *p)
{
        class A *aa = new A(0);
        aa->inc();
        aa->print();
        sleep(5);
        cout<<"foo: ";
        aa->print();
        aa->inc();
        cout<<"foo again: ";
        aa->print();
        delete aa;
}
void *boo(void *p)
{
        class A *bb = new A(10);
        bb->inc();
        sleep(1);
        bb->print();
        sleep(2);
        cout<<"boo: ";
        bb->print();
        delete bb;
}

int main()
{
        pthread_t tid,tid2;
        int ret = pthread_create(&tid,NULL,foo,NULL);
        if(ret < 0)
                cout<<"error1";
        ret = pthread_create(&tid2,NULL,boo,NULL);
        if(ret < 0)
                cout<<"error2";
        pthread_join(tid,NULL);
        pthread_join(tid2,NULL);

return 0;
}

以下内容的输出为

value:1
value:11
boo: value:11
foo: value:-1
foo again: value:0

我认为这澄清了，当然你需要使用同步来避免异常行为。

Answer 2

每个类定义一次静态成员变量，并且在C ++ 11标准§11“成员访问控制”中定义了程序其他部分的“可访问性”。

在执行函数main之前，以线程安全的方式执行静态成员变量初始化。

但是，从至少一个线程修改变量的不同线程访问变量（类或实例）需要同步原语，如内存屏障，互斥等。否则，您的程序具有“未定义的行为”。

Answer 3

静态成员在同一进程中的线程之间共享。所有线程都会看到相同的变量。

Answer 4

所有线程共享一个类的常见静态成员。线程只是一个进程中带有剪贴簿（堆栈）的可执行序列。它们共享进程的内存。而且由于静态成员属于类，因此它们不会被复制为每个例子。

在线程之间共享类的静态数据

4 个答案: