BOOST c++库学习 之 boost.thread入门实战指南 使用boost.thread库以及读写锁mutex的测试例程

Boost.Thread 库简介

1. 概述

Boost.Thread库是Boost库中专门用于处理多线程编程的模块。它提供了一组跨平台的线程管理和同步工具，帮助开发者在C++中更轻松地编写多线程程序。Boost.Thread的设计目标是使多线程编程更加简单、可靠，同时保持高效和可移植性。

2. Boost.Thread库主要提供以下功能：

2.1. 线程管理相关

• boost::thread

  • boost::thread: 创建和管理线程的类。可以通过传递一个可调用对象（如函数指针、函数对象或lambda表达式）来创建一个线程。
    • 构造函数：boost::thread(boost::function<void()> f)
    • join(): 等待线程完成。
    • detach(): 分离线程，使其在后台运行。

• boost::this_thread::get_id

  • 获取当前线程的ID。

• boost::this_thread::sleep_for

  • 使当前线程休眠指定的时间段。

• boost::this_thread::yield

  • 让出当前线程的执行权。

2.2. 互斥量相关

• boost::mutex

  • 简单的互斥锁，用于保护共享数据的访问。

• boost::recursive_mutex

  • 支持递归锁定的互斥量，允许同一线程多次加锁。

• boost::shared_mutex

  • 读写锁，允许多个线程同时读取数据，但写操作是独占的。

2.3. 条件变量相关

• boost::condition_variable

  • 条件变量，用于线程间的等待和通知机制。

• boost::condition_variable_any

  • 与boost::condition_variable类似，但适用于任何锁类型。

• wait()

  • 阻塞当前线程，直到收到通知。
    • 例：cond_var.wait(lock, predicate);

• notify_one()

  • 通知一个等待的线程继续执行。

• notify_all()

  • 通知所有等待的线程继续执行。

2.4. 锁管理相关

• boost::unique_lock

  • 管理独占锁，通常用于与boost::mutex配合使用。

• boost::shared_lock

  • 管理共享锁，通常用于与boost::shared_mutex配合使用。

• boost::lock_guard

  • RAII风格的锁管理器，自动管理锁的获取和释放。

• boost::try_lock

  • 尝试获取多个锁，如果无法获取所有锁，则释放已经获取的锁。

2.5. 其他

• boost::thread_group

  • 管理一组线程的类，允许同时创建和管理多个线程。

• boost::call_once

  • 保证某个函数或初始化操作只被调用一次。

这些是Boost.Thread库中最常用的一些类和函数。通过这些工具，开发者可以在C++中实现复杂的多线程程序，确保线程间的数据安全性和同步。

3. 应用场景

Boost.Thread库广泛应用于需要并发处理的C++项目中，例如：

• 服务器开发: 在网络服务器中处理多个客户端请求。
• 并行计算: 在科学计算中利用多核CPU进行并行计算。
• 实时系统: 在嵌入式或实时系统中管理并发任务。

boost.thread库以及读写锁、互斥锁的测试例程、操作步骤

以下是一个使用Boost.Thread库的测试实例程序，它结合了读写锁、条件变量和锁管理机制。为了对比，还提供了一个没有使用这些同步机制的例子。

1. 使用同步机制的测试实例程序

#include <iostream>
#include <boost/thread.hpp>
#include <boost/chrono.hpp>

// 全局数据和同步机制
int shared_data = 0;
boost::mutex mtx; // 互斥量
boost::shared_mutex rw_mtx; // 读写锁
boost::condition_variable_any cond_var; // 条件变量

// 写线程函数 - 使用互斥量和条件变量
void writer(int id) {
    boost::this_thread::sleep_for(boost::chrono::milliseconds(100 * id));

    // 使用unique_lock管理互斥量
    boost::unique_lock<boost::mutex> lock(mtx);

    shared_data += id;
    std::cout << "Writer " << id << " updated shared_data to " << shared_data << std::endl;

    // 通知等待条件变量的读者线程
    cond_var.notify_all();
}

