linux多线程编程,你还在用sleep么?用pthread_cond_timedwait吧

摘要:多线程编程中,线程A循环计算,然后sleep一会接着计算(目的是减少CPU利用率);存在的问题是,如果要关闭程序,通常选择join线程A等待线程A退出,可是我们必须等到sleep函数返回,该线程A才能正常退出,这无疑减慢了程序退出的速度。当然,你可以terminate线程A,但这样做很不优雅,且会存在一些未知问题。采用pthread_cond_timedwait(pthread_cond_t * cond, pthread_mutex_t *mutex, const struct timespec * abstime)可以优雅的解决该问题,设置等待条件变量cond,如果超时,则返回;如果等待到条件变量cond,也返回。本文暂不将内部机理,仅演示一个demo。

首先,看这段代码,thr_fn为一个线程函数:
bool flag = true;
void * thr_fn(void * arg)
{
while (flag)
{
printf(“.\n”);
sleep(10);
}
printf(“thread exit\n”);
}

int main()
{
pthread_t thread;
if (0 != pthread_create(&thread, NULL, thr_fn, NULL))
{
printf(“error when create pthread,%d\n”, errno);
return 1;
}

char c ;
while ((c = getchar()) != ‘q’);

printf(“Now terminate the thread!\n”);
flag = false;
printf(“Wait for thread to exit\n”);
pthread_join(thread, NULL);
printf(“Bye\n”);
return 0;
}

输入q后,需要等线程从sleep中醒来(由挂起状态变为运行状态),即最坏情况要等10s,线程才会被join。采用sleep的缺点:不能及时唤醒线程。
采用pthread_cond_timedwait函数实现的如下:

  1. include
  2. include
  3. include
  4. include
  5. include

pthread_t thread;
pthread_cond_t cond;
pthread_mutex_t mutex;
bool flag = true;

void * thr_fn(void * arg)
{
struct timeval now;
struct timespec outtime;
pthread_mutex_lock(&mutex);
while (flag)
{
printf(“.\n”);
gettimeofday(&now, NULL);
outtime.tv_sec = now.tv_sec + 5;
outtime.tv_nsec = now.tv_usec * 1000;
pthread_cond_timedwait(&cond, &mutex, &outtime);
}
pthread_mutex_unlock(&mutex);
printf(“thread exit\n”);
}

int main()
{
pthread_mutex_init(&mutex, NULL);
pthread_cond_init(&cond, NULL);
if (0 != pthread_create(&thread, NULL, thr_fn, NULL))
{
printf(“error when create pthread,%d\n”, errno);
return 1;
}
char c ;
while ((c = getchar()) != ‘q’);
printf(“Now terminate the thread!\n”);
flag = false;
pthread_mutex_lock(&mutex);
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);
printf(“Wait for thread to exit\n”);
pthread_join(thread, NULL);
printf(“Bye\n”);
return 0;
}

说明(翻译摘要中提供的连接,翻译的不好,凑合的看吧):

pthread_cond_timedwait()函数阻塞住调用该函数的线程,等待由cond指定的条件被触发(pthread_cond_broadcast() or pthread_cond_signal())。

当pthread_cond_timedwait()被调用时,调用线程必须已经锁住了mutex。函数pthread_cond_timedwait()会对mutex进行【解锁和执行对条件的等待】(原子操作)。这里的原子意味着:解锁和执行条件的等待是原则的,一体的。(In this case, atomically means with respect to the mutex and the condition variable and other access by threads to those objects through the pthread condition variable interfaces.)

如果等待条件满足或超时,或线程被取消,调用线程需要在线程继续执行前先自动锁住mutex,如果没有锁住mutex,产生EPERM错误。即,该函数返回时,mutex已经被调用线程锁住。

等待的时间通过abstime参数(绝对系统时间,过了该时刻就超时)指定,超时则返回ETIMEDOUT错误码。开始等待后,等待时间不受系统时钟改变的影响。

尽管时间通过秒和纳秒指定,系统时间是毫秒粒度的。需要根据调度和优先级原因,设置的时间长度应该比预想的时间要多或者少点。可以通过使用系统时钟接口gettimeofday()获得timeval结构体。

注: 为了可靠的使用条件变量和确保不忘记对条件变量的唤醒操作,应该采用一个bool变量和mutex变量同条件变量配合使用。如本文demo。




