Chinaunix首页 | 论坛 | 博客
  • 博客访问: 233932
  • 博文数量: 113
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 1044
  • 用 户 组: 普通用户
  • 注册时间: 2015-02-15 16:09
文章分类

全部博文(113)

文章存档

2016年(5)

2015年(108)

我的朋友

分类: C/C++

2015-09-17 23:22:04

一、 为什么要用多线程技术?

1.       避免阻塞,大家知道,单个进程只有一个主线程,当主线程阻塞的时候,整个进程也就阻塞了,无法再去做其它的一些功能了。

2.       避免CPU空转,应用程序经常会涉及到RPC,数据库访问,磁盘IO等操作,这些操作的速度比CPU慢很多,而在等待这些响应时,CPU却不能去处理新的请求,导致这种单线程的应用程序性能很差。

3.       提升效率,一个进程要独立拥有4GB的虚拟地址空间,而多个线程可以共享同一地址空间,线程的切换比进程的切换要快得多。

 

二、  如何使用多线程技术进行编程?

首先给一个完整的多线程程序,以下是最简单的模拟火车票售票系统:

点击(此处)折叠或打开

  1. #include<stdio.h>

  2.          #include<pthread.h>

  3. #include<errno.h>

  4. #include<stdlib.h>

  5. #include<unistd.h>

  6. void* ticketport1(void*);//线程函数声明

  7. void* ticketport2(void*);//线程函数声明

  8. int tickets=100; //火车票的起始值

  9. int main()

  10. {

  11.          pthread_t id1,id2;

  12.          int ret;

  13.          ret=pthread_create(&id1,NULL,ticketport1,NULL); //创建线程1

  14.          if(ret<0)

  15.          {

  16.                    perror("creat thread1:");

  17.                    exit(-1);

  18.          }

  19.          ret=pthread_create(&id2,NULL,ticketport2,NULL); //创建线程2

  20.          if(ret<0)

  21.          {

  22.                    perror("creat thread2:");

  23.                    exit(-1);

  24.          }

  25.          pthread_join(id1,NULL); //等待线程1结束

  26.          pthread_join(id2,NULL); //等待线程2结束

  27.          return 0;
  28. }
  29. void* ticketport1(void* arg)
  30. {
  31.          while(1)
  32.          {
  33.                    if(tickets>0)
  34.                    {
  35.                             //usleep(1000);
  36.                             //售票点1每卖一张票,自减一
  37.                             printf("ticketport1 sells ticket: %d\n",tickets--);
  38.                    }
  39.                    else
  40.                    {
  41.                             break;
  42.                    }
  43.          }
  44.          return (void*)0;
  45. }
  46. void* ticketport2(void* arg)
  47. {
  48.          while(1)
  49.          {
  50.                    if(tickets>0)
  51.                    {
  52.                             //usleep(1000);
  53.                             //售票点2每卖一张票,自减一
  54.                             printf("ticketport2 sells ticket: %d\n",tickets--);
  55.                    }
  56.                    else
  57.                    {
  58.                             break;
  59.                    }
  60.          }
  61.          return (void*)0;
  62. }

我们用pthread_create函数来创建线程,用pthread_join来阻塞主线程,等待子线程执行完成后返回。利用了多线程技术来创建了两个售票点,可以不同的地方进行同时售票。

用gcc带选项-lpthread来连结pthread库函数。执行这个程序发现两个售票点在正常售票,一部分连续是ticketport1,另一部分连 续是ticketport2;此时,其实存在一个隐含的问题,就是线程间的切换,在单CPU系统中,CPU是有时间片时间,时间片到了,就要执行其它的线 程,假设thread1执行到if里面,但在printf执行前发生了线程切换,那么会发生什么呢?我们在这里用usleep函数(放开程序中的 usleep注释行)进行强制模拟切换,编译运行程序发现竟然有0号票被卖出了,这显然是错误的!当thread1的if里面发生线程切换 时,thread2得到运行,把最后一张票卖了,此时thread1恢复运行,结果卖出了0号票,这里我们需要的是火车票的票数数据对于所有线程而言是同 步的,所以就要用到线程同步技术了。

 

三、  使用多线程的同步与互斥

1、多线程的同步方式有很多种,例如互斥锁,条件变量,信号量,读写锁。先看看互斥锁如何解决多线程之间的同步问题。程序用互斥锁后如下:


