多进程和多线程的区别（转载）

转载地址：http://blog.csdn.net/hairetz/article/details/4281931/

一.为什么须要多进程（或者多线程），为什么须要并发？

这个问题或许自己都不是个问题。可是对于没有接触过多进程编程的朋友来讲，他们确实没法感觉到并发的魅力以及必要性。

我想，只要你不是成天都写那种int main()到底的代码的人，那么或多或少你会遇到代码响应不够用的状况，也应该有尝过并发编程的

甜头。就像一个快餐点的服务员，既要在前台接待客户点餐，又要接电话送外卖，没有分身术确定会忙得你焦头烂额的。幸运的是确实

有这么一种技术，让你能够像孙悟空同样分身，灵魂出窍，乐哉乐哉地轻松应付一切情况,这就是多进程/线程技术。

并发技术，就是可让你在同一时间同时执行多条任务的技术。你的代码将不只仅是从上到下，从左到右这样规规矩矩的一条线执行。你能够一条线在main函数里跟你的客户交流，另外一条线，你早就把你外卖送到了其余客户的手里。

因此，为什么须要并发？由于咱们须要更强大的功能，提供更多的服务，因此并发，必不可少。

 

二.多进程

什么是进程。最直观的就是一个个pid,官方的说法就：进程是程序在计算机上的一次执行活动。

说得简单点，下面这段代码执行的时候

1 int main()
2 
3 {
4 
5 printf(”pid is %d/n”,getpid() );
6 
7 return 0;
8 
9 }

进入main函数，这就是一个进程，进程pid会打印出来，而后运行到return，该函数就退出，而后因为该函数是该进程的惟一的一次执行，因此return后，该进程也会退出。

看看多进程。linux下建立子进程的调用是fork();

 1 #include <unistd.h>
 2 #include <sys/types.h> 
 3 #include <stdio.h>
 4 
 5  
 6 
 7 void print_exit()
 8 {
 9        printf("the exit pid:%d/n",getpid() );
10 }
11 
12 main () 
13 { 
14    pid_t pid; 
15    atexit( print_exit );      //注册该进程退出时的回调函数
16       pid=fork(); 
17         if (pid < 0) 
18                 printf("error in fork!"); 
19         else if (pid == 0) 
20                 printf("i am the child process, my process id is %d/n",getpid()); 
21         else 
22         {
23                printf("i am the parent process, my process id is %d/n",getpid()); 
24               sleep(2);
25               wait();
26        }
27 
28 }

i am the child process, my process id is 15806
the exit pid:15806
i am the parent process, my process id is 15805
the exit pid:15805

这是gcc测试下的运行结果。

关于fork函数，功能就是产生子进程，因为前面说过，进程就是执行的流程活动。

那么fork产生子进程的表现就是它会返回2次，一次返回0，顺序执行下面的代码。这是子进程。

一次返回子进程的pid，也顺序执行下面的代码，这是父进程。

（为什么父进程须要获取子进程的pid呢？这个有不少缘由，其中一个缘由：看最后的wait，就知道父进程等待子进程的终结后，处理其task_struct结构，不然会产生僵尸进程,扯远了，有兴趣能够本身google）。

若是fork失败，会返回-1.

额外说下atexit( print_exit ); 须要的参数确定是函数的调用地址。

这里的print_exit 是函数名仍是函数指针呢？答案是函数指针，函数名永远都只是一串无用的字符串。

某本书上的规则：函数名在用于非函数调用的时候，都等效于函数指针。

 

说到子进程只是一个额外的流程，那他跟父进程的联系和区别是什么呢？

我很想建议你看看linux内核的注解（有兴趣能够看看，那里才有本质上的了解），总之,fork后，子进程会复制父进程的task_struct结构，并为子进程的堆栈分配物理页。理论上来讲，子进程应该完整地复制父进程的堆，栈以及数据空间，可是2者共享正文段。

关于写时复制：因为通常 fork后面都接着exec，因此，如今的 fork都在用写时复制的技术，顾名思意，就是，数据段，堆，栈，一开始并不复制，由父，子进程共享，并将这些内存设置为只读。直到父，子进程一方尝试写这些区域，则内核才为须要修改的那片内存拷贝副本。这样作能够提升 fork的效率。

 

三.多线程