最近开始入手网络编程领域,简单的学习了PThread的几个库方法,然后就开始进项目组学习了。遇到的最大问题就是死锁问题,因为我用的方法是:
     pthread_cond_wait()和 pthread_cond_signal() 来控制的,有的时候看着明明是对的或者说是单步调试的情况下是正确的,但是一运行就卡住不动了,实在是太郁闷了,这个时候我发现了一个有用的函数:
pthread_cond_timedwait
   (pthread_cond_t * _cond,pthread_mutex_t * _mutex,_const struct timespec * _abstime);
这个函数的解释为:比函数pthread_cond_wait()多了一个时间参数,经历abstime段时间后,即使条件变量不满足,阻塞也被解除。
一看到后面这句话,就比较激动,这样的话,我只需要把pthread_cond_wait函数替换为 pthread_cond_timedwait函数,这样即使有的时候发生死锁了,也可以让程序自己解开,重新进入正常的运行状态.好,开始学习这个函数.
     这个函数和pthread_cond_wait主要差别在于第三个参数,这个_abstime,从函数的说明来看,这个参数并不是像红字所描述的经历了abstime段时间后,而是到达了abstime时间,而后才解锁,所以这里当我们用参数的时候不能直接就写个时间间隔,比如5S,而是应该写上到达的时间点.所以初始化的过程为:
  struct timespec timeout;  //定义时间点
  timeout.tv_sec=time(0)+1; //time(0) 代表的是当前时间 而tv_sec 是指的是秒
  timeout.tv_nsec=0;             //tv_nsec 代表的是纳秒时间
    这样这个结构体的意思是,当函数到达到距离当前时间1s的时间点的时候,线程自动苏醒。然后再调用 pthread_cond_timedwait的方法就完全OK. 顺便再附上linux下所有的时间代表含义.
   

关于Linux下时间编程的问题:

1. Linux下与时间有关的结构体

struct timeval

{

int tv_sec;

int tv_usec;

};

其中tv_sec是由凌晨开始算起的秒数,tv_usec则是微秒(10E-6 second)。

struct timezone

{

int tv_minuteswest;

int tv_dsttime;

};

tv_minuteswest是格林威治时间往西方的时差,tv_dsttime则是时间的修正方式。

struct timespec

{

long int tv_sec;

long int tv_nsec;

};

tv_nsec是nano second(10E-9 second)。

struct tm

{

int tm_sec;

int tm_min;

int tm_hour;

int tm_mday;

int tm_mon;

int tm_year;

int tm_wday;

int tm_yday;

int tm_isdst;

};

tm_sec表「秒」数,在[0,61]之间,多出来的两秒是用来处理跳秒问题用的。

tm_min表「分」数,在[0,59]之间。

tm_hour表「时」数,在[0,23]之间。

tm_mday表「本月第几日」,在[1,31]之间。

tm_mon表「本年第几月」,在[0,11]之间。

tm_year要加1900表示那一年。

tm_wday表「本第几日」,在[0,6]之间。

tm_yday表「本年第几日」,在[0,365]之间,闰年有366日。

tm_isdst表是否为「日光节约时间」。

struct itimerval

{

struct timeval it_interval;

struct timeval it_value;

};

it_interval成员表示间隔计数器的初始值,而it_value成员表示间隔计数器的当前值。

2.获得当前时间

在所有的UNIX下,都有个time()的函数

time_t time(time_t *t);

这个函数会传回从epoch开始计算起的秒数,如果t是non-null,它将会把时间值填入t中。

对某些需要较高精准度的需求,Linux提供了gettimeofday()。

int gettimeofday(struct timeval * tv,struct timezone *tz);

int settimeofday(const struct timeval * tv,const struct timezone *tz);

struct tm格式时间函数

struct tm * gmtime(const time_t * t);

转换成格林威治时间。有时称为GMT或UTC。

struct tm * localtime(const time_t *t);

转换成本地时间。它可以透过修改TZ环境变数来在一台机器中,不同使用者表示不同时间。

time_t mktime(struct tm *tp);

转换tm成为time_t格式,使用本地时间。

tme_t timegm(strut tm *tp);

转换tm成为time_t格式,使用UTC时间。