点击(此处)折叠或打开

  1. #include<stdio.h>
  2. #include<pthread.h>
  3. #include<errno.h>
  4. #include<stdlib.h>
  5. #include<unistd.h>
  6. void* ticketport1(void*);
  7. void* ticketport2(void*);
  8. int tickets=100;
  9. pthread_mutex_t mutex;
  10. int main()
  11. {
  12.          int ret;
  13.          pthread_t id1,id2;
  14.          pthread_mutex_init(&mutex,NULL); //初始化互斥量
  15.          ret=pthread_create(&id1,NULL,ticketport1,NULL);
  16.          if(ret<0)
  17.          {
  18.                    perror("creat thread1:");
  19.                    exit(-1);
  20.          }
  21.          ret=pthread_create(&id2,NULL,ticketport2,NULL);
  22.          if(ret<0)
  23.          {
  24.                    perror("creat thread2:");
  25.                    exit(-1);
  26.          }
  27.          pthread_join(id1,NULL);
  28.          pthread_join(id2,NULL);
  29. }
  30. void* ticketport1(void* arg)
  31. {
  32.          while(1)
  33.          {
  34.                    pthread_mutex_lock(&mutex); //给互斥量上锁
  35.                    if(tickets>0)
  36.                    {
  37.                             usleep(1000);
  38.                             printf("thread1 sell ticket: %d\n",tickets--);
  39.                             pthread_mutex_unlock(&mutex); //给互斥量解锁
  40.                    }
  41.                    else
  42.                    {
  43.                             pthread_mutex_unlock(&mutex); //给互斥量解锁
  44.                             break;
  45.                    }
  46.                    pthread_yield(); //线程的调度函数,使两个线程都有执行机会
  47.          }
  48.          return (void*)0;
  49. }
  50. void* ticketport2(void* arg)
  51. {
  52.          while(1)
  53.          {
  54.                    pthread_mutex_lock(&mutex); //给互斥量上锁
  55.                    if(tickets>0)
  56.                    {
  57.                             usleep(1000);
  58.                             printf("thread2 sell ticket: %d\n",tickets--);
  59.                             pthread_mutex_unlock(&mutex); //给互斥量解锁
  60.                    }
  61.                    else
  62.                    {
  63.                             pthread_mutex_unlock(&mutex); //给互斥量解锁
  64.                             break;
  65.                    }
  66.                    pthread_yield(); //线程的调度函数,使两个线程都有执行机会
  67.          }
  68.          return (void*)0;
  69. }

我们用pthread_mutext_init函数来初始化互斥量,然后再用pthread_mutex_lock函数和 pthread_mutext_unlock分别进行上锁和解锁,至于这两个函数的参数说明,大家可以上网查阅,在这我只说明功能。我们用gcc带选项 -lpthread编译后多次执行发现即使强制线程在很短的时间内(如1ms)睡眠引起线程切换,也不会导致上述的问题,说明互斥锁可以解决线程间的同步 问题。

 

2、再看看用信号量来解决多线程的同步问题,程序代码如下:


点击(此处)折叠或打开

  1. #include<stdio.h>

  2. #include<pthread.h>

  3. #include<errno.h>

  4. #include<stdlib.h>

  5. #include<unistd.h>

  6. #include <semaphore.h>

  7.  

  8. void* ticketport1(void*);

  9. void* ticketport2(void*);

  10.  

  11. int tickets=100;

  12. sem_t mutex,full; //定义两个信号量

  13.  

  14. int main()

  15. {

  16.          int ret;

  17.          pthread_t id1,id2;

  18.  

  19.          ret=sem_init(&mutex,0,1); //初始化mutex信号量为1

  20.          ret+=sem_init(&full,0,0); //初始化full信号量为0

  21.          if(ret!=0)

  22.          {

  23.                    perror("sem_init");

  24.          }

  25.          ret=pthread_create(&id1,NULL,ticketport1,NULL);

  26.          if(ret<0)

  27.          {

  28.                    perror("creat thread1:");

  29.                    exit(-1);

  30.          }

  31.          ret=pthread_create(&id2,NULL,ticketport2,NULL);

  32.          if(ret<0)

  33.          {

  34.                    perror("creat thread2:");

  35.                    exit(-1);

  36.          }

  37.         

  38.          pthread_join(id1,NULL);

  39.          pthread_join(id2,NULL);

  40.          return 0;

  41. }

  42.  

  43. void* ticketport1(void* arg)

  44. {

  45.          while(1)

  46.          {

  47.                    sem_wait(&mutex); //mutex信号量进行P操作

  48.                    if(tickets>0)

  49.                    {

  50.                             usleep(1000);

  51.                             printf("thread1 sell ticket: %d\n",tickets--);

  52.                             sem_post(&full); //full信号量进行V操作

  53.                    }

  54.                    else

  55.                    {

  56.                             sem_post(&full); //full信号量进行V操作

  57.                             break;

  58.                    }

  59.                   

  60.          }

  61.          return (void*)0;

  62. }
  63. void* ticketport2(void* arg)
  64. {
  65.          while(1)
  66.          {
  67.                    sem_wait(&full); //full信号量进行P操作
  68.                    if(tickets>0)
  69.                    {
  70.                             usleep(1000);
  71.                             printf("thread2 sell ticket: %d\n",tickets--);
  72.                             sem_post(&mutex); //mutex信号量进行V操作
  73.                    }
  74.                    else
  75.                    {
  76.                             sem_post(&mutex); //mutex信号量进行V操作
  77.                             break;
  78.                    }       
  79.          }
  80.          return (void*)0;
  81. }

