多进程和多线程的区别和联系

发布时间：2023-05-19

一、c++多进程和多线程的区别

在c++中，多进程和多线程都可以实现并发编程。但是多进程和多线程有以下区别：

  1. 多进程是指操作系统中可以同时运行多个独立的进程，每个进程之间都是独立的空间，拥有独立的内存空间。而多线程是指在一个进程中运行的多个线程，所有线程共享同一个地址空间。
  2. 多进程中的进程之间通信可以通过IPC（进程间通信）机制，例如管道，消息队列等。而多线程之间的通信可以通过共享内存，消息队列等。
  3. 在多进程中，每个进程的运行是独立的，一个进程挂掉不会影响其他进程的运行。而在多线程中，一个线程的挂掉可能会影响整个进程的运行。 下面给出c++多进程的示例代码：
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
    pid_t pid;
    pid = fork();  // 创建一个子进程
    if(pid < 0)  // 子进程创建失败
    {
        printf("Fork error!");
        return -1;
    }
    else if(pid == 0)  // 子进程
    {
        printf("This is child process!pid=%d\n",getpid());
        return 0;
    }
    else  // 父进程
    {
        printf("This is parent process!pid=%d,child_pid=%d\n",getpid(),pid);
        waitpid(pid,NULL,0);  // 等待子进程退出
    }
    return 0;
}

二、多线程和多进程的区别

多线程和多进程的区别如下：

  1. 多进程中每个进程有独立的内存空间，而多线程中所有线程共享同一块内存空间。
  2. 多进程中进程切换的代价较高，因为进程需要切换全局变量，虚拟内存等信息。而多线程中线程切换的代价较低，因为线程只需要保存少量的寄存器和堆栈信息即可。
  3. 多线程中编程的复杂度相对较低，因为多线程之间可以直接共享数据，不需要借助IPC机制。而多进程中编程的复杂度较高，因为进程之间需要借助IPC机制进行通信。 下面给出多线程的示例代码：
#include <stdio.h>
#include <pthread.h>
void *fun(void *arg)
{
    printf("This is thread!tid=%ld\n",pthread_self());
    pthread_exit(NULL);
}
int main()
{
    pthread_t tid;
    int ret;
    ret = pthread_create(&tid,NULL,fun,NULL);  // 创建一个线程
    if(ret != 0)  // 线程创建失败
    {
        printf("Create thread error!");
        return -1;
    }
    printf("This is main thread!tid=%ld\n",pthread_self());
    pthread_join(tid,NULL);  // 等待线程退出
    return 0;
}

三、python多进程和多线程的区别

在python中，多进程和多线程都可以方便地实现并发编程。但是它们有以下区别：

  1. 多进程中每个进程都有独立的全局变量和堆栈，而多线程中所有线程都共享同一块全局变量和堆栈。
  2. 在多进程中使用pickle进行进程间通信，而在多线程中使用queue进行线程间通信。
  3. 在多进程中多个进程之间不会有GIL（全局解释锁）的竞争，因此多进程可以充分利用多核CPU的优势。而在多线程中，GIL会导致多个线程无法同时执行python字节码，因此不能充分利用多核CPU的优势。 下面给出python多进程的示例代码：
from multiprocessing import Process
def fun():
    print("This is child process!pid=%d"%(os.getpid()))
if __name__=='__main__':
    p = Process(target=fun)  # 创建一个子进程
    p.start()
    p.join()
    print("This is parent process!pid=%d"%(os.getpid()))

四、多进程与多线程的优缺点

  1. 多进程的优点：多进程可以充分利用多核CPU，因此在CPU密集型任务中效率较高；每个进程都有独立的地址空间，因此不会出现内存共享的问题；进程之间的通信可以使用IPC机制，例如管道，消息队列等。
  2. 多进程的缺点：进程切换的代价较高，因为进程需要切换全局变量，虚拟内存等信息；进程之间通信需要使用IPC机制，编程复杂度较高。
  3. 多线程的优点：线程切换的代价较低，因为线程只需要保存少量的寄存器和堆栈信息即可；线程之间可以直接共享数据，编程复杂度较低。
  4. 多线程的缺点：GIL会导致多个线程无法同时执行python字节码，因此不能充分利用多核CPU的优势；多个线程共享同一块内存空间，容易出现内存共享的问题。

五、linux多进程和多线程区别

在linux中，多进程和多线程的区别与c++和python中是类似的。下面简要总结一下：

  1. 多进程中每个进程有独立的内存空间和堆栈，而多线程中所有线程共享同一块内存空间。
  2. 多进程之间的通信可以使用IPC机制，例如管道，消息队列等；而多线程之间可以使用共享内存，消息队列等。
  3. 在多线程中，GIL会导致多个线程无法同时执行python字节码，因此不能充分利用多核CPU的优势。 下面给出linux多线程的示例代码：
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
void *fun1(void *arg)
{
    printf("This is thread1!tid=%lu\n",pthread_self());
    pthread_exit(NULL);
}
void *fun2(void *arg)
{
    printf("This is thread2!tid=%lu\n",pthread_self());
    pthread_exit(NULL);
}
int main()
{
    pthread_t tid1,tid2;
    int ret;
    ret = pthread_create(&tid1,NULL,fun1,NULL);  // 创建线程1
    if(ret != 0)  // 线程创建失败
    {
        printf("Create thread1 error!");
        return -1;
    }
    ret = pthread_create(&tid2,NULL,fun2,NULL);  // 创建线程2
    if(ret != 0)  // 线程创建失败
    {
        printf("Create thread2 error!");
        return -1;
    }
    printf("This is main thread!tid=%lu\n",pthread_self());
    pthread_join(tid1,NULL);  // 等待线程1退出
    pthread_join(tid2,NULL);  // 等待线程2退出
    return 0;
}
推荐文章