double difftime(time_t t2,time_t t1);

计算秒差。

3.文字时间格式函数

char * asctime(struct tm *tp);

char * ctime(struct tm *tp);

这两个函数都转换时间格式为标准UNIX时间格式。

Mon May 3 08:23:35 1999

ctime一率使用当地时间,asctime则用tm结构内的timezone资讯来表示。

size_t strftime(char *str,size_t max,char *fmt,struct tm *tp);

strftime有点像sprintf,其格式由fmt来指定。

%a : 本第几天名称,缩写。

%A : 本第几天名称,全称。

%b : 月份名称,缩写。

%B : 月份名称,全称。

%c : 与ctime/asctime格式相同。

%d : 本月第几日名称,由零算起。

%H : 当天第几个小时,24小时制,由零算起。

%I : 当天第几个小时,12小时制,由零算起。

%j : 当年第几天,由零算起。

%m : 当年第几月,由零算起。

%M : 该小时的第几分,由零算起。

%p : AM或PM。

%S : 该分钟的第几秒,由零算起。

%U : 当年第几,由第一个日开始计算。

%W : 当年第几,由第一个一开始计算。

%w : 当第几日,由零算起。

%x : 当地日期。

%X : 当地时间。

%y : 两位数的年份。

%Y : 四位数的年份。

%Z : 时区名称的缩写。

%% : %符号。

char * strptime(char *s,char *fmt,struct tm *tp);

如同scanf一样,解译字串成为tm格式。

%h : 与%b及%B同。

%c : 读取%x及%X格式。

%C : 读取%C格式。

%e : 与%d同。

%D : 读取%m/%d/%y格式。

%k : 与%H同。

%l : 与%I同。

%r : 读取"%I:%M:%S %p"格式。

%R : 读取"%H:%M"格式。

%T : 读取"%H:%M:%S"格式。

%y : 读取两位数年份。

%Y : 读取四位数年份。

下面举一个小例子,说明如何获得系统当前时间:

time_t now;

struct tm *timenow;

char strtemp[255];

time(&now);

timenow = localtime(&now);

printf("recent time is : %s \n", asctime(timenow))





‍1 pthread_cond_timedwait行为和pthread_cond_wait一样,在返回的时候都要再次lock mutex.
2 pthread_cond_timedwait所谓的如果没有等到条件变量,超时就返回,并不确切。
如果pthread_cond_timedwait超时到了,但是这个时候不能lock临界区,pthread_cond_timedwait并不会立即返回,但是在pthread_cond_timedwait返回的时候,它仍在临界区中,且此时返回值为ETIMEDOUT.
其实,这样的设计也是符合逻辑的。
使用条件变量最大的好处是可以避免忙等。相当与多线程中的信号。
条件变量是线程中的东西就是等待某一条件的发生和信号一样

以下是说明
,条件变量使我们可以睡眠等待某种条件出现。
条件变量是利用线程间共享的全局变量进行同步的一种机制,主要包括两个动作:一个线程等待"条件变量的条件成立"而挂起;另一个线程使"条件成立"(给出条件成立信号)。为了防止竞争,条件变量的使用总是和一个互斥锁结合在一起。
条件变量类型为pthread_cond_t
 


创建和注销
条件变量和互斥锁一样,都有静态动态两种创建方式,静态方式使用PTHREAD_COND_INITIALIZER常量,如下:
pthread_cond_t cond=PTHREAD_COND_INITIALIZER
动态方式调用pthread_cond_init()函数,API定义如下:
int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr)
尽管POSIX标准中为条件变量定义了属性,但在LinuxThreads中没有实现,因此cond_attr值通常为NULL,且被忽略。
注销一个条件变量需要调用pthread_cond_destroy(),只有在没有线程在该条件变量上等待的时候才能注销这个条件变量,否则返回EBUSY。API定义如下:
int pthread_cond_destroy(pthread_cond_t *cond)
等待和激发
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime)
等待条件有两种方式:无条件等待pthread_cond_wait()和计时等待pthread_cond_timedwait(),其中计时等待方式如果在给定时刻前条件没有满足,则返回ETIMEOUT,结束等待,其中abstime以与time()系统调用相同意义的绝对时间形式出现,0表示格林尼治时间1970年1月1日0时0分0秒。
使用绝对时间而非相对时间的优点是。如果函数提前返回(很可能因为捕获了一个信号,)
无论哪种等待方式,都必须和一个互斥锁配合,以防止多个线程同时请求pthread_cond_wait()(或pthread_cond_timedwait(),下同)的竞争条件(Race Condition)。mutex互斥锁必须是普通锁(PTHREAD_MUTEX_TIMED_NP)或者适应锁(PTHREAD_MUTEX_ADAPTIVE_NP),且在调用pthread_cond_wait()前必须由本线程加锁(pthread_mutex_lock()),而在更新条件等待队列以前,mutex保持锁定状态,并在线程挂起进入等待前解锁。在条件满足从而离开pthread_cond_wait()之前,mutex将被重新加锁,以与进入pthread_cond_wait()前的加锁动作对应。
激发条件有两种形式,pthread_cond_signal()激活一个等待该条件的线程,存在多个等待线程时按入队顺序激活其中一个;而pthread_cond_broadcast()则激活所有等待线程。
 


