C++线程安全：共享数据的完美守护者("C++线程安全详解：共享数据守护的最佳实践")

原创

ithorizon 6个月前 (10-20) 阅读数 19 #后端开发

C++线程稳固详解：共享数据守护的最佳实践

一、引言

在多线程编程中，共享数据是造成程序差错和性能问题的关键因素之一。在C++中，如果多个线程同时访问和修改同一块数据，就或许出现竞态条件（race condition），造成数据不一致或程序崩溃。由此，确保线程稳固是编写高效、可靠多线程程序的核心。本文将深入探讨C++线程稳固的各种策略，以保护共享数据免受意外破坏。

二、线程稳固的挑战

线程稳固重点面临的挑战包括：

竞态条件：当多个线程同时访问和修改共享数据时，导致不可预测。

死锁：线程因等待其他线程释放资源而无法继续执行，造成程序停滞。

资源泄露：线程未能正确释放已分配的资源，造成内存泄露。

三、互斥锁（Mutex）

互斥锁是最常用的线程同步机制，用于确保同一时间只有一个线程可以访问共享资源。

3.1 std::mutex

在C++11及以后的版本中，标准库提供了std::mutex类，用于创建互斥锁。


        #include 
        #include 
        #include 
        std::mutex mtx;
        void print_block(int n, char c) {
            mtx.lock();
            for (int i = 0; i < n; ++i) { std::cout << c; }
            std::cout << ' ';
            mtx.unlock();
        }
        int main() {
            std::thread t1(print_block, 50, '*');
            std::thread t2(print_block, 50, '$');
            t1.join();
            t2.join();
            return 0;
        }

3.2 std::lock_guard

std::lock_guard是一个作用域锁，它自动在构造时锁定互斥锁，并在析构时释放互斥锁。


        #include 
        #include 
        #include 
        std::mutex mtx;
        void print_block(int n, char c) {
            std::lock_guard guard(mtx);
            for (int i = 0; i < n; ++i) { std::cout << c; }
            std::cout << ' ';
        }
        int main() {
            std::thread t1(print_block, 50, '*');
            std::thread t2(print_block, 50, '$');
            t1.join();
            t2.join();
            return 0;
        }

四、读写锁（Read-Write Lock）

读写锁允许多个线程同时读取共享数据，但写入时需要独占访问。

4.1 std::shared_mutex

在C++17中，标准库引入了std::shared_mutex类，用于创建读写锁。


        #include 
        #include 
        #include 
        std::shared_mutex rw_mutex;
        int count = 0;
        void read_data() {
            std::shared_lock lock(rw_mutex);
            std::cout << "Count is " << count << std::endl;
        }
        void write_data() {
            std::unique_lock lock(rw_mutex);
            ++count;
        }
        int main() {
            std::thread t1(read_data);
            std::thread t2(write_data);
            std::thread t3(read_data);
            t1.join();
            t2.join();
            t3.join();
            return 0;
        }

五、原子操作（Atomic Operations）

原子操作可以确保对数据的操作在单个机器指令中完成，从而避免竞态条件。

5.1 std::atomic

std::atomic模板类用于创建原子类型，赞成原子操作。


        #include 
        #include 
        #include 
        std::atomic counter(0);
        void increment() {
            for (int i = 0; i < 1000; ++i) {
                ++counter;
            }
        }
        int main() {
            std::thread t1(increment);
            std::thread t2(increment);
            t1.join();
            t2.join();
            std::cout << "Counter value is " << counter << std::endl;
            return 0;
        }

六、条件变量（Condition Variables）

条件变量用于在线程之间同步，通常与互斥锁结合使用，以等待某个条件设立。

6.1 std::condition_variable

std::condition_variable允许一个线程在某些条件不满足时挂起，直到另一个线程通知条件变量。


        #include 
        #include 
        #include 
        #include 
        std::mutex mtx;
        std::condition_variable cv;
        bool ready = false;
        void do_work() {
            std::unique_lock lock(mtx);
            while (!ready) {
                cv.wait(lock);
            }
            std::cout << "Work done" << std::endl;
        }
        int main() {
            std::thread t(do_work);
            std::unique_lock lock(mtx);
            ready = true;
            cv.notify_one();
            t.join();
            return 0;
        }