// 读线程函数 - 使用读写锁和条件变量
void reader(int id) {
    boost::this_thread::sleep_for(boost::chrono::milliseconds(100 * id));

    // 等待条件变量
    {
        boost::unique_lock<boost::mutex> lock(mtx);
        cond_var.wait(lock, []{ return shared_data > 0; });
    }

    // 使用shared_lock管理读写锁（读锁）
    boost::shared_lock<boost::shared_mutex> read_lock(rw_mtx);
    std::cout << "Reader " << id << " reads shared_data: " << shared_data << std::endl;
}

int main() {
    boost::thread_group writers, readers;

    // 启动写线程
    for (int i = 1; i <= 3; ++i) {
        writers.create_thread(boost::bind(&writer, i));
    }

    // 启动读线程
    for (int i = 1; i <= 5; ++i) {
        readers.create_thread(boost::bind(&reader, i));
    }

    // 等待所有线程完成
    writers.join_all();
    readers.join_all();

    return 0;
}

2. 没有同步机制的对照例子

下面的代码示例没有使用任何同步机制，这样可以看到多线程程序在没有保护共享数据时可能产生的问题。

#include <iostream>
#include <boost/thread.hpp>
#include <boost/chrono.hpp>

// 全局数据
int shared_data = 0;

// 写线程函数 - 无同步机制
void writer(int id) {
    boost::this_thread::sleep_for(boost::chrono::milliseconds(100 * id));

    shared_data += id;
    std::cout << "Writer " << id << " updated shared_data to " << shared_data << std::endl;
}

// 读线程函数 - 无同步机制
void reader(int id) {
    boost::this_thread::sleep_for(boost::chrono::milliseconds(100 * id));

    std::cout << "Reader " << id << " reads shared_data: " << shared_data << std::endl;
}

int main() {
    boost::thread_group writers, readers;

    // 启动写线程
    for (int i = 1; i <= 3; ++i) {
        writers.create_thread(boost::bind(&writer, i));
    }

    // 启动读线程
    for (int i = 1; i <= 5; ++i) {
        readers.create_thread(boost::bind(&reader, i));
    }

    // 等待所有线程完成
    writers.join_all();
    readers.join_all();

    return 0;
}

3. 调试过程

3.1 启动使用同步机制的程序

编译并运行使用同步机制的程序，确保所有读写操作都按照预期执行，并且共享数据的一致性得到保护。

g++ -o boost_thread_sync boost_thread_sync.cpp -lboost_thread -lboost_system -pthread
./boost_thread_sync

3.2 启动没有同步机制的程序

编译并运行没有使用同步机制的程序，观察输出是否混乱或者数据不一致。

g++ -o boost_thread_no_sync boost_thread_no_sync.cpp -lboost_thread -lboost_system -pthread
./boost_thread_no_sync

4. 输出结果

4.1 使用同步机制的程序输出

Writer 1 updated shared_data to 1
Reader 1 reads shared_data: 1
Writer 2 updated shared_data to 3
Reader 2 reads shared_data: 3
Writer 3 updated shared_data to 6
Reader 3 reads shared_data: 6
Reader 4 reads shared_data: 6
Reader 5 reads shared_data: 6

4.2 没有使用同步机制的程序输出

Writer 1 updated shared_data to 1
Writer 2 updated shared_data to 3
Reader 1 reads shared_data: 3
Writer 3 updated shared_data to 6
Reader 2 reads shared_data: 6
Reader 3 reads shared_data: 6
Reader 4 reads shared_data: 3
Reader 5 reads shared_data: 6

5. 输出结果分析

1. 使用同步机制的程序：共享数据在多个线程间保持了一致性，所有线程按照预期顺序读取和更新数据。

2. 没有使用同步机制的程序：由于没有保护共享数据，多个线程同时读取或写入数据可能导致不一致的结果（如某些读线程读取到旧的或中间态的数据）。

6. 总结

通过对比这两个程序，展示了在多线程编程中使用同步机制（如读写锁和条件变量）的重要性。没有这些机制，多线程环境下的数据竞争会导致程序行为不可预测，而使用这些机制可以确保线程安全性和数据一致性。