该类封装了thread的create、join、detach等操作。

多线程中系统中将要大量使用线程操作函数。
为了扩展和维护方便，将这些函数风和钻挂在一个类中，也符合oop的理念。

muduo是这样做的：

一个类，来封装需要执行的函数，并捕获线程创建时可能的错误。
该类是一个struct，有一个构造函数用于初始化类中变量。
有一个函数，用于在线程中被调用。

struct ThreadData 
{
  //别名
  typedef boost::function ThreadFunc;
  //数据
  ThreadFunc _func;//被调用的函数
  string _name;  //用于排错的线程名  
  //构造函数  
  ThreadData(const ThreadFunc &func, const string &name):_func(func),_name(name){}
  //被调用的函数
  void runInThread()
  {
    //CurrentThread中的获取当前线程。  
    pid_t   tid=tid();
    //给线程设置名字。可以使用ps -eL查看。用于拍错。
    prctl(PR_SET_NAME,_name.c_str());
    try
    {
      _func();
    }
    catch ()
    {
       //如果出错，设置threadName
    }
  }
}

定义一个通用函数，作为pthread_create的第三个参数，这个函数将调用传入的结构体中的一个函数。

void* start(void* i)
{
  ThreadData *data=static_casti;
  data->runInThread();
  delete data;//这里的应该是栈上的变量吧。不需要
  return NULL;
}

3。然后一类，用来控制线程的执行。相当于一个代理类的感觉。可以先初始化一个线程，等到合适的时候执行。

class Thread
{
//别名
typedef boost::function ThreadFunc;
private；
  ThreadFunc _func;//实际调用的函数
  string _name; //对线程起的名字
  bool _started;//记录是否已经创建过线程
  bool _joined;//记录是否已经等待结束，回收资源。
  pthread_t _pthread;  //线程id用于回收资源
public:
  Thread(const ThreadFunc &func， const string &name):_func(func),_name(name),_started(false),_joided(false),_tid(0),_pthread(0);
  ~Thread()
  {
    if(_started&&!_joined)
    {
        pthread_detach(_pthread);
    }
  }
  void start()
  {
    assert(_started);
    _started=true;
    ThreadData *data=new ThreadData(_func,_name);
    if(pthread_create(&thread,NULL,runInThread,data))
    {
      _started=false;      
    }
    delete data;
  }
  int joid(0
  {
    assert(_joided);
    assert(_started);
    _joined=ture;
    return pthread_join(_pthread,NULL);
  }
}

基础

int pthread_create(pthread_t , const pthread_attr_t,void (func)(void), void *)

创建新的线程,立即执行传入的函数。成功返回0,否则返回错误编号。

在pthread.h库中，但该库不是c的标准哭，所以在编译的时候需要在后面显式的加上-lpthread。

这是多线程的基础。
第一个参数是线程id，pthread_t的结构体。传入后，由函数进行填充。
第二个参数是控制参数。可为空
第三个参数是一个函数指针（也就是函数名）。这个函数必须是void *func(void *)，它有一个参数是void *类型的。如果有多个参数没那么需要在放在一个结构体中。
第四个参数传入的参数指针或者结构体的指针。可为空

#include 

struct arg
{
  int i;
  char c;
};
//func
void *func(void *a)
 {
  //转化后才可以使用
  struct arg *tmp=(struct arg *)a;  
}

int main()
{
  //填充结构体
  struct arg arg1;
  arg1.i=1;
  arg1.c='u'；

  pthread_t tid1;
  int result = pthread_create(&tid1, NULL, func, &arg1);
}

pthread_t pthread_self()和gettid()

判断两个线程是否相同

pthread_t

线程的id

是一个结构体，可已通过pthread_t pthread_self()来返回当前线程的id。同时使用int pthread_equal(pthread_t ,pthread_t)来判断两个线程id是否相同，不同时返回0。

但是，这个结构体在多线程的时候有问题：不同进程中线程的线程id可能相同。所以不是作为判断线程相同的条件。

gettid()

所以，常用gettid()来判断似乎否是同一个线程.
但是，标准c沒有实现这个函数，所以需要使用系统调用。

int syscall()

系统调用函数，返回int
unistd.h

pid_t pid1=(pid_t)syscall(SYS_gettid);

同上使用上述函数来获取tid。
其中SUS_gettid,在sys/syscall.h中。

返回的值作为系统中线程中唯一的id。

其中，进程中唯一线程的pid_t和通过getpid()的返回值相同。

线程回收

等待线程执行结束，和回收资源。

线程在函数执行结束以后，需要回收资源。
线程有两种状态joinable和unjoinable。
unjoinable下，线程所使用的资源不会被释放，直到joinable。

pthread_join(pthread_t,void *)

使函数变为joinable

第一个参数是线程id，第二个参数可以是函数的返回值，如果是NULL表示我们不关心函数的返回值。如果需要返回值，需要先创建对应的结构体，然后传入指针，让函数填充。

程序将会在该语句出堵塞，直到线程执行完毕返回。即使有很多该函数也会依次执行。
int pthread_atfork(void (prepare)(void), void (parent)(void), void (*child)(void));

pthread_detach(pthread_t)

即使函数没执行完也可以使用该函数制定线程的状态

执行该函数后，线程中函数运行结束后直接释放所消耗的资源。

prctl()

可以设置和获取线程的名字

prctl(PR_SET_NAME,"name");
prctl(PR_GET_NAME,buf);//如果没设置那么获取的是值是`getid`

为fork和pthread注册函数

int pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void));

pthread_atfork()在fork()之前调用，当调用fork时，内部创建子进程前在父进程中会调用prepare，内部创建子进程成功后，父进程会调用parent ，子进程会调用child。

3. Thread.h——封装thread

基础