当前位置：首页 > news >正文

C++ —— 线程安全

news 来源：原创 2025/4/26 21:31:41

C++ —— 线程安全

线程安全的基本概念
- 定义
- 共享资源和临界区
三个概念的介绍
如何保证线程安全
- volatile 关键字

线程安全的基本概念

定义

当多个线程同时访问同一个资源（例如变量、数据结构或对象）时，如果程序通过适当的同步机制保证这些访问不会引起数据损坏或不一致性，那么这段代码就是线程安全的。也就是说，无论线程如何调度执行，其结果都与单线程环境下的行为一致。

共享资源和临界区

多个线程同时操作的共享资源（如全局变量、静态变量、共享内存等）如果没有保护，就会产生竞争条件（race condition）。通常，访问共享资源的代码段称为临界区，需要特殊的机制来保证同一时间只有一个线程能进入。

示例代码：

#include <iostream>
#include <thread>
using namespace std;

// 线程任务函数
// 普通函数
void func (int n, const string& s) {
    for (int i = 1; i <= 5; i++) {
        cout << "No." << i << ", n = " << n << ", s = " << s << endl;
        this_thread::sleep_for(chrono::seconds(1));
    }
}

// lambda函数
auto f = [] (int n, const string& s) {
    for (int i = 1; i <= 5; i++) {
        cout << "No." << i << ", n = " << n << ", s = " << s << endl;
        this_thread::sleep_for(chrono::seconds(1));
    }
};

// 仿函数
class mythread_1 {
public:
    void operator() (int n,const string& s) {
        for (int i = 1; i <= 5; i++) {
            cout << "No." << i << ", n = " << n << ", s = " << s << endl;
            this_thread::sleep_for(chrono::seconds(1));
        }
    }
};

// 类的静态成员函数
class mythread_2 {
public:
    static void func (int n, const string& s) {
        for (int i = 1; i <= 5; i++) {
            cout << "No." << i << ", n = " << n << ", s = " << s << endl;
            this_thread::sleep_for(chrono::seconds(1));
        }
    }
};

// 类的非静态成员函数
class mythread_3 {
public:
    void func (int n, const string& s) {
        for (int i = 1; i <= 5; i++) {
            cout << "No." << i << ", n = " << n << ", s = " << s << endl;
            this_thread::sleep_for(chrono::seconds(1));
        }
    }
};

int main () {
    thread t1(func, 1, "普通函数 t1");
    thread t2(func, 2, "普通函数 t2");
    thread t3(f, 3, "lambda函数 t3");
    thread t4(mythread_1(), 4, "仿函数 t4");
    thread t5(mythread_2::func, 5, "静态成员函数 t5");
    mythread_3 mt;
    thread t6(&mythread_3::func, &mt, 6, "非静态成员函数 t6");

    cout << "=== start task ===" << endl;
    for (int i = 1; i <= 5; i++) {
        cout << "" << endl;
        this_thread::sleep_for(chrono::seconds(1));
    }
    cout << "=== task completed ===" << endl;

    t1.join();
    t2.join();
    t3.join();
    t4.join();
    t5.join();
    t6.join();

    return 0;
}

编译运行这段代码，你会发现打印出来的信息有些奇怪。这是因为，cout是全局对象。在目前这个程序中，所有的线程共享cout对象，每个线程都会利用cout向屏幕发送数据。如果同一时间点有多个线程使用cout，打印出来的内容肯定会有些奇怪。
再看一段代码：

#include <iostream>
#include <thread>
using namespace std;

int res = 0; // 定义全局变量 res

void func_add () {
    for (int i = 1; i <= 1000000; i++) {
        res++;
    }
}

int main () {
    thread t1(func_add);
    thread t2(func_add);

    t1.join();
    t2.join();

    cout << "now res = " << res << endl;

    return 0;
}

我的PC某次运行的结果如下：

now res = 1398091

这段代码使用了两个线程t1和t2来并行执行func_add 数，因此会并行对全局变量res进行操作。由于res是一个全局变量，两个线程在对其进行修改时可能会发生竞争条件，即两个线程可能会同时读取和修改res，从而导致res的值不准确。不管运行多少次，结果都不会是2000000。