linux多进/线程编程（7）——多线程1（线程的创建，回收，分离，设置线程属性等）

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;
}