线程是可执行代码的可分派单元。这个名称来源于“执行的线索”的概念。在基于线程的多任务的环境中，全部进程有至少一个线程，可是它们能够具备多个任务。这意味着单个程序能够并发执行两个或者多个任务。

简而言之，线程就是把一个进程分为不少片，每一片均可以是一个独立的流程。这已经明显不一样于多进程了，进程是一个拷贝的流程，而线程只是把一条河流截成不少条小溪。它没有拷贝这些额外的开销，可是仅仅是现存的一条河流，就被多线程技术几乎无开销地转成不少条小流程，它的伟大就在于它少之又少的系统开销。（固然伟大的后面又引起了重入性等种种问题，这个后面慢慢比较）。

仍是先看linux提供的多线程的系统调用：

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

Returns: 0 if OK, error number on failure

第一个参数为指向线程标识符的指针。
第二个参数用来设置线程属性。
第三个参数是线程运行函数的起始地址。
最后一个参数是运行函数的参数。

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

 
void* task1(void*);
void* task2(void*);


void usr();
int p1,p2;

int main()
{
    usr();
    getchar();
    return 1;
}

 

void usr()
{
       pthread_t pid1, pid2;
    　　pthread_attr_t attr;
       void *p;
       int ret=0;
       pthread_attr_init(&attr);         //初始化线程属性结构
       pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);   //设置attr结构为分离
       pthread_create(&pid1, &attr, task1, NULL);         //建立线程，返回线程号给pid1,线程属性设置为attr的属性，线程函数入口为task1，参数为NULL
    　 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
　　　　pthread_create(&pid2, &attr, task2, NULL);
　　　　//前台工做

　　　　ret=pthread_join(pid2, &p);         //等待pid2返回，返回值赋给p
       printf("after pthread2:ret=%d,p=%d/n", ret,(int)p);          

}

void* task1(void *arg1)
{
　　printf("task1/n");
　　//艰苦而没法预料的工做，设置为分离线程，任其自生自灭
    pthread_exit( (void *)1);

}

void* task2(void *arg2)
{
    int i=0;
    printf("thread2 begin./n");
    //继续送外卖的工做
    pthread_exit((void *)2);
}

这个多线程的例子应该很明了了，主线程作本身的事情，生成2个子线程，task1为分离，任其自生自灭，而task2仍是继续送外卖，须要等待返回。（因该还记得前面说过僵尸进程吧，线程也是须要等待的。若是不想等待，就设置线程为分离线程）

 额外的说下，linux下要编译使用线程的代码，必定要记得调用pthread库。以下编译：

 gcc -o pthrea -pthread  pthrea.c

 

四.比较以及注意事项

1.看完前面，应该对多进程和多线程有个直观的认识。若是总结多进程和多线程的区别，你确定能说，前者开销大，后者开销较小。确实，这就是最基本的区别。

2.线程函数的可重入性：

说到函数的可重入，和线程安全，我偷懒了，引用网上的一些总结。

线程安全：概念比较直观。通常说来，一个函数被称为线程安全的，当且仅当被多个并发线程反复调用时，它会一直产生正确的结果。

可重入：概念基本没有比较正式的完整解释，可是它比线程安全要求更严格。根据经验，所谓“重入”，常见的状况是，程序执行到某个函数foo()时，收到信号，因而暂停目前正在执行的函数，转到信号处理函数，而这个信号处理函数的执行过程当中，又偏偏也会进入到刚刚执行的函数foo()，这样便发生了所谓的重入。此时若是foo()可以正确的运行，并且处理完成后，以前暂停的foo()也可以正确运行，则说明它是可重入的。

线程安全的条件：

要确保函数线程安全，主要须要考虑的是线程之间的共享变量。属于同一进程的不一样线程会共享进程内存空间中的全局区和堆，而私有的线程空间则主要包括栈和寄存器。所以，对于同一进程的不一样线程来讲，每一个线程的局部变量都是私有的，而全局变量、局部静态变量、分配于堆的变量都是共享的。在对这些共享变量进行访问时，若是要保证线程安全，则必须经过加锁的方式。

可重入的判断条件：

要确保函数可重入，需知足一下几个条件：

一、不在函数内部使用静态或全局数据 
二、不返回静态或全局数据，全部数据都由函数的调用者提供。 
三、使用本地数据，或者经过制做全局数据的本地拷贝来保护全局数据。
四、不调用不可重入函数。

