原文作者:aircraft

原文链接:https://www.cnblogs.com/DOMLX/p/10914162.html

    

      最近是恰好写了一些c++11多线程有关的东西,就写一下笔记留着以后自己忘记回来看吧,也不是专门写给读者看的,我就想到哪就写到哪吧

  c++11呢,就是c++升级之后的一个版本,现在马上就出c++20了,里面增加了很多对多线程支持的类,让多线程编程更加简单了,好了废话不多说,先来建立一个简单的多线程编程案例,看看c++11下多线程编程创建到底有多么的简单。

1.创建一个简单的多线程案例:

首先导入#include<thread>---用于创建线程

其次导入#include<chrono>--用于时间延时 获取时间之类的

好了知道这些参数意思就行了,看一下代码:

#include<windows.h>
#include <iostream>
#include <chrono>
#include <thread>
using namespace std;

int number = 1;

int ThreadProc1()
{
    while (number < 100)
    {
        cout << "thread 1 :" << number << endl;
        ++number;
       this_thread::sleep_for(std::chrono::milliseconds(10));
    }

    return 0;
}

int ThreadProc2()
{
    while (number < 100)
    {
        cout << "thread 2 :" << number << endl;
        ++number;
        this_thread::sleep_for(std::chrono::milliseconds(10));
    }

    return 0;
}

int main()
{
    thread t1(ThreadProc1);
    thread t2(ThreadProc2);

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

    system("pause");
    return 0;
}

  join()就是阻塞线程,直到线程函数执行完毕,如果函数有返回值,在这里会直接忽略。阻塞的目的就是让Main主线程等待一下创建的线程,免得我函数还在跑,程序就直接结束了。

  如果不想阻塞在这里就将join()换成使用线程的detach()方法,将线程与线程对象分离,线程就可以继续运行下去,并且不会造成影响。

  从示例可以看到c++11下创建多线程多么方便了吧 ,比在Linux下用posix创建还简便,而这个也是可以在windows使用的(想想windows下多线程的代码,看着都头疼好吧,乱七八糟一大堆)。

2.互斥量的使用

  跟往常的多线程一样,多线程在运行过程中都会对临界区进行访问,也就是一起访问共享资源。这样就会造成一个问题,当两个线程都要对一个变量int value值假如为11,加一时,线程一取出11 进行加一还没有存入value,这时候线程二又取得value的11进行加一,然后线程一存入12,线程二又存入12,这就导入两个线程访问冲突,也就是临界区问题。所以引进互斥量来解决。

导入#include <mutex>

代码案例:

一个线程对变量number进行加一100次,另外一个减一100次,最后结果应该还是原来的值0。

#include<windows.h>
#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
using namespace std;

int number = 0;
mutex g_lock;

int ThreadProc1()
{

    for (int i = 0; i < 100; i++)
    {
        g_lock.lock();
        ++number;
        cout << "thread 1 :" << number << endl;
        g_lock.unlock();
        this_thread::sleep_for(std::chrono::milliseconds(10));
    }

    return 0;
}

int ThreadProc2()
{

    for (int i = 0; i < 100; i++)
    {
        g_lock.lock();
        --number;
        cout << "thread 2 :" << number << endl;
        g_lock.unlock();
        this_thread::sleep_for(std::chrono::milliseconds(10));
    }

    return 0;
}

int main()
{
    thread t1(ThreadProc1);
    thread t2(ThreadProc2);

    t1.detach();
    t2.detach();

    system("pause");
    return 0;
}

上面的每次都要对mutex变量进行锁以及解锁,有时候忘记解锁就凉凉了。所以c++11还提供了一个lock_guard类,它利用了RAII机制可以保证安全释放mutex。

在std::lock_guard对象构造时,传入的mutex对象(即它所管理的mutex对象)会被当前线程锁住。在lock_guard对象被析构时,它所管理的mutex对象会自动解锁,不需要程序员手动调用lock和unlock对mutex进行上锁和解锁操作。lock_guard对象并不负责管理mutex对象的生命周期,lock_guard对象只是简化了mutex对象的上锁和解锁操作,方便线程对互斥量上锁,即在某个lock_guard对象的生命周期内,它所管理的锁对象会一直保持上锁状态;而lock_guard的生命周期结束之后,它所管理的锁对象会被解锁。程序员可以非常方便地使用lock_guard,而不用担心异常安全问题。