其他
pthread_cond_wait()和pthread_cond_timedwait()都被实现为取消点,因此,在该处等待的线程将立即重新运行,在重新锁定mutex后离开pthread_cond_wait(),然后执行取消动作。也就是说如果pthread_cond_wait()被取消,mutex是保持锁定状态的,因而需要定义退出回调函数来为其解锁。
EXAMPLE
Consider two shared variables x and y, protected by the mutex mut, and
a condition variable cond that is to be signaled whenever x becomes
greater than y.
int x,y;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
Waiting until x is greater than y is performed as follows:
pthread_mutex_lock(&mut);
while (x <= y) {
pthread_cond_wait(&cond, &mut);
}
/* operate on x and y */
pthread_mutex_unlock(&mut);
Modifications on x and y that may cause x to become greater than y
should signal the condition if needed:
pthread_mutex_lock(&mut);
/* modify x and y */
if (x > y) pthread_cond_broadcast(&cond);
pthread_mutex_unlock(&mut);
If it can be proved that at most one waiting thread needs to be waken
up (for instance, if there are only two threads communicating through x
and y), pthread_cond_signal can be used as a slightly more efficient
alternative to pthread_cond_broadcast. In doubt, use
pthread_cond_broadcast.
To wait for x to becomes greater than y with a timeout of 5 seconds,
do:
struct timeval now;
struct timespec timeout;
int retcode;
pthread_mutex_lock(&mut);
gettimeofday(&now);
timeout.tv_sec = now.tv_sec + 5;
timeout.tv_nsec = now.tv_usec * 1000;
retcode = 0;
while (x <= y && retcode != ETIMEDOUT) {
retcode = pthread_cond_timedwait(&cond, &mut, &timeout);
}
if (retcode == ETIMEDOUT) {
/* timeout occurred */
} else {
/* operate on x and y */
}
pthread_mutex_unlock(&mut);



1.初始化条件变量pthread_cond_init


#include int pthread_cond_init(pthread_cond_t *cv, const pthread_condattr_t *cattr); 返回值:函数成功返回0;任何其他返回值都表示错误 
初始化一个条件变量。当参数cattr为空指针时,函数创建的是一个缺省的条件变量。否则条件变量的属性将由cattr中的属性值来决定。调用pthread_cond_init函数时,参数cattr为空指针等价于cattr中的属性为缺省属性,只是前者不需要cattr所占用的内存开销。这个函数返回时,条件变量被存放在参数cv指向的内存中。

可以用宏PTHREAD_COND_INITIALIZER来初始化静态定义的条件变量,使其具有缺省属性。这和用pthread_cond_init函数动态分配的效果是一样的。初始化时不进行错误检查。如:

pthread_cond_t cv = PTHREAD_COND_INITIALIZER; 
不能由多个线程同时初始化一个条件变量。当需要重新初始化或释放一个条件变量时,应用程序必须保证这个条件变量未被使用。

2.阻塞在条件变量上pthread_cond_wait


#include int pthread_cond_wait(pthread_cond_t *cv, pthread_mutex_t *mutex); 返回值:函数成功返回0;任何其他返回值都表示错误 
函数将解锁mutex参数指向的互斥锁,并使当前线程阻塞在cv参数指向的条件变量上。

