Linux系统编程学习笔记(十二)线程1

comeonxueRong 2010-05-07

线程1:

线程和进程类似,但是线程之间能够共享更多的信息。一个进程中的所有线程可以共享进程文件描述符和内存。

有了多线程控制,我们可以把我们的程序设计成为在一个进程同时做多个任务,每一个线程做一个独立的任务,这种

方式可以有以下好处:

1、通过把每一个事件分配给一个线程处理,可以简化异步事件处理的代码。每一个线程可以用同步编程模型,而同步

编程要比异步编程简单的多。

2、多个进程需要使用复杂的机制来共享内存和文件描述符。而线程可以自动共享同一内存地址空间和文件描述符。

3、有一些问题可以划分以便提高这个程序的吞吐量。一个进程如果有多个任务,需要进行隐式的序列化任务,因为

只有一个线程控制。使用多线程控制,独立的任务可以将每个任务分配一个线程。

4、交互式的进程可以改善响应时间,通过使用多线程将I/O和程序其他部分分开实现处理。

多线程不光可以在多核系统中得到并行的优势,而且在单核系统中,也可以提高系统的吞吐量和响应时间,因为当一个线程

阻塞的时候,另一线程可以占有cpu执行。

线程有一些描述线程和执行环境的信息来表示它,包括线程ID,寄存器值的集合,栈,调度优先级和策略,信号的掩码,errno

变量以及线程特有的一些结构。进程中各个线程共享进程的程序执行文本,程序的全局变量、堆内存、栈和文件描述符。

1、线程标志:

和进程一样,每一个线程都有一个ID。和进程ID是全系统唯一不同,线程ID是在进程内唯一。进程id用pid_t类型来表示,是一个

非负的整数。线程ID由pthread_t数据类型代表,和进程一样实现可能为一个结构,所以把pthread_t类型当做一个整数是不具有可

移植性,所以也没有可移植的打印线程id的方法。这样也需要一个函数来比较两个线程的ID是否相同。

#include <pthread.h>

int pthread_equal(pthread_t tid1, pthread_t tid2);

一个线程可以获得使用pthread_self来获得自己的线程id:

#include <pthread.h>

pthread_t pthread_self();

这个方法可以和pthread_equal配合使用,来识别被打上线程标记的数据结构。

2、进程创建:

通过调用pthread_create可以创建一个线程:

#include <pthread.h>

int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *),void *restrict arg);

创建成功tidp返回线程的id,attr为线程的属性,新创建的进程会运行start_rtn函数,并传入arg作为参数。如果想传入多个参数到start_rtn

函数中,需要将它们存储在一个结构体中,并把地址传到arg中。失败返回errorcode,而它们不设定errno。每个线程一个errno只是为了兼容

以前的函数而被使用的。多线程中,返回errorcode要比依赖于全局变量的errno清晰一些。

例子:创建一个线程,并打印进程id、新创建的线程id和主线程id。

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

pthread_t ntid;

void printids(const char *s){
	pid_t pid;
	pthread_t tid;
	pid = getpid();
	tid = pthread_self();
	printf("%s pid %u tid (0x%x) \n",s,(unsigned int)pid,(unsigned int)tid);
}

void * thr_fn(void *arg){
	printids("new thread: ");
	return ((void *) 0);
}

int main(void){
	int err;
	err = pthread_create(&ntid, NULL, thr_fn, NULL);
	if(err != 0){
		fprintf(stderr,"create pthread failed: %s",strerror(err));
		exit(1);
	}
	printids("main thread: ");
	sleep(1);
	exit(0);
}

这个例子有两个地方比较古怪,主要是为了处理主线程和新创建线程的竞争:1)主线程休眠,以防止主线程终止,导致真个进程的终止,新建的线程没有机会

运行,我们后面介绍pthread_join可以避免这个。2)新的线程获得它的线程id是通过调用pthread_self而不是读取一个共享内存的变量或者传递的参数。这是因为

主线程不能安全的使用ntid,新的线程可能在调用pthread_create返回之前开始运行。

3、进程终止

如果进程内的任何一个线程调用exit,_Exit,_exit,整个进程就会终止。类似的如果信号的默认action是终止进程,那么一个发送到线程的信号会终止整个进程。

只终止一个线程有三种方式:

