C++多线程-第三篇-Thread(线程)

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/hffhjh111/article/details/53141324

Thread

//Boost

#include<boost/thread/thread.hpp>

#define BOOST_THREAD_VERSION 4 //使用最新版本，含有1,2,3但只是为了兼容之前程序。

Thread库丰富强大的扩展功能但不在Thread中的未看。

//C++11

#include<thread>

1.Thread_Class简析

特点：

1.线程对象需要一个可调用物，而调用函数的对象默认是拷贝传参，因此要求可调用物和参数类型都支持拷贝构造。所以如果希望传递给线程引用值就要使用ref库进行包装，同时必须保证被引用对象在线程执行期间一直存在，否则会引发为定义行为。

2.线程对象在析构时会调用std::terminate 结束线程的执行，并不会关心线程是否执行完毕，所以要保证函数正确运行完毕必须调用join()等待线程执行函数或者调用detach()分离线程体。

3.Thread实例的析构会导致其表示线程强制终止?

可是测试证实不会！他是在线程中插入结束点等待它自动结束？若线程死锁或者啥的则不会结束，资源也不会释放。

4.Thread对象创建完毕就会执行，不提供Start()，但事实上它含有私有成员函数Start_thread()启动自己。

类摘要：

  
  
Class Thread
{ //不可拷贝
Public:
Thread();
Explicit thread(F f); //传递可调用对象
Thread(F f, A1 a1, A2 a2, ...); //传递可调用对象及参数

Thread(thread&&) noexcept; //转移构造函数(C++11)
Thread& operator = (thread&&) noexcept; //转移赋值函数(C++11)

Bool joinable() const; //是否可join
Void join(); //等待线程
Void detach(); //分离线程

Bool try_join_for(const duration& rel_time); //超时等待(非C++11)
Bool try_join_until(const time_point& t); //超时等待(非C++11)

Void interrupt(); //中断线程(非C++11)
Bool interruption_requested() const; //判断是否被中断(非C++11)

Class id; //内部类线程ID
Id get_id() const; //获得线程id对象
Native_handle_type native_handle(); //获得系统操作相关的handle

Static unsigned hardware_concurrency(); //获得可并发核心数
Static unsigned physical_concurrency(); //获得真实CPU核心数
};

namespace this_thread{
Thread:: id ger_id(); //获得线程ID对象
Void yield(); //允许重复调度线程
Void sleep_nutil(const time_point&t); //睡眠等待
Void sleep_for(const duration& d); //睡眠等待
}
  
  

2.Start_Thread

explicit thread(const boost::function0<void>& threadfunc)： 

boost::function0<void>可以简单看为：一个无返回(返回void)，无参数的函数。这里的函数也可以是类重载operator()构成的函数；该构造函数传入的是函数对象而并非是函数指针，这样一个具有一般函数特性的类也能作为参数传入

用法：

  
  
#include<iostream>
#include<boost/thread/thread.hpp>
#include<boost/chrono.hpp>
#include<boost/bind.hpp>
#include <boost/ref.hpp>
using namespace std;
using namespace boost;

void Alloa(string name)
{
cout << "Alloa! " << name << ". __ Asuna" << endl;
/*for (int i = 0; i < 10; i++)
{
cout << i << ' ';
}*/
}



class mycount
{
int id;
public:
mycount( int d = 0) :id(d){}
void operator()()
{
cout << "Alloa ! " << id << endl;
}
void Say(string name)
{
cout << name << endl;
}
};
class ForThread
{
//类内创建线程
public:
static void Hello()
{
this_thread::sleep_for(boost::chrono::milliseconds( 10000));
cout << "ForTHread::HELLO 类内线程" << endl;
}
static void start()
{
thread t(Hello);
t.join();
}
};
  
  

  
  

