1. #include <stdio.h>
  2. #include <unistd.h>
  3. #include <string.h>
  4. #include <sys/types.h>
  5. #include <sys/stat.h>
  6. #include <fcntl.h>
  7. #include <signal.h>
  11. // void func(int sig)
  12. // {
  13. //     int ret = -1;
  14. //     
  15. //     if(sig != SIGIO)
  16. //     {
  17. //         return ;
  18. //     }
  21. // }
  23. int main(int argc, char **argv)
  24. {
  25.     int mousefd = -1;
  26.     char buf[1024] = {0};
  27.     //create two process, one to read mouse, and one to read keyboard
  28.     int ret = -1;
  29.     ret = fork();
  30.     if(ret == 0)
  31.     {
  32.         //son process
  33.         mousefd = open("/dev/input/mouse0", O_RDONLY);
  34.         if(mousefd < 0)
  35.         {
  36.             perror("open");
  37.             return -1;
  38.         }
  40.         while(1)
  41.         {
  42.             memset(buf, 0, sizeof(buf));
  43.             ret = read(mousefd, buf, 1024); 
  44.             if(ret > 0)
  45.             {
  46.                 printf("context of mouse: [%s]\n", buf);
  47.             }
  48.         }
  50.     }
  51.     else if(ret > 0)
  52.     {
  53.         //parent process
  54.         while(1)
  55.         {
  56.             memset(buf, 0, sizeof(buf));
  57.             ret = read(0, buf, 1024);            //0 is standard input
  58.             if(ret > 0)
  59.             {
  60.                 printf("context of keyboard : [%s]\n", buf);
  61.             }
  62.         }
  63.     }
  64.     else
  65.     {
  66.         perror("fork");
  67.     }
  70.     return 0;
  71. }

进程技术的缺点：
进程间切换开销大
进程间通信麻烦而且效率低

线程技术保留了进程技术实现多任务的特性
线程的改进就是在线程间切换和线程间通信上提升了效率
多线程在多核心CPU上面更有优势

  1. #include <stdio.h>
  2. #include <unistd.h>
  3. #include <string.h>
  4. #include <sys/types.h>
  5. #include <sys/stat.h>
  6. #include <fcntl.h>
  7. #include <pthread.h>
  9. char buf[1024] = {0};
  11. void *func()
  12. {
  13.     int ret = -1;
  14.     while(1)
  15.     {
  16.         memset(buf, 0, sizeof(buf));
  17.         ret = read(0, buf, 1024);            //0 is standard input
  18.         if(ret > 0)
  19.         {
  20.             printf("context of keyboard : [%s]\n", buf);
  21.         }
  22.     }
  23. }
  25. int main(int argc, char **argv)
  26. {
  27.     int mousefd = -1;
  29.     //create two process, one to read mouse, and one to read keyboard
  30.     int ret = -1;
  31.     pthread_t th = -1;
  33.     ret = pthread_create(&th, NULL, func, NULL);
  34.     if(ret != 0)
  35.     {
  36.         printf("Error: pthread_create");
  37.         return -1;    
  38.     }
  40.     //main task
  41.     mousefd = open("/dev/input/mouse0", O_RDONLY);
  42.     if(mousefd < 0)
  43.     {
  44.         perror("open");
  45.         return -1;
  46.     }
  48.     while(1)
  49.     {
  50.         memset(buf, 0, sizeof(buf));
  51.         ret = read(mousefd, buf, 1024); 
  52.         if(ret > 0)
  53.         {
  54.             printf("context of mouse: [%s]\n", buf);
  55.         }
  56.     }
  59.     return 0;
  60. }

Linux中线程简介

线程是参与内核调度的最小单元
一个进程中可以有多个线程

线程的优势：
像进程一样可被OS调度
同一进程的多个线程之间很容易高效率通信
在多核CPU（对称多处理器架构）架构下效率最大化