1、线程简单的返回。返回值就是退出码。

2、线程可以被进程中的另一个线程取消。

3、线程调用pthread_exit。

#include <phtread.h>

void pthread_exit(void *rval_ptr);

rval_ptr是一个无类型的指针,和传递到进程的单个参数类似。这个指针可以被调用pthread_join的其他的线程得到。

#include <pthread.h>

int pthread_join(pthread_t thread,void **rval_ptr);

调用pthread_join的线程会阻塞,直到指定的线程调用了pthread_exit,从start_rtn中返回,或者被取消。

如果线程简单的返回,那么rval_ptr被设置成start_rtn的返回值,如果线程被取消,rval_ptr被设置成

PTHREAD_CANCELED。

通过调用pthread_join,我们自动将线程设置成为detached状态,所以资源会被清除。如果线程已经处于detached状态,

那么pthread_join就会失败,返回EINVAL.

如果我们不关心线程的返回值,那么我们可以把rval_ptr设置为NULL。

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

void * thr_fun1(void *arg){
	printf("Thread 1 returning...\n");
	return ((void *)1);
}

void * thr_fun2(void *arg){
	printf("Thread 2 exiting...\n");
	pthread_exit((void *) 2);
}

int main(void){
	int err;
	pthread_t tid1,tid2;
	void *tret;

	err = pthread_create(&tid1,NULL,thr_fun1,NULL);
	if(err != 0){
		fprintf(stderr,"create thread1 failed: %s",strerror(err));
		exit(1);
	}
	err = pthread_create(&tid2,NULL,thr_fun2,NULL);
	if(err != 0){
		fprintf(stderr,"create thread2 failed: %s",strerror(err));
		exit(1);
	}
	err = pthread_join(tid1,&tret);
	if( err != 0 ){
		fprintf(stderr,"join thread1 failed: %s",strerror(err));
		exit(1);
	}
	
	printf("Thread 1 exit code %d\n",(int)tret);

	err = pthread_join(tid2,&tret);
	if( err != 0 ){
		fprintf(stderr,"join thread2 failed: %s",strerror(err));
		exit(1);
	}
	printf("Thread 2 exit code %d\n",(int)tret);
	exit(0);
}

无类型的指针传递给pthread_create和pthread_exit,使用它可以传递多个值,这个指针可以指向包含复杂的结构。但是需要注意这个结构在调用返回时仍然合法。如果

这个结构是在调用者的栈中,内存的内容在使用的可能时候已经被改变。比如一个线程申请在栈中申请了一个结构,然后将结构的指针传递给pthread_exit,接着这个

栈在调用thread_join的时候可能已经被销毁。

例子:

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

struct foo{
	int a,b,c,d;
};

void printfoo(const char *s, const struct foo *fp){
	printf("%s",s);
	printf(" structure at 0x%x\n",(unsigned) fp);
	printf(" foo.a = %d\n", fp->a);
	printf(" foo.b = %d\n", fp->b);
	printf(" foo.c = %d\n", fp->c);
	printf(" foo.d = %d\n", fp->d);
}

void *thr_fn1(void *arg){
	struct foo foo = {1,2,3,4};
	printfoo("thread 1:\n",&foo);
	pthread_exit((void *)&foo);
}

void *thr_fn2(void *arg){
	printf("thread 2: ID is %u\n",(unsigned)pthread_self());
	pthread_exit((void *)0);
}

int main(void){
	int err;
	pthread_t tid1,tid2;
	struct foo *fp;

	err = pthread_create(&tid1,NULL,thr_fn1,NULL);
	if(err != 0){
		fprintf(stderr,"create thread1 failed: %s",strerror(err));
		exit(1);
	}
	err = pthread_join(tid1,(void *)&fp);
	if(err != 0){
		fprintf(stderr,"thread_join failed: %s",strerror(err));
		exit(1);	
	}
	sleep(1);
	printf("Parent starting second thread\n");

	err = pthread_create(&tid2,NULL,thr_fn2,NULL);
	if(err != 0){
		fprintf(stderr,"create thread2 failed: %s",strerror(err));
		exit(1);
	}
	sleep(1);
	printfoo("Parent:\n",fp);
	exit(0);
}

一个线程可以可以使用pthread_cancel来取消同一进程中的其他线程。

#include <pthread.h>