int main()
{
cout << "此线程ID" << this_thread::get_id() << endl;
//this_thread::sleep_for(boost::chrono::microseconds(100));//此线程睡眠100MS
//this_thread::yield();//允许CPU调度让出执行权

thread t1, t2;
cout << t1.get_id() << endl;
assert(t1.get_id() == t2.get_id());

//*******************以下皆为拷贝传递**************************//

////////////////////// 1 /////////////////////////////////
thread t1(&Alloa,"YWF"); //都可
thread t2(Alloa, "YWF");
t1.detach();
t1.join();

///////////////////// 2 复杂对象作为参数////////////////////
mycount c(1); //必须重载()
thread thrd1(c); //自动执行c();
thrd1.join();

///////////////////// 3 类内部创建线程 ///////////////////
ForThread Forthrd; //可以设置成仅有一个实例可以运行的哦！
Forthrd.start(); //主线程会等待函数返回哦！

///////////////////// 4 类内部函数在类外创建 ////////////////
mycount my(10);
thread th2(boost::bind(&mycount::Say, &my,"ZGJ"));
cout << "th2.joinable = " <<th2.joinable() << endl;
th2.join();

///*****************引用传参********************************///
string argv1 = "YWFAHX";
thread th2(boost::bind(Alloa, boost::ref(argv1)));


//this_thread::sleep_for(boost::chrono::milliseconds(1000));//此线程睡眠100MS
cout << "END OF MAIN" << endl;
return 0;
}
  
  

3.等待线程结束

Join等待线程

Thread的成员函数joinable可以判断thread对象是否标示了一个可执行的线程。

若joinable返回true,则可调用

一直阻塞等待直到线程结束

Join();  

阻塞等待一定的时间，然后返回，或者等待的线程完毕返回。

Try_join_for();

Try_join_until();

Detach分离线程 -- 将线程托管给系统，不受控制了！

Detach将thread对象与线程执行体手动分离，从此后thread对象不代表任何线程体

Joinable() == false ，从而失去对线程体的控制。

分离后的线程体将不受影响的继续执行，直到函数结束或者随着主线程一起结束。

所以不需要在操作线程体时可利用临时对象启动线程后即可分离。

Thread对象在析构时若其函数仍未执行完毕则自动detach。

Thread_guard()控制thread对象的析构时行为 类似的有scoped_thread()

Thread_guard()是与Lock_guard()类似的辅助类

#include<boost/thread/thread_guard.hpp>

4.中断/结束线程

中断依靠Interrupted()

通过interrupted_requested()检查是否被要求中断.

被中断的线程会抛出一个thread_interrupted异常（一个空类）,应该捕获处理，否则默认动作是终止线程。

线程不是想中断就可以中断，需要等待中断点（手动设置）才可以触发。

Boost::Thread中12个中断点(函数)为

1. Thread::Join()

2. thread::Try_join_for()

3. thread::try_join_until()

4. Condition_variable::Wait()

5. Condition_variable::wait_for()

6. Condition_variable::wait_until()

7. Condition_variable_any::wait()

8. Condition_variable_any::wait_for()

9. Condition_variable_any::wait_until()

10. This_thread::sleep_for()

11. This_thread::sleep_until()

12. This_thread::interruption_point()//不会等待，只起标签作用，到此处可被中断。

启用/禁用中断（选，我没仔细看）

默认线程是可被中断的

但是boost::this_thread里提供了一组函数与类来共同完成现成的中断启/禁用

Interruption_enabled() //检测当前线程是否可中断

Interrupted_requested() //检测当前线程是否被要求中断

类disable_interruption 是一个RAII类型的对象，在构造时关闭线程的中断，析构时自动回复线程的中断状态。在disable_interruption生命周期内线程不可中断，除非使用restore_interruption对象

Restore_interruption只可在disable_interruption的作用域内使用，它在构造时临时打开线程的中断状态，析构时又关闭中断状态。

Code:

  
  
#include<iostream>
#include<boost/thread/thread.hpp>
#include<boost/chrono.hpp>
#include<boost/bind.hpp>
using namespace std;
using namespace boost;


void Alloa(string name)
{
try
{
using namespace this_thread;
assert(interruption_enabled()); //测试是否允许中断
{
disable_interruption dis;
assert(!interruption_enabled()); //此时不允许中断
cout << "Alloa! " << name << ". __ Asuna" << endl;
this_thread::sleep_for(chrono::milliseconds( 2));
interruption_point();
//restore_interruption ri(dis);//下面的中断是否可用
assert(interruption_enabled()); //可用
cout << interruption_enabled() << endl;
interruption_point();
}
assert(interruption_enabled());
cout << "END　Alloa" << endl;
interruption_point();
}
catch ( const thread_interrupted)
{
cout << "thread_interrupted" << endl;
}
}

int main()
{

thread t1(Alloa, "YWF");
//this_thread::sleep_for(chrono::milliseconds(1));
t1.interrupt();
assert(t1.interruption_requested());
t1.join();
return 0;
}
  
  

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/hffhjh111/article/details/53141324