代码:

#include<windows.h>
#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
using namespace std;

int number = 0;
mutex g_lock;

int ThreadProc1()
{
    lock_guard<mutex> loker(mutex);
    for (int i = 0; i < 100; i++)
    {
        ++number;
        cout << "thread 1 :" << number << endl;

    }
    //this_thread::sleep_for(std::chrono::milliseconds(100));
    return 0;
}

int ThreadProc2()
{
    lock_guard<mutex> loker(mutex);
    for (int i = 0; i < 100; i++)
    {
        --number;
        cout << "thread 2 :" << number << endl;
        //this_thread::sleep_for(std::chrono::milliseconds(10));
    }

    return 0;
}

int main()
{
    thread t1(ThreadProc1);
    thread t2(ThreadProc2);

    t1.detach();
    t2.detach();

    system("pause");
    return 0;
}

除了lock_guard,之外c++11还提供了std::unique_lock

#include <iostream>       // std::cout
#include <thread>         // std::thread
#include <mutex>          // std::mutex, std::unique_lock
#include <vector>

std::mutex mtx;           // mutex for critical section
std::once_flag flag;        //定义一个once_flag类型的变量作为call_once参数,
                                    //用std::call_once来保证多线程环境中只被调用一次
void print_block (int n, char c) {
    //unique_lock有多组构造函数, 这里std::defer_lock不设置锁状态
    std::unique_lock<std::mutex> my_lock (mtx, std::defer_lock);
    //尝试加锁, 如果加锁成功则执行
    //(适合定时执行一个job的场景, 一个线程执行就可以, 可以用更新时间戳辅助)
    if(my_lock.try_lock()){
        for (int i=0; i<n; ++i)
            std::cout << c;
        std::cout << '\n';
    }
}

void run_one(int &n){
    std::call_once(flag, [&n]{n=n+1;}); //只执行一次, 适合延迟加载; 多线程static变量情况
}

int main () {
    std::vector<std::thread> ver;
    int num = 0;
    for (auto i = 0; i < 10; ++i){
        ver.emplace_back(print_block,50,'*');
        ver.emplace_back(run_one, std::ref(num));
  //emplace_back比push_back更好 是c++11增加的
    }

    for (auto &t : ver){
        t.join();
    }
    std::cout << num << std::endl;
    return 0;
}                    

3.原子变量的使用

  在新标准C++11,引入了原子操作的概念,原子操作更接近内核,并通过这个新的头文件提供了多种原子操作数据类型,例如,atomic_bool,atomic_int等等,如果我们在多个线程中对这些类型的共享资源进行操作,编译器将保证这些操作都是原子性的,也就是说,确保任意时刻只有一个线程对这个资源进行访问,编译器将保证,多个线程访问这个共享资源的正确性。从而避免了锁的使用,提高了效率。

  上面我们用互斥锁来实现加一百次,减少一百次。使用原子变量会更加简洁。

#include<windows.h>
#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
#include <atomic>
using namespace std;

atomic<int> number(0);//定义原子变量 一次只允许一个线程对其进行访问
//int number = 0;
//mutex g_lock;

int ThreadProc1()
{
    //lock_guard<mutex> loker(mutex);
    for (int i = 0; i < 100; i++)
    {
        ++number;
        cout << "thread 1 :" << number << endl;

    }
    //this_thread::sleep_for(std::chrono::milliseconds(100));
    return 0;
}

int ThreadProc2()
{
    //lock_guard<mutex> loker(mutex);
    for (int i = 0; i < 100; i++)
    {
        --number;
        cout << "thread 2 :" << number << endl;
        //this_thread::sleep_for(std::chrono::milliseconds(10));
    }

    return 0;
}

int main()
{
    thread t1(ThreadProc1);
    thread t2(ThreadProc2);

    t1.detach();
    t2.detach();

    system("pause");
    return 0;
}

可以看到使用了原子变量之后,代码简化了很多,以及以后对某些共享资源我们都可以酌情的定义为原子变量类型,很方便有木有。。。。。

  本来想写完几个c++11多线程常用的函数和操作的,但是有点想去看一下哥斯拉2,但是哥斯拉1还没看,先去看哥斯拉1好了  今天就先写这么多了hhhhhh

05-24 11:01