int pthread_cancel(pthread_t tid);

在默认的条件下,pthread_cancle将会使由tid指定的线程像调用了pthread_exit(PTHREAD_CANCELED)一样,但是一个线程可以选择忽略和如果控制被取消。pthread_cancel

并不等待线程的终止,而只是发送一个请求。

一个线程可以注册函数,当它终止的时候被调用,这个和进程使用atexit注册函数,当进程终止的时候调用类似。这个函数比较出名的就是线程清理函数。一个线程可以

加入多个线程清理函数,这个清理函数保存在栈中,所以执行的顺序和注册的顺序相反:

#include <pthread.h>

void pthread_cleanup_push(void (*rtn)(void *), void arg);
void pthread_cleanup_pop(int execute);

pthread_cleanup_push来注册清理函数rtn,这个函数有一个参数arg。但一下三种情形之一发生时,注册的清理函数被执行:

1)调用pthread_exit

2)作为对取消线程请求(pthread_cancel)的响应。

3)以非0参数调用pthread_cleanup_pop。

如果pthread_cleanup_pop被传递0参数,则清除函数不会被调用,但是仍然会清除处于栈顶的清理函数。

一个限制是这两个函数可能被实现为一个宏,所以在线程的同一作用域必须以匹配的成对出现。pthread_cleanup_push可能有{,而pthread_cleanup_pop可能有匹配这个

字符的}字符。

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

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

void *thr_fn1(void *arg){
	printf("thread 1 start\n");
	pthread_cleanup_push(cleanup,"thread 1 first handler");
	pthread_cleanup_push(cleanup,"thread 1 second handler");
	printf("thread 1 push complete\n");
	if(arg)
		return ((void *)1);
	pthread_cleanup_pop(1);
	pthread_cleanup_pop(1);
	return ((void *)1);
}

void *thr_fn2(void *arg){
	printf("thread 2 start\n");
	pthread_cleanup_push(cleanup,"thread 2 first handler");
	pthread_cleanup_push(cleanup,"thread 2 second handler");
	printf("thread 2 push complete\n");
	if(arg){
		pthread_exit((void *)2);
	}
	pthread_cleanup_pop(0);
	pthread_cleanup_pop(0);

	pthread_exit((void *) 2);
}

int main(void){
	int err;
	pthread_t tid1,tid2;
	void *tret;

	err = pthread_create(&tid1,NULL,thr_fn1,(void *)1);
	if( err != 0){
		fprintf(stderr,"create thread1 failed: %s",strerror(err));
		exit(1);
	}

	err = pthread_create(&tid2,NULL,thr_fn2,(void *)2);
	if(err != 0){
		fprintf(stderr,"create thread 2 failed: %s",strerror(err));
		exit(1);
	}

	err = pthread_join(tid1,&tret);
	if(err != 0){
		fprintf(stderr,"thread1 join failed: %s",strerror(err));
		exit(1);
	}
	printf("thread 1 exit code %d\n",(int)tret);
	err = pthread_join(tid2,&tret);
	if(err != 0){
		fprintf(stderr,"thread2 join failed: %s",strerror(err));
		exit(1);
	}
	printf("thread 2 exit code %d\n",(int) tret);
	exit(0);

}

如果线程从开始例程(startroutine)中返回(byreturnstatement),清理函数不会被调用。

线程的终止状态,直到pthread_join被调用的时候才能得到。如果一个线程已经被detached,这个线程的空间将会被回收。pthread_join不能等待detached的线程,获得其

终止状态。pthread_join一个detached线程将会失败,并返回EINVAL,我们可以通过pthread_detach来detach一个线程:

#include <pthread.h>

int pthread_detach(pthread_t tid);

4、线程同步

当多个线程共享相同的内存时,我们需要保证每一个线程都看到一个一致的数据。如果一个线程的变量别的线程不能够读写,或者变量时只读的,那么不会有不一致的状态。

然而一个线程可以修改一个变量,而其他的进程同时可以读取或者修改它,我们需要同步线程来保证它们访问变量,使用的是一个合法的值。

1)互斥量(Mutexes):

我们可以通过pthread提供的互斥量接口来保护我们的数据,确保每次只有一个线程访问。一个mutex基本上是一个锁,我们在访问共享数据的时候设置(上锁),在访问完成

