pthread_create    　　　　　　　　创建线程

pthread_exit  　　　　　　　　　　 终止线程

pthread_join  　　　　　　　　 　　回收进程

pthread_detach  　　　　　　　 　线程分离

pthread_attr_setdetachstate 　　设置线程属性

#include <pthread.h>

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);

* It calls pthread_exit(3), specifying an exit status value that is available to another thread in the same process that calls pthread_join(3).

* It returns from start_routine().  This is equivalent to calling pthread_exit(3) with the value supplied in the return statement.

* It is canceled (see pthread_cancel(3)).

* Any of the threads in the process calls exit(3), or the main thread performs a return from main().  

简言之就是以下几种可能：
1.执行新线程的函数“走完了”；
2.新线程本身或者与之join的线程执行“终止线程”的方法pthread_exit；
3.取消创建该线程pthread_cancel；
4.其他线程执行推出exit，或者主线程return弹（函数）栈

终止调用它的线程并返回一个指向某个对象的指针。

#include <stdio.h>

#include <unistd.h>

#include <pthread.h>

void* thr(void* arg) {

  printf("i am a thread! pid = %d, tid = %ld\n", getpid(), pthread_self());

  //pthread_exit((void*)100);

//  return nullptr;

}

int main(int argc, char* argv[]) {

  /*

   * int pthread_create(pthread_t *thread, const pthread_attr_t *attr,

                          void *(*start_routine) (void *), void *arg);

  */

  pthread_t tid { 0 };

  pthread_create(&tid, nullptr, thr, nullptr);

  printf("i am a main thread! pid = %d, tid = %ld\n", getpid(), pthread_self());

  //sleep(1);

  /*1. 如果添加pthread_exit()在主线程，则主线程马上退出，不在执行主线程下面的程序，但是主线程中启动的其他线程继续执行，程序不会马上退出，等待子线程执行完毕退出。

  2. 如果不添加，主线程不等待子线程执行完毕，程序直接退出，子线程可能没有执行完毕。*/

  pthread_exit(nullptr);

  //return 0;// no use, never exec

}

上面的代码中子线程创建成功依赖于，主线程要么是推出的很慢（有耗时操作）来保证一定会创建子线程，要么是加上pthread_exit，我们往往不想这么做，因此介绍

pthread_join  

#include <pthread.h>

int pthread_join(pthread_t thread, void **retval);

The  pthread_join() function  waits for the thread specified by thread to terminate. wait()方法用来回收进程，是阻塞的，类比，pthread_join也是阻塞的，直至指定的进程终止才会执行后面的代码。

If that thread has already terminated, then pthread_join() returns immediately.  

The thread specified by thread must be joinable.

#include <stdio.h>

#include <unistd.h>

#include <pthread.h>

#include <stdlib.h>

void* thr(void* arg) {

  printf("i am a thread! pid = %d, tid = %ld\n", getpid(), pthread_self());

  sleep(3);

  pthread_exit((void*)1004);

//  return (void*)100;

}

int main(int argc, char* argv[]) {

  /*

   * int pthread_join(pthread_t thread, void **retval);

  */

  pthread_t tid { 0 };

  pthread_create(&tid, nullptr, thr, nullptr);

  printf("i am a main thread! pid = %d, tid = %ld\n", getpid(), pthread_self());

  void* ret = nullptr;

  pthread_join(tid, &ret);//回收子线程，pthread_join会阻塞，直到子线程退出

  printf("ret exit with %ld\n", (long)ret);

  //sleep(1);

  /*

   * 此处主线程加pthread_exit仅用来回收主线程，不影响子线程创建，因为pthread_join的作用*/

  pthread_exit(nullptr);

   //return 0; no use there

}

线程默认属性就是joinable，依赖于创建该线程的“父线程”（其实线程之间不存在父子关系），但是可以修改线程属性。

修改方法有两种，1是使用函数pthread_detach，2是设置属性pthread_attr_setdetachstate。

当线程被分离（detached）后，这个线程的回收就交给操作系统，就不是用户可以控制的了。

#include <pthread.h>

int pthread_detach(pthread_t thread);

The  pthread_detach()  function  marks the thread identified by thread as detached.  

When a detached thread terminates, its resources are automatically released back to the system without the


need for another thread to join with the terminated thread.

#include <pthread.h>

int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);

int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);

The  pthread_attr_setdetachstate()  function  sets  the  detach  state  attribute  of the thread attributes object referred to by attr to the value specified in detachstate.  

The detach state attribute determines whether a thread created using the thread attributes object attr will be created in a joinable or a detached state.


The following values may be specified in detachstate:

PTHREAD_CREATE_DETACHED

      Threads that are created using attr will be created in a detached state.

PTHREAD_CREATE_JOINABLE

      Threads that are created using attr will be created in a joinable state.

The default setting of the detach state attribute in a newly initialized thread attributes object is PTHREAD_CREATE_JOINABLE.（默认是joinable，可以设置为detached）

The pthread_attr_getdetachstate() returns the detach state attribute of the thread attributes object attr in the buffer pointed to by detachstate.

#include <stdio.h>

#include <pthread.h>

#include <string.h>

void * thr(void * arg) {

  printf("i am child thread \n");

  return nullptr;

}

int main(int argc, char* argv[]) {

  pthread_attr_t attr;

  pthread_attr_init(&attr);

  /*

   * 当设置为PTHREAD_CREATE_JOINABLE时，下面可以用pthread_join回收，但是如果设置为PTHREAD_CREATE_DETACHED则不可以

   * */

  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

  pthread_t tid {0};

  pthread_create(&tid, &attr, thr, nullptr);

  int ret = 0;

  if ((ret = pthread_join(tid, nullptr)) > 0) {

    //printf("join err:%ld, %s\n", (long)ret, strerror((long)ret));

    printf("join err:%d, %s\n", ret, strerror(ret));

  }

  pthread_attr_destroy(&attr);

  return 0;

}

#include <stdio.h>

#include <unistd.h>

#include <pthread.h>

void * thr(void * arg) {

//  malloc();

  printf("i am child thread, tid = %ld, arg = %ld\n", pthread_self(), (long)arg);

  //return nullptr;

  return (void *)(100 + (long)arg);

}

int main(int argc, char* argv[]) {

  pthread_t tid[5];

  int length = sizeof(tid) / sizeof(pthread_t);

  printf("**********************length = %d\n", length);

  for (long i = 0; i < length; ++i) {

    /* (void*)i :

     * 这里不能这样写，最好是先在堆区创建，再传进去，用完了在外面释放，这样保证数据没问题。

     * 如果直接传地址，可能在创建子线程的过程中，数据发生了变化（指向的地址也变了），这样传参不稳定，有问题。

     * */

    pthread_create(&tid[i], nullptr, thr, (void*)i);

  }

  for (int i = 0; i < length; ++i) {

    void* ret = nullptr;

    pthread_join(tid[i], &ret);

    printf("i == %d, ret == %ld\n", i, (long)ret);

  }

  return 0;

}