创建线程
#include <pthread.h>
int pthread_create(pthread_t * tidp,const pthread_attr_t *attr,void *(*start_rtn)(void),void *arg)
tidp:线程id
attr:线程属性(通常为空)
start_rtn:线程要执行的函数
arg:start_rtn的参数
注意:因为pthread的库不是linux系统的库,所以在进行编译的时候要加上-lpthread
如:# gcc filename -lpthread
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
struct menber
{
int a;
char *s;
};
/*线程执行函数*/
void *create(void *arg)
{
struct menber *temp;
temp=(struct menber *)arg;
printf("menber->a = %d \n",temp->a);
printf("menber->s = %s \n",temp->s);
return (void *)0;
}
int main(int argc,char *argv[])
{
pthread_t tidp;
int error;
struct menber *b;
/*为结构体指针b分配内存并赋值*/
b=(struct menber *)malloc( sizeof(struct menber) );
b->a = 4;
b->s = "zieckey";
/*创建线程并运行线程执行函数*/
error = pthread_create(&tidp, NULL, create, (void *)b);
if( error )
{
printf("phread is not created...\n");
return -1;
}
sleep(1); //进程睡眠一秒使线程执行完后进程才会结束
printf("pthread is created...\n");
return 0;
}
终止线程
如果进程中任何一个线程中调用exit或_exit,那么整个进程都会终止。线程的正常退出方式有:
(1) 线程从启动例程中返回
(2) 线程可以被另一个进程终止
(3) 线程自己调用pthread_exit函数
线程退出
#include <pthread.h>
void pthread_exit(void * rval_ptr)
功能:终止调用线程
rval_ptr:线程退出返回值的指针。
线程等待
#include <pthread.h>
int pthread_join(pthread_t tid,void **rval_ptr)
功能:阻塞调用线程,直到指定的线程终止。
tid :等待退出的线程id
rval_ptr:线程退出的返回值的指针
thread_join.c
#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
void *thread(void *str)
{
int i;
for (i = 0; i < 3; ++i)
{
sleep(2);
printf( "This in the thread : %d\n" , i );
}
return NULL;
}
int main()
{
pthread_t pth;
int i;
/*创建线程并执行线程执行函数*/
int ret = pthread_create(&pth, NULL, thread, NULL);
printf("The main process will be to run,but will be blocked soon\n");
/*阻塞等待线程退出*/
pthread_join(pth, NULL);
printf("thread was exit\n");
for (i = 0; i < 3; ++i)
{
sleep(1);
printf( "This in the main : %d\n" , i );
}
return 0;
}
线程标识
#include <pthread.h>
pthread_t pthread_self(void)
功能:
获取调用线程的 thread identifier
清除
从pthread_cleanup_push的调用点到pthread_cleanup_pop之间的程序段中的终止动作(包括调用pthread_exit()和异常终止,不包括return)都将执行pthread_cleanup_push()所指定的清理函数。
#include <pthread.h>
void pthread_cleanup_push(void (*rtn)(void *),void *arg)
功能:
将清除函数压入清除栈
rtn:清除函数
arg:清除函数的参数
#include <pthread.h>
void pthread_cleanup_pop(int execute)
功能:
将清除函数弹出清除栈
参数:
execute执行到pthread_cleanup_pop()时是否在弹出清理函数的同时执行该函数,非0:执行; 0:不执行
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
/*线程清理函数*/
void *clean(void *arg)
{
printf("cleanup :%s\n",(char *)arg);
return (void *)0;
}
/*线程1的执行函数*/
void *thr_fn1(void *arg)
{
printf("thread 1 start \n");
/*将线程清理函数压入清除栈两次*/
pthread_cleanup_push( (void*)clean,"thread 1 first handler");
pthread_cleanup_push( (void*)clean,"thread 1 second hadler");
printf("thread 1 push complete \n");
if(arg)
{
return((void *)1); //线程运行到这里会结束,后面的代码不会被运行。由于是用return退出,所以不会执行线程清理函数。
}
pthread_cleanup_pop(0);
pthread_cleanup_pop(0);
return (void *)1;
}
/*线程2的执行函数*/
void *thr_fn2(void *arg)
{
printf("thread 2 start \n");
/*将线程清理函数压入清除栈两次*/
pthread_cleanup_push( (void*)clean,"thread 2 first handler");
pthread_cleanup_push( (void*)clean,"thread 2 second handler");
printf("thread 2 push complete \n");
if(arg)
{
pthread_exit((void *)2);//线程运行到这里会结束,后面的代码不会被运行。由于是用pthread_exit退出,所以会执行线程清理函数。执行的顺序是先压进栈的后执行,即后进先出。
}
pthread_cleanup_pop(0);
pthread_cleanup_pop(0);
pthread_exit((void *)2);
}
int main(void)
{
int err;
pthread_t tid1,tid2;
void *tret;
/*创建线程1并执行线程执行函数*/
err=pthread_create(&tid1,NULL,thr_fn1,(void *)1);
if(err!=0)
{
printf("error .... \n");
return -1;
}
/*创建线程2并执行线程执行函数*/
err=pthread_create(&tid2,NULL,thr_fn2,(void *)1);
if(err!=0)
{
printf("error .... \n");
return -1;
}
/*阻塞等待线程1退出,并获取线程1的返回值*/
err=pthread_join(tid1,&tret);
if(err!=0)
{
printf("error .... \n");
return -1;
}
printf("thread 1 exit code %d \n",(int)tret);
/*阻塞等待线程2退出,并获取线程2的返回值*/
err=pthread_join(tid2,&tret);
if(err!=0)
{
printf("error .... ");
return -1;
}
printf("thread 2 exit code %d \n",(int)tret);
return 1;
}
进行多线程编程,因为无法知道哪个线程会在哪个时候对共享资源进行操作,因此让如何保护共享资源变得复杂,通过下面这些技术的使用,可以解决线程之间对资源的竞争:
1 互斥量Mutex
互斥量从本质上说就是一把锁, 提供对共享资源的保护访问。
创建:
在Linux中, 互斥量使用类型pthread_mutex_t表示。在使用前, 要对它进行初始化:
1)对于静态分配的互斥量, 可以把它设置为默认的mutex,对象PTHREAD_MUTEX_INITIALIZER
2)对于动态分配的互斥量, 在申请内存(malloc)之后, 通过pthread_mutex_init进行初始化, 并且在释放内存(free)前需要调用pthread_mutex_destroy。
#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutexattr_t *attr)
int pthread_mutex_destroy(pthread_mutex_t *mutex)
加锁:
对共享资源的访问, 要使用互斥量进行加锁, 如果互斥量已经上了锁, 调用线程会阻塞, 直到互斥量被解锁。
int pthread_mutex_lock(pthread_mutex_t *mutex)
int pthread_mutex_trylock(pthread_mutex_t *mutex)
返回值: 成功则返回0, 出错则返回错误编号。
trylock是非阻塞调用模式, 如果互斥量没被锁住, trylock函数将对互斥量加锁, 并获得对共享资源的访问权限; 如果互斥量被锁住了,
trylock函数将不会阻塞等待而直接返回EBUSY, 表示共享资源处于忙状态
解锁:
在操作完成后,必须给互斥量解锁,也就是前面所说的释放。这样其他等待该锁的线程才有机会获得该锁,否则其他线程将会永远阻塞。
int pthread_mutex_unlock(pthread_mutex_t *mutex)
互斥量PK信号量:
Mutex是一把钥匙,一个人拿了就可进入一个房间,出来的时候把钥匙交给队列的第一个。
Semaphore是一件可以容纳N人的房间,如果人不满就可以进去,如果人满了,就要等待有人出来。
对于N=1的情况,称为binary semaphore。
Binary semaphore与Mutex的差异:
1). mutex要由获得锁的线程来释放(谁获得,谁释放)。而semaphore可以由其它线程释放
2). 初始状态可能不一样:mutex的初始值是1 ,而semaphore的初始值可能是0(或者为1)。
2 信号灯Semaphore
3 条件变量Conditions