后释放(解锁)。当我们解锁的互斥量的时候,当有多余一个的线程被阻塞时,所有阻塞在这个锁的进程都被唤醒,变成可以运行的状态,只有一个线程开始运行并设置锁,

其他的看到互斥量仍然是被锁定,继续等待。

互斥量使用pthread_mutex_t数据类型,在我们使用一个互斥量变量时,我们必须先初始化它,可以初始化为PTHREAD_MUTEX_INITIALIZER(静态初始化)或者调用

pthread_mutext_init,如果我们动态申请了互斥量,我们需要调用pthread_mutext_destory来销毁它:

#include <pthread.h>

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t * restrict attr);
int pthread_mutex_destory(pthread_mutex_t *mutex);

如果想使用默认的属性来初始化互斥量,我们把attr设置为NULL。

例子:

1)静态初始化

pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;

2)动态初始化:

int error;
pthread_mutex_t mylock;

if (error = pthread_mutex_init(&mylock, NULL))
   fprintf(stderr, "Failed to initialize mylock:%s\n", strerror(error));

想给一个互斥量上锁,我们调用pthread_mutex_lock.如果mutex已经上锁,调用的线程将会被阻塞,直至信号量解锁。要解锁一个信号量,我们调用phtread_mutex_unlock

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

一个线程如果lock一个已经上锁的互斥量,不想被阻塞,那么可以使用pthread_mutex_trylock,如果调用它的时候没有被上锁,就锁住这个互斥量,如果已经上锁,

就会失败,并返回EBUSY。

例子:

我们使用mutex来保护数据结构:当多个进程需要访问动态申请的结构,我们嵌入了引用计数,来保证知道所有线程都使用完它时,我们才释放它。

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

struct foo{
	int f_count;
	pthread_mutex_t f_lock;
	/* ...more stuff here... */
};

struct foo * foo_alloc(void){
	struct foo *fp;
	if((fp = malloc(sizeof(struct foo))) != NULL){
		fp->f_count = 1;
		if(pthread_mutex_init(&fp->f_lock,NULL) != 0){
			free(fp);
			return NULL;
		}
	} 
	return fp;
}

void foo_hold(struct foo *fp){
	pthread_mutex_lock(&fp->f_lock);
	fp->f_count++;
	pthread_mutex_unlock(&fp->f_lock);
}

void foo_rele(struct foo *fp){
	pthread_mutex_lock(&fp->f_lock);
	if(--fp->f_count == 0){
		pthread_mutex_unlock(&fp->f_lock);
		pthread_mutex_destroy(&fp->f_lock);
		free(fp);
	}else{
		pthread_mutex_unlock(&fp->f_lock);
	}
}

2)读写锁:

读写锁也叫共享-排他锁,和互斥量类似,除了它可以提供更高的并行性。使用mutex,它的状态要么处于锁住和未锁状态,只有一个线程可以上锁。而读

写锁有更多的状态:在读状态锁住,在写状态锁住,未锁住。只有一个线程可以获得写锁,多个线程可以同时获得读锁。当读写锁处于写锁住状态,所有

试图上锁的进程都被阻塞,当读写锁处于读锁住状态时,所有试图上读状态的锁成功,但是试图获得写状态锁将会被阻塞,直到所有的读进程都释放读状

态锁,此后来到试图上读锁的线程也被阻塞。

读写锁适合读比写频繁情形。读写锁和互斥量一样也需要在使用前初始化,在释放他们内存的时候销毁。

#include <pthread.h>

int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);
int pthread_rwlock_destroy(pthread_rwlock_t *restrict rwlock);

一个读写锁可以调用pthread_rwlock_init来初始化,我们可以传递NULL作为attr的参数,这样会使用读写锁的默认属性。

我们可以调用pthread_rwlock_destroy来清理,销毁它所占的内存空间。

上锁:

#include <pthread.h>

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

实现上可能会对读写锁中读模式的锁锁住次数有一定的限制,所以我们需要检查返回值,以确定是否成功。而其他的两个函数

会返回错误,但是只要我们的锁设计的恰当,我们可以不必做检查。

SingleUNIX规范另外两个读写锁原语:

#include <pthread.h>

int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);

当锁成功获取时,返回0,否则返回EBUSY。这两个函数使用在一个上锁的结构不能够保证产生死锁的时候,它可以避免死锁。