可重入与线程安全并不等同，通常说来，可重入的函数必定是线程安全的，但反过来不必定成立。它们的关系可用下图来表示：

好比：strtok函数是既不可重入的，也不是线程安全的；加锁的strtok不是可重入的，但线程安全；而strtok_r既是可重入的，也是线程安全的。

若是咱们的线程函数不是线程安全的，那在多线程调用的状况下，可能致使的后果是显而易见的——共享变量的值因为不一样线程的访问，可能发生不可预料的变化，进而致使程序的错误，甚至崩溃。

 

3.关于IPC(进程间通讯)

因为多进程要并发协调工做，进程间的同步，通讯是在所不免的。

稍微列举一下linux常见的IPC.

linux下进程间通讯的几种主要手段简介：

1. 管道（Pipe）及有名管道（named pipe）：管道可用于具备亲缘关系进程间的通讯，有名管道克服了管道没有名字的限制，所以，除具备管道所具备的功能外，它还容许无亲缘关系进程间的通讯；
2. 信号（Signal）：信号是比较复杂的通讯方式，用于通知接受进程有某种事件发生，除了用于进程间通讯外，进程还能够发送信号给进程自己；linux除了支持Unix早期信号语义函数sigal外，还支持语义符合Posix.1标准的信号函数sigaction（实际上，该函数是基于BSD的，BSD为了实现可靠信号机制，又可以统一对外接口，用sigaction函数从新实现了signal函数）；
3. 报文（Message）队列（消息队列）：消息队列是消息的连接表，包括Posix消息队列system V消息队列。有足够权限的进程能够向队列中添加消息，被赋予读权限的进程则能够读走队列中的消息。消息队列克服了信号承载信息量少，管道只能承载无格式字节流以及缓冲区大小受限等缺点。
4. 共享内存：使得多个进程能够访问同一块内存空间，是最快的可用IPC形式。是针对其余通讯机制运行效率较低而设计的。每每与其它通讯机制，如信号量结合使用，来达到进程间的同步及互斥。
5. 信号量（semaphore）：主要做为进程间以及同一进程不一样线程之间的同步手段。
6. 套接口（Socket）：更为通常的进程间通讯机制，可用于不一样机器之间的进程间通讯。起初是由Unix系统的BSD分支开发出来的，但如今通常能够移植到其它类Unix系统上：Linux和System V的变种都支持套接字。                                                                                                

或许你会有疑问，那多线程间要通讯，应该怎么作？前面已经说了，多数的多线程都是在同一个进程下的，它们共享该进程的全局变量，咱们能够经过全局变量来实现线程间通讯。若是是不一样的进程下的2个线程间通讯，直接参考进程间通讯。

 

4.关于线程的堆栈

说一下线程本身的堆栈问题。

是的，生成子线程后，它会获取一部分该进程的堆栈空间，做为其名义上的独立的私有空间。（为什么是名义上的呢？)因为，这些线程属于同一个进程，其余线程只要获取了你私有堆栈上某些数据的指针，其余线程即可以自由访问你的名义上的私有空间上的数据变量。（注：而多进程是不能够的，由于不一样的进程，相同的虚拟地址，基本不可能映射到相同的物理地址）

 

5.在子线程里fork

看过好几回有人问，在子线程函数里调用system或者 fork为什么出错，或者fork产生的子进程是彻底复制父进程的吗？

我测试过，只要你的线程函数知足前面的要求，都是正常的。

 1 #include<stdio.h>
 2 #include<string.h>
 3 #include<stdlib.h>
 4 #include<unistd.h>
 5 #include<pthread.h>
 6                                                                                                 
 7 void* task1(void *arg1)
 8 {
 9     printf("task1/n");
10     system("ls");
11     pthread_exit( (void *)1);
12 }
13                                                                                                 
14 int main()
15 {
16   int ret=0;
17   void *p;
18    int p1=0;
19    pthread_t pid1;
20     pthread_create(&pid1, NULL, task1, NULL);
21     ret=pthread_join(pid1, &p);
22      printf("end main/n");
23     return 1;
24 }

上面这段代码就能够正常得调用ls指令。

不过，在同时调用多进程（子进程里也调用线程函数）和多线程的状况下，函数体内颇有可能死锁。

具体的例子能够看看这篇文章。

http://www.cppblog.com/lymons/archive/2008/06/01/51836.aspx