Chinaunix首页 | 论坛 | 博客
  • 博客访问: 915542
  • 博文数量: 632
  • 博客积分: 2778
  • 博客等级: 大尉
  • 技术积分: 3387
  • 用 户 组: 普通用户
  • 注册时间: 2012-05-31 09:09
个人简介

123

文章分类

全部博文(632)

文章存档

2014年(36)

2013年(33)

2012年(563)

分类:

2012-05-31 21:11:51

为什么对于多数合作性任务,多线程比多个独立的进程更优越呢?
这是因为,线程共享相同的内存空间。不同的线程可以存取内存中的同一个变量。所以,程序中的所有线程都可以读或写声明过的全局变量。如果曾用fork() 编写过重要代码,就会认识到这个工具的重要性。为什么呢?虽然fork()允许创建多个进程,但它还会带来以下通信问题,如何让多个进程相互通信,这里每 个进程都有自己独立的内存空间。对这个问题没有一个简单的答案。虽然有许多不通种类的本地IPC(进程间通信),但他们都遇到两个重要的障碍:
1.加强了某种形式的额外内核开销,从而降低性能。
2.对于大多数情形,IPC不是对于代码的“自然”扩展,通常极大地增加了程序的复杂性。
一、创建线程
函数简介
phread_create是UNIX环境创建线程函数
头文件
#include
函数声明
int pthread_create(pthread_t *restrict tidp
const pthread_attr_t *restrict_addr,
void *(start_rtn)(void *),
void *restrict arg);
返回值
若成功则返回0,否则返回出错编号
返回成功时,由tidp指向的内存单元被设置为新创建线程的线程ID。attr参数用于制定各种不同的线程属性。新创建的线程从start_rtn函数的 地址开始运行,该函数只有一个空指针参数arg,如果需要像start_rtn函数传递的参数不止一个,那么需要把这些参数放到一个结构体中,然后把这个 结构的地址作为arg的参数传入。
linux下用c开发多线程程序,linux系统下的多线程遵循POSIX线程接口,称为pthread。
参数
第一参数为指向线程标识符的指针
第二个参数用来设置线程属性
第三个参数是线程运行函数的起始地址
最后一个参数是运行函数的参数
另外,在编译时注意加上-lpthread参数,以调用静态连接库。因为pthread并非linux系统的默认库。
二、pthread_join
函数pthread_join用来等待一个线程的结束。函数原型为:

extern int phread_join (pthead_t __th,void **_thread_return);
第一个参数为被等待的线程标识符。第二个参数为一个用户定义的指针,它可以用来存储被等待线程的返会值。这个函数是一个线程阻塞的函数,调用它的函数将一 直等待到被等待的线程结束为止,当函数返回时,被等待线程的资源被收回。如果执行成功,将返回0,如果失败则返回一个错误号。
在linux中,默认情况下是在一个线程被创建后,必须使用此函数对创建的线程进行资源回收,但是可以设置Threads attributes来设置当一个线程结束时,直接回收此线程所占用的系统资源。
三、互斥锁pthread_mutex_t的使用
1.两种方法创建互斥锁,静态方式和动态方式。POXIX定义了一个PTHREAD_MUTEX_INITIALIZER来静态初始化互斥锁,方法如 下:phread_mutex_t mutex=PTHREAD_MUTEX_INITALIZER;在LinuxThreads实现中,pthread_mutex_t是一个结构,而 PTHREAD_MUTEX_INITIALIZER则是一个结构常量。
动态方式是采用pthread_mutex_init()函数来初始化互斥锁,API定义如下:
int pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutexattr_t *mutexattr)其中mutexattr用于指定互斥属性(见下),如果为NULL则使用缺省属性。
pthread_mutex_destroy()用于注销一个互斥锁,API定义如下:int pthread_mutex_destory(pthread_mutex_t *mutex) 销毁一个互斥锁即意味着释放它所占用的资源,且要求锁当前处于开发状态。由于在linux中,互斥锁并不占用任何资源,因此LinuxThreads中的 pthread_mutex_destroy()除了检查锁状态以外(锁定状态则返回EBUSY)没有其他动作。
2.互斥锁属性
互斥锁的属性在创建锁的时候指定,在LinuxThreads实现中仅有一个锁类型属性,不通的锁类型试图对一个已经被锁定的互斥锁加锁时表现不通。当前(glibc 2.2.3,linuxthreads0.9)有四个值可供选择:
*PTHREAD_MUTEX_TIMED_NP,这是缺省值,也就是普通锁。当一个线程加锁以后,其余请求锁的线程将形成一个等待队列,并在解锁后按优先级获得锁。这种锁策略保证了资源分配的公平性。
*PTHREAD_MUTEX_RECURSIVE_NP,嵌套锁,允许同一个线程对同一个锁成功获得多次,并通过多次unlock解锁。如果是不同线程请求,则在加锁线程解锁时重新竞争。
*PTHREAD_MUTEX_ERRORCHECK_NP,检错锁,如果同一个线程请求同一个锁,则返回EDEADLK,否则与PTHREAD_MUTEX_TIMED_NP类型动作相同。这样就保证当步允许多次加锁 时不会出现最简单情况下的死锁。
*PTHREAD_MUTEX_ADAPTIVE_NP,适应锁,动作最简单的锁类型,仅等待解锁后重新竞争。
3.锁操作
锁操作主要包括加锁pthread_mutex_lock()、解锁pthread_mutex_unlock()和测试加锁 pthread_mutex_trylock()三个,不论哪种类型的锁,都不可能被两个不同的线程时得到,而必须等待解锁。对于普通锁和适应锁类型,解 锁者可以是同进程内任何线程;而检错锁则必须由加锁者解锁才有效,否则EPERM;对于嵌套锁,文档和实现要求必须由加锁者解锁,但试验结果表明并没有这 种限制,这个不同目前还没有得到解释。在同一进程中的线程,如果加锁后没有解锁,则任何其他线程都无法在获得锁。
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
phread_mutex_trylock()语义与pthread_mutex_lock()类似,不同的是在锁已经被占用时返回EBUSY而不是挂起等待。四、使用条件变量提高效率
如果线程正在等待某个特定条件发生,它应该如何处理这种情况?它可以重复对互斥对象锁定和解锁,每次都会检查共享数据结,以查找某个值。但这是在浪费时间 和资源,而且这种繁忙查询的效率非常低。解决这个问题的最佳方法是使用pthread_cond_wait()调用来等待特殊条件发生。
条件变量是利用线程间共享的全局变量进行同步的一种机制,主要包括连个动作:一个线程等待"条件变量的条件成立"而挂起;另一个线程使"条件成立"(给出条件成立信号)。为了防止竞争,条件变量的使用总是和一个互斥锁结合在一起。
1.创建和注销
条件变量和互斥锁一样,都有静态、动态两种创建方式,静态方式使用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。因为Linux实现的条件变量没有分配什么资源,所以注销动作只包括检查是否有等待线程。API定下如下:
int pthread_cond_destroy(pthread_cond_t *cond);
2.等待和激发
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(),下同)的竞争条件。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()则激活所有等待线程。
事例使用说明:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
分别把服务器端程序和客户端程序拷贝到2个文件:如server.c 和 client.c
编译:
gcc server.c -o server -lpthread
gcc client.c -o client
之后分别打开2个bash:
一个bash运行服务器端:
./server
一个bash运行客户端:
./client
操作说明:
在客户端bash中使用组合键 ctrl+c 时,服务器端打印:sigint_Action;使用组合键 ctrl+\ 时打印:sigquit_Action
可以反复输入2个组合键,每次输入服务器端都会打印相应信息,但应注意
当连续输入3次组合键 ctrl+\ 时2个程序分别结束,这也是测试程序结束的方法。
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
以下是服务器端程序:拷贝出去命名 server.c
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
typedef unsigned int U_16;
typedef char C_8;
typedef struct sockaddr SA;
struct data{
U_16 sigint_flag;//非零执行
U_16 sigquit_flag;//非零执行
U_16 overAll_flag;//非零才判断,为零取消所有动作
}flags;
int index2 = 0;
struct sockaddr_in s_addr;
pthread_mutex_t sigint_mutex;
pthread_mutex_t sigquit_mutex;
pthread_cond_t sigint_cond;
pthread_cond_t sigquit_cond;
void *sigint_Action(void *arg)
{
while(1) {
pthread_mutex_lock(&sigint_mutex);
pthread_cond_wait(&sigint_cond,&sigint_mutex);
if(1 == index2) {
printf("sigint_Action\n");
pthread_mutex_unlock(&sigint_mutex);
}
if(2 == index2) {
pthread_mutex_unlock(&sigint_mutex);
return NULL;
}
}
}
void *sigquit_Action(void *arg)
{
while(1) {
pthread_mutex_lock(&sigquit_mutex);
pthread_cond_wait(&sigquit_cond,&sigquit_mutex);
if(1 == index2) {
printf("sigquit_Action\n");
pthread_mutex_unlock(&sigquit_mutex);
}
if(2 == index2) {
pthread_mutex_unlock(&sigquit_mutex);
return NULL;
}
}
}
void sys_Init()
{
pthread_t sigint_pthread;
pthread_t sigquit_pthread;
if(pthread_create(&sigint_pthread,NULL,sigint_Action,NULL)){
printf("sigint_pthread create failed\n");
exit(-1);
}
if(pthread_create(&sigquit_pthread,NULL,sigquit_Action,NULL)){
printf("sigquit_pthread create failed\n");
exit(-1);
}
pthread_mutex_init(&sigint_mutex,NULL);
pthread_mutex_init(&sigquit_mutex,NULL);
pthread_cond_init(&sigint_cond,NULL);
pthread_cond_init(&sigquit_cond,NULL);
return;
}
int main(int argc,char *argv[])
{
int server_fd,client_fd;
socklen_t len;
struct sockaddr_in c_addr;
if((server_fd=socket(PF_INET,SOCK_STREAM,0)) == -1){
perror("socket fail");
exit(-1);
}
memset(&s_addr,0,sizeof(s_addr));
s_addr.sin_family = PF_INET;
if(argc < 3){
s_addr.sin_port = htons(8000);
s_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
}else {
s_addr.sin_port = htons(atoi(argv[2]));
s_addr.sin_addr.s_addr = inet_addr(argv[1]);
}
if((bind(server_fd,(SA *)&s_addr,sizeof(s_addr))) == -1){
perror("action bind\n");
exit(-1);
}
if(listen(server_fd,10) == -1){
perror("listen fail");
exit(-1);
}
len = sizeof(s_addr);
if((client_fd=accept(server_fd,(SA *)&c_addr,&len)) == -1){
perror("accept fail");
exit(-1);
}
sys_Init();
memset(&flags,0,sizeof(flags));
while(1) {
if(read(client_fd,&flags,sizeof(flags)) < 0){
perror("read error");
exit(-1);
}
if(1 == flags.overAll_flag){
if(1 == flags.sigint_flag){
index2 = 1;
pthread_cond_signal(&sigint_cond);
}
if(1 == flags.sigquit_flag){
index2 = 1;
pthread_cond_signal(&sigquit_cond);
}
}else if(0 == flags.overAll_flag){
printf("action process end\n");
index2 = 2;
close(client_fd);
close(server_fd);
return 0;
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
以下是客户端程序:拷贝出去命名 client.c
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
typedef unsigned int U_16;
typedef struct sockaddr SA;
static int sockfd;
static socklen_t len;
static struct sockaddr_in s_addr;
static int g_end = 0;
struct data{
U_16 sigint_flag;//非零执行
U_16 sigquit_flag;//非零执行
U_16 overAll_flag;//非零才判断,为零取消所有动作
}flags;
void sighandler(int signo)
{
switch(signo) {
case SIGINT:
g_end = 0;
flags.sigint_flag = 1;
flags.sigquit_flag = 0;
flags.overAll_flag = 1;
if(write(sockfd,&flags,sizeof(flags)) < sizeof(flags)){
printf("write size error\n");
exit(-1);
}
break;
case SIGQUIT:
g_end++;
flags.sigint_flag = 0;
flags.sigquit_flag = 1;
flags.overAll_flag = 1;
if(3 == g_end) {
flags.overAll_flag = 0;
}
if(write(sockfd,&flags,sizeof(flags)) < sizeof(flags)){
printf("write size error\n");
exit(-1);
}
break;
}
}
int main(int argc,char *argv[])
{
memset(&flags,0,sizeof(flags));
memset(&s_addr,0,sizeof(s_addr));
s_addr.sin_family = PF_INET;
if(argc < 3){
s_addr.sin_port = htons(8000);
s_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
}else {
s_addr.sin_port = htons(atoi(argv[2]));
s_addr.sin_addr.s_addr = inet_addr(argv[1]);
}
if((sockfd=socket(PF_INET,SOCK_STREAM,0)) == -1){
perror("socket fail");
exit(-1);
}
if(connect(sockfd,(SA *)&s_addr,sizeof(s_addr)) == -1){
perror("connect fail");
exit(-1);
}
while(1) {
signal(SIGINT,sighandler);
signal(SIGQUIT,sighandler);
if(3 == g_end) {
close(sockfd);
exit(0);
}
sleep(1);
};
return 0;
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////




Linux环境下利用套接口(Socket)和多线程技术实现简单聊天室设计
http://wenku.baidu.com/view/c17f4bc78bd63186bcebbcb8.html
阅读(318) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~