上面的sem_init函数用来初始化两个信号量的初始化值,这里一个设为1,一个设为0,sem_wait类似于P操作,让信号量减1,如果小于结果小 于0,线程阻塞,否则线程继续执行,sem_post类似于V操作,提升信号量的值,加1,通过这两个信号量之间的互相“救对方”,就可以实现这两个线程 的同步执行。

我们编译运行以上程序,发现两个售票点交替卖票,两个纯程依次得到机会执行,并且不会有0号票卖出,实现了同步。

 

3、我们再用条件变量来解决同步问题,一般条件变量需要结合互斥量一起使用,代码如下:


点击(此处)折叠或打开

  1. #include<stdio.h>

  2. #include<pthread.h>

  3. #include<errno.h>

  4. #include<stdlib.h>

  5. #include<unistd.h>

  6. void* ticketport1(void*);

  7. void* ticketport2(void*);

  8. int tickets=100;

  9. pthread_mutex_t mutex;

  10. pthread_cond_t qready=PTHREAD_COND_INITIALIZER; //静态初始化条件变量;

  11. int main()

  12. {

  13.          int ret;

  14.          pthread_t id1,id2;

  15.          pthread_mutex_init(&mutex,NULL); //初始化互斥量

  16.          ret=pthread_create(&id1,NULL,ticketport1,NULL);

  17.          if(ret<0)

  18.          {

  19.                    perror("creat thread1:");

  20.                    exit(-1);

  21.          }

  22.          ret=pthread_create(&id2,NULL,ticketport2,NULL);

  23.          if(ret<0)

  24.          {

  25.                    perror("creat thread2:");

  26.                    exit(-1);

  27.          }

  28.          pthread_join(id1,NULL);

  29.          pthread_join(id2,NULL);

  30. }

  31.  

  32. void* ticketport1(void* arg)

  33. {

  34.          pthread_mutex_lock(&mutex); //给互斥量上锁

  35.          while(tickets > 0)

  36.          {

  37.                    if(tickets%2 == 1)

  38.                    {

  39.                             usleep(1000);

  40.                             printf("thread1 sell ticket: %d\n",tickets--);

  41.                             pthread_cond_signal(&qready); //条件改变,发送信号,通知ticketport2

  42.                    }

  43.                   else

  44.                    {

  45.                             pthread_cond_wait(&qready,&mutex); //解开mutex,并等待qready改变

  46.                    }

  47.                    pthread_mutex_unlock(&mutex); //给互斥量解锁

  48.          }

  49.          return (void*)0;

  50. }

  51.  

  52. void* ticketport2(void* arg)

  53. {

  54.          pthread_mutex_lock(&mutex); //给互斥量上锁

  55.          while(tickets > 0)

  56.          {

  57.                    if(tickets%2==0)

  58.                   {

  59.                             usleep(1000);

  60.                             printf("thread2 sell ticket: %d\n",tickets--);

  61.                             pthread_cond_signal(&qready); //条件改变,发送信号,通知ticketport1

  62.                    }

  63.                    else

  64.                    {

  65.                             pthread_cond_wait(&qready,&mutex); //解开mutex,并等待qready改变

  66.                    }

  67.                    pthread_mutex_unlock(&mutex); //给互斥量解锁

  68.          }

  69.          return (void*)0;

  70. }

条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足,它常和互斥锁一起使用。使用时,条件变量被用来阻塞一个线程,当条件不满足 时,线程往往解开相应的互斥锁并等待条件变量发生变化。一旦其它的某个线程改变了条件变量,它将通知相应的条件变量唤醒一个或多个正被此条件变量阻塞的线 程。这些线程将重新锁定互斥锁并重新测试条件是否满足。一般说来,条件变量被用来进行线程间的同步.

函数pthread_cond_wait使线程阻塞在一个条件变量上,而函数pthread_cond_signal是用来释放被阻塞在条件变量上的一个 线程。但是要注意的是,条件变量只是起到阻塞和唤醒线程的作用,具体的判断条件还需用户给出,我这里给出的是tickets是否是偶数这个条件。




阅读(1037) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~