转载一下看到的一个博主的文章，方便后续查看学习
【转载】pthread_join用法（一）
函数pthread_join用来等待一个线程的结束。函数原型为：
extern int pthread_join __P ((pthread_t __th, void**__thread_return));
第一个参数为被等待的线程标识符，第二个参数为一个用户定义的指针，它可以用来存储被等待线程的返回值。这个函数是一个线程阻塞的函数，调用它的函数将一直等待到被等待的线程结束为止，当函数返回时，被等待线程的资源被收回。
一个线程的结束有两种途径，一种是象我们下面的例子一样，函数结束了，调用它的线程也就结束了；另一种方式是通过函数pthread_exit来实现。另外需要说明的是，一个线程不能被多个线程等待，也就是说对一个线程只能调用一次pthread_join，否则只有一个能正确返回，其他的将返回ESRCH 错误。
在Linux中，默认情况下是在一个线程被创建后，必须使用此函数对创建的线程进行资源回收，但是可以设置Threads attributes来设置当一个线程结束时，直接回收此线程所占用的系统资源，详细资料查看Threads attributes。
范例：
//signaltest.c
// 子线程阻塞，等待信号，然后输出字符串
// 主线程从键盘录入字符，给子线程发信号。
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <pthread.h>
#include <time.h>
pthread_t tid;
sigset_t set;
void myfunc()
{
printf("hello
");
}
static void* mythread(void *p)
{
int signum;
while(1){
sigwait(&set,&signum);
if(SIGUSR1 == signum)
myfunc();
if(SIGUSR2 == signum)
{
printf("I will sleep 2 second and exit
");
sleep(2);
break;
}
}
}
int main()
{
char tmp;
void* status;
sigemptyset(&set);
sigaddset(&set,SIGUSR1);
sigaddset(&set,SIGUSR2);
sigprocmask(SIG_SETMASK,&set,NULL);
pthread_create(&tid,NULL,mythread,NULL);
while(1)
{
printf(":");
scanf("%c",&tmp);
if('a' == tmp)
{
pthread_kill(tid,SIGUSR1); //发送SIGUSR1，打印字符串。
}
else if('q'==tmp)
{
pthread_kill(tid,SIGUSR2); //发出SIGUSR2信号，让线程退出，如果发送SIGKILL，线程将直接退出。
pthread_join(tid,&status); //等待线程tid执行完毕，这里阻塞。
printf("finish
");
break;
}
else
continue;
}
return 0;
}
运行结果：
// 如果输入a，子线程打印"hello"，主程序继续等待输入；
// 如果输入q，主程序等待子程序结束。子线程打印"I will sleep 2 second and exit"，并延时两秒后结束。主线程随之打印"finish"，程序结束。
在前面我们提到，可以通过pthread_join()函数来使主线程阻塞等待其他线程退出，这样主线程可以清理其他线程的环境。但是还有一些线程，更喜欢自己来清理退出的状态，他们也不愿意主线程调用pthread_join来等待他们。我们将这一类线程的属性称为detached。如果我们在调用pthread_create()函数的时候将属性设置为NULL，则表明我们希望所创建的线程采用默认的属性，也就是joinable。如果需要将属性设置为detached，则参考下面的例子：
void * start_run(void * arg)
{
//do some work
}
int main()
{
pthread_t thread_id;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
pthread_create(&thread_id,&attr,start_run,NULL);
pthread_attr_destroy(&attr);
sleep(5);
exit(0);
}
在线程设置为joinable后，可以调用pthread_detach()使之成为detached。但是相反的操作则不可以。还
有，如果线程已经调用pthread_join()后，则再调用pthread_detach()则不会有任何效果。
【转载】pthread_join用法（二）
调用pthread_join的线程会阻塞，直到指定的线程返回，调用了pthread_exit，或者被取消。
如果线程简单的返回，那么rval_ptr被设置成线程的返回值，参见范例1；如果调用了pthread_exit，则可将一个无类型指针返回，在pthread_join中对其进行访问，参见范例2；如果线程被取消，rval_ptr被设置成PTHREAD_CANCELED。
如果我们不关心线程的返回值，那么我们可以把rval_ptr设置为NULL。
范例1：
#include <pthread.h>
#include <string.h>
void *thr_fn1(void *arg)
{
printf(“thread 1 returning.
”);
return((void *)1);
}
void *thr_fn2(void *arg)
{
printf(“thread 2 exiting.
”);
return((void *)2);
}
int main()
{
pthread_t tid1,tid2;
void *tret;
pthread_create(&tid1,NULL,thr_fn1,NULL);
pthread_create(&tid2,NULL,thr_fn2,NULL);
pthread_join(tid1,&tret);
printf(“thread 1 exit code %d
”,(int)tret);
pthread_join(tid2,&tret);
printf(“thread 2 exit code %d
”,(int)tret);
exit(0);
}
运行结果：
thread 1 returning.
thread 1 exit code 1.
thread 2 exiting.
thread 2 exit code 2.
范例2：
#include <stdio.h>
#include <pthread.h>
void thread1(char s[])
{
printf("This is a pthread1.
");
printf("%s
",s);
pthread_exit("Hello first!"); //结束线程，返回一个值。
}
void thread2(char s[])
{
printf("This is a pthread2.
");
printf("%s
",s);
pthread_exit("Hello second!");
}
int main(void)
{
pthread_t id1,id2;
void *a1,*a2;
int i,ret1,ret2;
char s1[]="This is first thread!";
char s2[]="This is second thread!";
ret1=pthread_create(&id1,NULL,(void *) thread1,s1);
ret2=pthread_create(&id2,NULL,(void *) thread2,s2);
if(ret1!=0){
printf ("Create pthread1 error!
");
exit (1);
}
pthread_join(id1,&a1);
printf("%s
",(char*)a1);
if(ret2!=0){
printf ("Create pthread2 error!
");
exit (1);
}
printf("This is the main process.
");
pthread_join(id2,&a2);
printf("%s
",(char*)a2);
return (0);
}
运行结果：
[****@XD**** c]$ ./example
This is a pthread1.
This is first thread!
Hello first!
This is the main process.
This is a pthread2.
This is second thread!
Hello second!
【转载】Linux 定时器setitimer()
用法：
#include <sys/time.h>
int getitimer(int which, struct itimerval *value);
int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue);
功能描述：
获取或设定间歇计时器的值。系统为进程提供三种类型的计时器，每一类以不同的时间域递减其值。当计时器超时，信号被发送到进程，之后计时器重启动。
参数：
which：间歇计时器类型，有三种选择
ITIMER_REAL //数值为0，以系统真实的时间来计算，发送的信号是SIGALRM。
ITIMER_VIRTUAL //数值为1，以该进程在用户态下花费的时间来计算，发送的信号是SIGVTALRM。
ITIMER_PROF //数值为2， 以该进程在用户态下和内核态下所费的时间来计算，发送的信号是SIGPROF。
value，ovalue：时间参数，原型如下
struct itimerval {
struct timeval it_interval;
struct timeval it_value;
};
struct timeval {
long tv_sec;
long tv_usec;
};
itimerval结构中的it_value是减少的时间,当这个值为0的时候就发出相应的信号了. 然后再将it_value设置为it_interval值. 也就是先处理it_value中设置的值，为0后发送信号(根据which来判断发送什么信号),之后都是根据it_interval的值发送信号。若 it_value为0，就没有相应的信号产生了。
getitimer()用计时器的当前值填写value指向的结构体。
setitimer()将 value 指向的结构体设为计时器的当前值，如果ovalue不是NULL，将返回计时器原有值。
返回说明：
成功执行时，返回0。失败返回-1，errno被设为以下的某个值
EFAULT：value 或ovalue是不有效的指针
EINVAL：其值不是ITIMER_REAL，ITIMER_VIRTUAL 或 ITIMER_PROF之一
例子：
void sigroutine(int signo)
{
static int count1=0,count2=0;
switch (signo)
{
case SIGALRM:
count1++;
printf("Catch a signal -- SIGALRM
");
printf("count1 = %d
", count1);
signal(SIGALRM, sigroutine);
break;
case SIGVTALRM:
count2++;
printf("Catch a signal -- SIGVTALRM
");
printf("count2 = %d
", count2);
signal(SIGVTALRM, sigroutine);
break;
}
return;
}
int main()
{
struct itimerval value, ovalue, value2;
printf("process id is %d
", getpid());
signal(SIGALRM, sigroutine);
signal(SIGVTALRM, sigroutine);
value.it_value.tv_sec = 2;
value.it_value.tv_usec = 0;
value.it_interval.tv_sec = 3;
value.it_interval.tv_usec = 0;
setitimer(ITIMER_REAL, &value, &ovalue);
value2.it_value.tv_sec = 1;
value2.it_value.tv_usec = 0;
value2.it_interval.tv_sec = 3;
value2.it_interval.tv_usec = 0;
setitimer(ITIMER_VIRTUAL, &value2, &ovalue);
while(1);
}