被阻塞的线程可以被pthread_cond_signal函数,pthread_cond_broadcast函数唤醒,也可能在被信号中断后被唤醒。

pthread_cond_wait函数的返回并不意味着条件的值一定发生了变化,必须重新检查条件的值。

pthread_cond_wait函数返回时,相应的互斥锁将被当前线程锁定,即使是函数出错返回。

一般一个条件表达式都是在一个互斥锁的保护下被检查。当条件表达式未被满足时,线程将仍然阻塞在这个条件变量上。当另一个线程改变了条件的值并向条件变量发出信号时,等待在这个条件变量上的一个线程或所有线程被唤醒,接着都试图再次占有相应的互斥锁。

阻塞在条件变量上的线程被唤醒以后,直到pthread_cond_wait()函数返回之前条件的值都有可能发生变化。所以函数返回以后,在锁定相应的互斥锁之前,必须重新测试条件值。最好的测试方法是循环调用pthread_cond_wait函数,并把满足条件的表达式置为循环的终止条件。如:

pthread_mutex_lock(); while (condition_is_false) pthread_cond_wait(); pthread_mutex_unlock(); 
阻塞在同一个条件变量上的不同线程被释放的次序是不一定的。

注意:pthread_cond_wait()函数是退出点,如果在调用这个函数时,已有一个挂起的退出请求,且线程允许退出,这个线程将被终止并开始执行善后处理函数,而这时和条件变量相关的互斥锁仍将处在锁定状态。

3.解除在条件变量上的阻塞pthread_cond_signal


#include int pthread_cond_signal(pthread_cond_t *cv); 返回值:函数成功返回0;任何其他返回值都表示错误 
函数被用来释放被阻塞在指定条件变量上的一个线程。

必须在互斥锁的保护下使用相应的条件变量。否则对条件变量的解锁有可能发生在锁定条件变量之前,从而造成死锁。

唤醒阻塞在条件变量上的所有线程的顺序由调度策略决定,如果线程的调度策略是SCHED_OTHER类型的,系统将根据线程的优先级唤醒线程。

如果没有线程被阻塞在条件变量上,那么调用pthread_cond_signal()将没有作用。

4.阻塞直到指定时间pthread_cond_timedwait


#include #include int pthread_cond_timedwait(pthread_cond_t *cv, pthread_mutex_t *mp, const structtimespec * abstime); 返回值:函数成功返回0;任何其他返回值都表示错误 
函数到了一定的时间,即使条件未发生也会解除阻塞。这个时间由参数abstime指定。函数返回时,相应的互斥锁往往是锁定的,即使是函数出错返回。

注意:pthread_cond_timedwait函数也是退出点。

超时时间参数是指一天中的某个时刻。使用举例:

pthread_timestruc_t to; to.tv_sec = time(NULL) + TIMEOUT; to.tv_nsec = 0; 
超时返回的错误码是ETIMEDOUT。

5.释放阻塞的所有线程pthread_cond_broadcast


#include int pthread_cond_broadcast(pthread_cond_t *cv); 返回值:函数成功返回0;任何其他返回值都表示错误 
函数唤醒所有被pthread_cond_wait函数阻塞在某个条件变量上的线程,参数cv被用来指定这个条件变量。当没有线程阻塞在这个条件变量上时,pthread_cond_broadcast函数无效。

由于pthread_cond_broadcast函数唤醒所有阻塞在某个条件变量上的线程,这些线程被唤醒后将再次竞争相应的互斥锁,所以必须小心使用pthread_cond_broadcast函数。

6.释放条件变量pthread_cond_destroy


#include int pthread_cond_destroy(pthread_cond_t *cv); 返回值:函数成功返回0;任何其他返回值都表示错误 
释放条件变量。

注意:条件变量占用的空间并未被释放。

7.唤醒丢失问题


在线程未获得相应的互斥锁时调用pthread_cond_signal或pthread_cond_broadcast函数可能会引起唤醒丢失问题。

唤醒丢失往往会在下面的情况下发生:

一个线程调用pthread_cond_signal或pthread_cond_broadcast函数; 
另一个线程正处在测试条件变量和调用pthread_cond_wait函数之间; 
没有线程正在处在阻塞等待的状态下

你可能感兴趣的:(Linux进程与线程)