C++——多线程编程（一）std::thread

程序员文章站 2024-01-22 15:46:16

（一）与c++11多线程相关的头文件 c++11 新标准中引入了四个头文件来支持多线程，他们分别是< atomic> ,< thread>,< mutex>,&l...

（一）与c++11多线程相关的头文件

c++11 新标准中引入了四个头文件来支持多线程，他们分别是< atomic> ,< thread>,< mutex>,< condition_variable>和< future>。
?< atomic>：该头文主要声明了两个类, std::atomic 和 std::atomic_flag，另外还声明了一套 c 风格的原子类型和与 c 兼容的原子操作的函数。
?< thread>：该头文件主要声明了 std::thread 类，另外 std::this_thread 命名空间也在该头文件中。
?< mutex>：该头文件主要声明了与互斥量(mutex)相关的类，包括 std::mutex 系列类，std::lock_guard, std::unique_lock, 以及其他的类型和函数。
?< condition_variable>：该头文件主要声明了与条件变量相关的类，包括 std::condition_variable 和 std::condition_variable_any。
?< future>：该头文件主要声明了 std::promise, std::package_task 两个 provider 类，以及 std::future 和 std::shared_future 两个 future 类，另外还有一些与之相关的类型和函数，std::async() 函数就声明在此头文件中。

（二）std::thread

0

0.1 线程状态

在一个线程的生存期内，可以在多种状态之间转换，不同的操作可以实现不同的线程模型，定义许多不同的线程状态，每个状态还可以包含多个子状态，但大体来说，如下几种状态是通用的：

1）就绪：参与调度，等待被执行，一旦被调度选中，立即开始执行

2）运行：占用cpu，正在运行中

3）休眠：暂不参与调度，等待特定事件发生

4）中止：已经运行完毕，等待回收线程资源

0.2 线程环境

线程存在于进程之中，进程内所有全局资源对于内部每个线程都是可见的。

进程内典型全局资源如下：

1）代码区：这意味着当前进程空间内所有的可见的函数代码，对于每个线程来说，也是可见的

2）静态存储区：全局变量，静态空间

3）动态存储区：堆空间

线程内典型的局部资源：

1）本地栈空间：存放本线程的函数调用栈，函数内部的局部变量等

2）部分寄存器变量：线程下一步要执行代码的指针偏移量

1 构造、赋值和拷贝

1.1 构造函数

（1）default ：thread() noexcept;
（2）initialization ：template < class fn, class… args> explicit thread (fn&& fn, args&&… args);
（3）copy [deleted] ：thread (const thread&) = delete;
（4）move ：thread (thread&& x) noexcept;

默认构造函数，创建一个空的 thread 执行对象。初始化构造函数，创建一个 thread对象，该 thread对象可被joinable，新产生的线程会调用 fn 函数，该函数的参数由 args 给出。拷贝构造函数(被禁用)，意味着 thread 不可被拷贝构造。 move 构造函数，调用成功之后 x 不代表任何 thread 执行对象。

注意：可被 joinable 的 thread 对象必须在他们销毁之前被主线程 join 或者将其设置为 detached。

栗子：

#include 
#include 
#include 
#include 
#include 
#include 

