std::thread

#include <thread>

void ThreadRun1() {
    cout<<"ThreadRun1" << endl;
}

void ThreadRun2(int i) {
    cout << "ThreadRun2: " << i <<endl;
}

std::thread myThread1(ThreadRun1);  
std::thread myThread2(ThreadRun2,57);
myThread2.join();
myThread1.join();
//myThread2.detach();
//myThread1.detach();

类中创建Thread

c++ std::thread 的构建可以传入 class 类别中的函数。AA::a1 前面记得要加上&，第二参数代表的是哪个类别，之后的参数为传入函数所需的参数。例如，std::thread t1(&AA::a1, this)

class AA {
public:
    void a1() {
        std::cout << "a1\n";
    }

    void a2(int n) {
        std::cout << "a2 " << n << "\n";
    }

    void start() {
        std::thread t1(&AA::a1, this);
        std::thread t2(&AA::a2, this, 10);

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

join与detach方式

当线程启动后，一定要在和线程相关联的thread销毁前，确定以何种方式等待线程执行结束。

  • detach方式，启动的线程自主在后台运行，当前的代码继续往下执行，不等待新线程结束。
  • join方式，等待启动的线程完成，才会继续往下执行。

joinable()

可以使用joinable判断是join模式还是detach模式。

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

this_thread

this_thread是一个类，它有4个功能函数 | 函数 | 使用 | Description | |:———–|:———–|:———–| | get_id | std::this_thread::get_id() | 获取线程id | | yield | std::this_thread::yield() | 放弃线程执行，回到就绪状态 | | sleep_for|std::this_thread::sleep_for(std::chrono::seconds(1)); | 暂停1秒 | | sleep_until | 条件执行 | 一分钟后执行 |

using std::chrono::system_clock;
std::time_t tt = system_clock::to_time_t(system_clock::now());
struct std::tm * ptm = std::localtime(&tt);
cout << "Waiting for the next minute to begin...\n";
++ptm->tm_min; //加一分钟
ptm->tm_sec = 0; //秒数设置为0//暂停执行，到下一整分执行
this_thread::sleep_until(system_clock::from_time_t(mktime(ptm)));

mutex

mutex头文件主要声明了与互斥量(mutex)相关的类。mutex提供了4种互斥类型.

类型 说明 Description
std::mutex 最基本的 Mutex 类  
std::recursive_mutex 递归 Mutex 类  
std::time_mutex 定时 Mutex 类  
std::recursive_timed_mutex 定时递归 Mutex 类  

lock与unlock

mutex常用操作：

  • lock()：资源上锁
  • unlock()：解锁资源
  • trylock()：查看是否上锁，它有下列3种类情况：
    1. 未上锁返回false，并锁住；
    2. 其他线程已经上锁，返回true；
    3. 同一个线程已经对它上锁，将会产生死锁。

死锁：是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;

void print_block (int n, char c) 
{
    mtx.lock();
    for (int i=0; i<n; ++i) 
    {
        std::cout << c; 
    }
    std::cout << '\n';
    mtx.unlock();
}

int main ()
{
    std::thread th1 (print_block,50,'');
    std::thread th2 (print_block,50,'$');

    th1.join();
    th2.join();
    return 0;
}