3)条件变量:

条件变量时另一中线程同步的机制,允许线程以无竞争的方式等待特定的条件发生。条件变量本身需要互斥量的保护,线程在改变条件前必须首先锁住互斥量,

且只有在锁住互斥量以后才能计算条件。条件变量使用之前必须首先进行初始化,pthread_cond_t数据类型代表的条件变量可以用两种方式初始化。

可以把常量PTHREAD_COND_INITIALIZER赋给静态分配的条件变量,但是如果条件变量是动态分配的,可以使用pthread_cond_init函数进行初始化。

在释放底层的内存空间前,可以使用pthread_mutex_destroy函数对条件变量进行销毁。除非需要创建一个非默认属性的条件变量,否则pthread_cond_init

函数的attr参数可以设置为NULL。

#include <pthread.h>

int pthread_cond_init(pthread_cond_t *restrict cond,
                      pthread_condattr_t *restrict attr);
int pthread_cond_destroy(pthread_cond_t *cond);

成功返回0,失败返回错误码。使用pthread_cond_wait等待条件变为真,如果在给定时间内条件不能满足,那么会生成一个代表出错码的返回值。

调用者需要把锁住的互斥量传给pthread_cond_wait对条件进行保护。函数把调用线程放到等待条件的线程列表上,然后对互斥量解锁,这两个操作

是原子操作。当pthread_cond_wait返回时,互斥量再次被锁住。

#include <pthread.h> 

int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
int pthread_cond_timewait(pthread_cond_t * restict cond, pthread_mutex_t *restrict mutex,const struct timespec * restrict timeout);

pthread_cond_timedwait函数的工作方式与pthread_cond_wait函数相似。timeout值指定了等待的时间,它通过timespec结构指定。时间值用秒数或者

分秒数表示,分秒数的单位是纳秒。时间值是一个绝对数而不是相对数。可以使用gettimeofday获取用timeval结构表示的当前时间,然后把这个时间加

上要等待的时间转换成timespec结构:

void maketimeout(struct timespec *tsp, long minutes){
	struct timeval now;
	/* get the current time */
	gettimeofday(&now);
	tsp->tv_sec = now.tv_sec;
	tsp->tv_nsec = now.tv_usec * 10000; /* usec to nsec */
	tsp->tv_sec += minutes * 60;
}

如果时间值到了但是条件还没有出现,pthread_cond_timedwait将重新获取互斥量,然后返回错误ETIMEDOUT。从pthread_cond_wait或者pthread_cond_timedwait

调用成功返回时,线程需要重新计算条件,因为其它线程可能已经在运行并改变了条件。pthread_cond_signal函数将唤醒等待该条件的某个线程,而pthread_cond_broadcast

函数将唤醒等待该条件的所有线程。必须注意一定要在改变条件状态以后再唤醒等待线程

#include <pthread.h>

int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);

例子:

#include <pthread.h>

struct msg {
    struct msg *m_next;
    /* ... more stuff here ... */
};

struct msg *workq;
pthread_cond_t qready = PTHREAD_COND_INITIALIZER;   /*初始化条件变量*/
pthread_mutex_t qlock = PTHREAD_MUTEX_INITIALIZER;  /*初始化互斥量*/

void process_msg(void)
{
    struct msg *mp; 

    for (;;) {
        pthread_mutex_lock(&qlock);     /*条件本身由互斥量保护*/
        while (workq == NULL)           /*wait返回后要重新检查条件*/
            pthread_cond_wait(&qready, &qlock);  /*wait期间释放互斥量,返回时再次锁住*/
        mp = workq;
        workq = mp->m_next;
        pthread_mutex_unlock(&qlock);   /*真正释放互斥量*/
        /* now process the message mp */
    }
}
void enqueue_msg(struct msg *mp)
{
    pthread_mutex_lock(&qlock);       /*修改条件前锁住互斥量*/
    mp->m_next = workq;
    workq = mp;
    pthread_mutex_unlock(&qlock);
    pthread_cond_signal(&qready);     /*唤醒等待线程时不需要占有互斥量*/

                                     /*如果希望在wait返回时不用再检查条件,就需要在唤醒时占有互斥量*/
}

参考:

《AdvancedprogramminginUnixEnvironment2ed》第11章

相关推荐