void f1(int n)
{
    for (int i = 0; i < 5; ++i) 
    {
        std::cout << "thread " << n << " executing\n";
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
}

void f2(int& n)
{
    for (int i = 0; i < 5; ++i) {
        std::cout << "thread 2 executing\n";
        ++n;
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
}

int main()
{
    int n = 0;
    std::thread t1; // t1 is not a thread
    std::thread t2(f1, n + 1); // pass by value
    std::thread t3(f2, std::ref(n)); // pass by reference
    std::thread t4(std::move(t3)); // t4 is now running f2(). t3 is no longer a thread
    t2.join();
    t4.join();
    std::cout << "final value of n is " << n << '\n';
}

possible output:

thread 1 executing
thread 2 executing
thread 1 executing
thread 2 executing
thread 1 executing
thread 2 executing
thread 1 executing
thread 2 executing
thread 2 executing
thread 1 executing
final value of n is 5

1.2 move赋值操作

move (1)：thread& operator= (thread&& rhs) noexcept;
copy [deleted] (2)：thread& operator= (const thread&) = delete;

move 赋值操作，如果当前对象不可 joinable，需要传递一个右值引用(rhs)给 move 赋值操作；如果当前对象可被 joinable，则 terminate() 报错。

//#include 
//#include 

#include     // std::chrono::seconds
#include   // std::cout
#include     // std::thread, std::this_thread::sleep_for

void thread_task(int n) {
    std::this_thread::sleep_for(std::chrono::seconds(n));
    std::cout << "hello thread "
        << std::this_thread::get_id()
        << " paused " << n << " seconds" << std::endl;
}

/*
* ===  function  =========================================================
*         name:  main
*  description:  program entry routine.
* ========================================================================
*/
int main(int argc, const char *argv[])
{
    std::thread threads[5];
    std::cout << "spawning 5 threads...\n";
    for (int i = 0; i < 5; i++) {
        threads[i] = std::thread(thread_task, i + 1); /******copy********/
    }
    std::cout << "done spawning threads! now wait for them to join\n";
    for (auto& t : threads) {
        t.join();
    }
    std::cout << "all threads joined.\n";

    system("pause");
    return exit_success;
}  /* ----------  end of function main  ---------- */

2 其他成员函数

2.1 get_id ：获取线程 id。

参数：none
返回值：an object of member type thread::id that uniquely identifies the thread (if joinable), or default-constructed (if not joinable)

returns the thread id.

if the thread object is joinable, the function returns a value that uniquely identifies the thread.

if the thread object is not joinable, the function returns a default-constructed object of member type thread::id.

栗子：

// thread::get_id / this_thread::get_id
#include        // std::cout
#include          // std::thread, std::thread::id, std::this_thread::get_id
#include          // std::chrono::seconds

std::thread::id main_thread_id = std::this_thread::get_id();

void is_main_thread() {
  if ( main_thread_id == std::this_thread::get_id() )
    std::cout << "this is the main thread.\n";
  else
    std::cout << "this is not the main thread.\n";
}

int main() 
{
  is_main_thread();
  std::thread th (is_main_thread);
  th.join();
}

output：

this is the main thread.
this is not the main thread.

2.2 joinable ：检查线程是否可被 join。

返回值：false、true
参数：none

returns whether the thread object is joinable.

a thread object is joinable if it represents a thread of execution.

a thread object is not joinable in any of these cases:
?if it was default-constructed.
?if it has been moved from (either constructing another thread object, or assigning to it).
?if either of its members join or detach has been called.

栗子：

// example for thread::joinable
#include        // std::cout
#include          // std::thread

void mythread() 
{
  // do stuff...
}

int main() 
{
  std::thread foo;
  std::thread bar(mythread);

  std::cout << "joinable after construction:\n" << std::boolalpha;
  std::cout << "foo: " << foo.joinable() << '\n';
  std::cout << "bar: " << bar.joinable() << '\n';

  if (foo.joinable()) foo.join();
  if (bar.joinable()) bar.join();

  std::cout << "joinable after joining:\n" << std::boolalpha;
  std::cout << "foo: " << foo.joinable() << '\n';
  std::cout << "bar: " << bar.joinable() << '\n';

  return 0;
}

output (after 3 seconds):

joinable after construction:
foo: false
bar: true
joinable after joining:
foo: false
bar: false

2.3 join：join 线程。

参数：none
返回值：none

the function returns when the thread execution has completed.

直到线程函数被执行完毕，join才返回。this synchronizes the moment this function returns with the completion of all the operations in the thread: this blocks the execution of the thread that calls this function until the function called on construction returns (if it hasn’t yet).

after a call to this function, the thread object becomes non-joinable and can be destroyed safely.

栗子：

// example for thread::join
#include        // std::cout
#include          // std::thread, std::this_thread::sleep_for
#include          // std::chrono::seconds

void pause_thread(int n) 
{
  std::this_thread::sleep_for (std::chrono::seconds(n));
  std::cout << "pause of " << n << " seconds ended\n";
}

int main() 
{
  std::cout << "spawning 3 threads...\n";
  std::thread t1 (pause_thread,1);
  std::thread t2 (pause_thread,2);
  std::thread t3 (pause_thread,3);
  std::cout << "done spawning threads. now waiting for them to join:\n";
  t1.join();
  t2.join();
  t3.join();
  std::cout << "all threads joined!\n";

  return 0;
}

output (after 3 seconds):

spawning 3 threads...
done spawning threads. now waiting for them to join:
pause of 1 seconds ended
pause of 2 seconds ended
pause of 3 seconds ended
all threads joined!

2.4 detach：detach 线程

参数：none
返回值：none

detaches the thread represented by the object from the calling thread, allowing them to execute independently from each other.

both threads continue without blocking nor synchronizing in any way. note that when either one ends execution, its resources are released.

after a call to this function, the thread object becomes non-joinable and can be destroyed safely.

栗子：

#include        // std::cout
#include          // std::thread, std::this_thread::sleep_for
#include          // std::chrono::seconds

void pause_thread(int n) 
{
  std::this_thread::sleep_for (std::chrono::seconds(n));
  std::cout << "pause of " << n << " seconds ended\n";
}

int main() 
{
  std::cout << "spawning and detaching 3 threads...\n";
  std::thread (pause_thread,1).detach();
  std::thread (pause_thread,2).detach();
  std::thread (pause_thread,3).detach();
  std::cout << "done spawning threads.\n";

  std::cout << "(the main thread will now pause for 5 seconds)\n";
  // give the detached threads time to finish (but not guaranteed!):
  pause_thread(5);
  return 0;
}

output (after 5 seconds):

spawning and detaching 3 threads...
done spawning threads.
(the main thread will now pause for 5 seconds)
pause of 1 seconds ended
pause of 2 seconds ended
pause of 3 seconds ended
pause of 5 seconds ended

detach调用之后，目标线程就成为了守护线程，驻留后台运行，与之关联的std::thread对象失去对目标线程的关联，无法再通过std::thread对象取得该线程的控制权。当线程主函数执行完之后，线程就结束了，运行时库负责清理与该线程相关的资源。

当一个thread对象到达生命期终点而关联线程还没有结束时，则thread对象取消与线程之间的关联，目标线程线程则变为分离线程继续运行搜索。

当调用join函数时，调用线程阻塞等待目标线程终止，然后回收目标线程的资源。

2.5 swap：swap 线程。

参数：the thread to swap with
返回值：none

exchanges the underlying handles of two thread objects

栗子

#include 
#include 
#include 

void foo()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

void bar()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

int main()
{
    std::thread t1(foo);
    std::thread t2(bar);

    std::cout << "thread 1 id: " << t1.get_id() << std::endl;
    std::cout << "thread 2 id: " << t2.get_id() << std::endl;

    std::swap(t1, t2);

    std::cout << "after std::swap(t1, t2):" << std::endl;
    std::cout << "thread 1 id: " << t1.get_id() << std::endl;
    std::cout << "thread 2 id: " << t2.get_id() << std::endl;

    t1.swap(t2);

    std::cout << "after t1.swap(t2):" << std::endl;
    std::cout << "thread 1 id: " << t1.get_id() << std::endl;
    std::cout << "thread 2 id: " << t2.get_id() << std::endl;

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