初探C++11 Thread

Thread

开启一个线程

使用c++11开启一个线程是比较简单的，如下：

#include<iostream>
#include<thread>
using namespace std;

void hello()
{
    cout<<"hello kitty"<<endl;
}

int main()
{
    std::thread t(hello);
     t.join();
     return 0;
}

输出结果：

也可以通过函数对象的方式

#include<iostream>
#include<thread>
using namespace std;


class Say_hello
{
public:
    void operator()(){cout<<"hello";}
};


int main()
{
    Say_hello hello;
    std::thread t(hello);
    t.join();
    return 0;
}

输出结果：

带参数的函数

当函数自身有参数时，形参可以直接写在开启线程的函数参数的后面，如：

thread  t( function , t1 , t2 , ...)

比如说下面这2个例子

#include<iostream>
#include<thread>
using namespace std;


class Say_hello
{
public:
    enum {times = 2};
    void operator()(int n = times)
    {
        for(int i=0;i!=n;i++)
            cout<<"hello"<<endl;
    }
};


int main()
{
    Say_hello hello;
    std::thread t(hello);
    t.join();
    return 0;
}

不带参数时，输出结果为：

带参数时，输出结果为：

int main()
{
    Say_hello hello;
    std::thread t(hello,5);
    t.join();
    return 0;
}

锁的实现

多线程为了实现线程安全，当访问共享数据时，要避免几个线程同时访问，以免造成竞争条件（race condition）

下面举了一个简单的例子，用锁来实现同步。

一共10张票，开4个线程来卖票。

#include<iostream>
#include<thread>
#include<mutex>
using namespace std;

int tickets_count = 10;
mutex a_mutex;

void sale()
{
    lock_guard<mutex> guard(a_mutex);
    //a_mutex.lock();
    while(tickets_count>0)
    {
       cout<<tickets_count--<<endl;
    }
     //a_mutex.unlock();
}

int main()
{
    std::thread t1(sale);
    std::thread t2(sale);
    std::thread t3(sale);
    std::thread t4(sale);
    t1.join();
    t2.join();
    t3.join();
    t4.join();
    return 0;
}

如果不加锁，可能造成重复，输出混乱（std::out 也不是线程安全）

通过对临界区加锁来尽量实现线程安全。

输出结果为：

初探C++11 Thread,古老的榕树,5-wow.com