Linux 线程学习及示例

头文件：#include <pthread.h>
一、pthread_create 函数
原型：int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine) (void *), void *arg);
功能：创建线程
参数：
thread：指向线程标识符的指针。
attr：线程属性
start_routine：线程运行函数地址
arg：运行函数的参数
返回值：
0：成功
非0：失败

注：
1)pthread_t定义：
typedef unsigned long int pthread_t;

二、pthread_join函数
原型：int pthread_join(pthread_t thread, void **retval);
功能：等待指定线程的结束，回收资源
参数：
thread：被等待的线程标识符
retval：为一个用户定义的指针，它可以用来存储被等待线程的返回值
返回值：
0：成功
非0：失败

三、pthread_attr_init函数
原型：int pthread_attr_init(pthread_attr_t *attr);
功能：初始化一个线程属性对象
参数：
attr：线程属性结构体指针
返回值：
0：成功
非0：失败

四、pthread_attr_destroy函数
原型：int pthread_attr_destroy(pthread_attr_t *attr);
功能：销毁一个线程属性对象
参数：
attr：线程属性结构体指针
返回值：
0：成功
非0：失败

注：
1)pthread_attr_t 结构体说明：
typedef struct
{
int detachstate; // 线程的分离状态
int schedpolicy; // 线程调度策略
structsched_param schedparam; // 线程的调度参数
int inheritsched; // 线程的继承性
int scope; // 线程的作用域
size_t guardsize; // 线程栈末尾的警戒缓冲区大小
int stackaddr_set; // 线程的栈设置
void* stackaddr; // 线程栈的位置
size_t stacksize; // 线程栈的大小
} pthread_attr_t;
2)线程具有属性，用pthread_attr_t表示，在对该结构进行处理之前必须进行初始化，在使用后需要对其去除初始化。
调用pthread_attr_init之后，pthread_t结构所包含的内容就是操作系统实现支持的线程所有属性的默认值。

五、pthread_exit函数
原型：void pthread_exit(void *retval);
功能：退出线程
参数：
retval：函数的返回代码

六、pthread_attr_getdetachstate函数
原型：int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
功能：设置线程分离状态属性
参数：
attr：线程属性结构体指针
detachstate：分离属性值
返回值：
0：成功
非0：失败

七、pthread_attr_getdetachstate函数
原型：int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);
功能：获取线程的分离状态属性
参数：
attr：线程属性结构体指针
detachstate：分离属性值
返回值：
0：成功
非0：失败

注：
PTHREAD_CREATE_DETACHED(1)：设置分离状态
PTHREAD_CREATE_JOINABLE(0)：设置正常状态

八、pthread_self函数
原型：pthread_t pthread_self(void);
功能：获取线程ID

示例代码：
测试1：pthread_join 阻塞等待指定线程结束

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

struct member{
	int num;
	char *name;
};

void *pthread(void *arg)
{
	struct member *temp;
	printf("pthread start!\n");
	
	sleep(2);
	
	temp = (struct member *)arg;
	printf("member->num: %d\n", temp->num);
	printf("member->namme: %s\n", temp->name);
	
	return NULL;
}


int main(int argc, char *argv[])
{
	pthread_t tidp;
	struct member *b;
	
	b = (struct member *) malloc(sizeof(struct member));
	b->num = 1;
	b->name = "hello world";
	
	if ((pthread_create(&tidp, NULL, pthread, (void *)b)) == -1) {
		printf(" create error!\n");
		return 1;
	}

	
	if (pthread_join(tidp, NULL)) {
		printf("thread is not exit...\n");
		return -2;
	}

	printf("Exit main thread\n");
	return 0;
}

执行结果：
pthread start!
member->num: 1
member->namme: hello world
Exit main thread

测试2：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

struct member{
	int len;
	char *data
};

void *func(void *arg)
{
	struct member *memData = (struct member *)arg;
	printf("data len is %d, data is %s\n",memData->len,memData->data);	
	sleep(10);
	printf("thread id =%ld\n", pthread_self());
	printf("pthread end\n");	
}


void main(void)
{
	pthread_attr_t attr;
	pthread_t pthread;
	struct member argMem = {10, "helloworld"};

	pthread_attr_init(&attr);
	pthread_attr_setdetachstate(&attr, 1);
	//pthread_attr_setdetachstate(&attr, 0);
	
	pthread_create(&pthread, &attr, func, (void *)&argMem);	
	pthread_attr_destroy(&attr);	
	sleep(2);
//	pthread_cancel(pthread);
	printf("end\n");
	pthread_join(pthread,NULL);
	
	return ;	
}

注：
1)如果设置成PTHREAD_CREATE_DETACHED状态，则pthread_join不会去阻塞等待指定线程结束,
只有设置成PTHREAD_CREATE_JOINABLE，pthread_join才生效
2)如果在pthread_join之前设置pthread_cancel，那么pthread_join也不会起作用
3)pthread_self 方式获取线程id：pthread_self返回的是posix定义的线程ID
thread id =140557187577600

测试3：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

void *func(void *arg)
{
	printf("%s: %s\n", __func__, (char *)arg);		
}

void *func2(void *arg)
{
	printf("%s: %s\n", __func__, (char *)arg);		
}

void *func3(void *arg)
{
	printf("%s: %s\n", __func__, (char *)arg);		
}

void main(void)
{
	pthread_t t1, t2, t3;
	pthread_attr_t attr;		
	int val;
	pthread_attr_init(&attr);
	pthread_attr_setdetachstate(&attr, 0);
	
	pthread_create(&t1, &attr, func, (void *)"hello this is thread1");	
	pthread_join(t1, NULL);
	pthread_create(&t2, &attr, func2, (void *)"hello this is thread2");	
	pthread_join(t2, NULL);
	pthread_attr_getdetachstate(&attr, &val);
    printf("%d\n",val);

	pthread_create(&t3, &attr, func3, (void *)"hello this is thread3");	
	
	pthread_attr_destroy(&attr);
	pthread_join(t3, NULL);
	printf("hello world\n");
	
}

测试结果：
func: hello this is thread1
func2: hello this is thread2
0
func3: hello this is thread3
hello world