什么是多进程和多线程及区别

多线程和多进程的区别（C++）很想写点关于多进程和多线程的东西，我确实很爱他们。

但是每每想动⼿写点关于他们的东西，却总是求全⼼理作祟，始终动不了⼿。

今天终于下了决⼼，写点东西，以后可以再修修补补也⽆妨。

⼀.为何需要多进程（或者多线程），为何需要并发？这个问题或许本⾝都不是个问题。

但是对于没有接触过多进程编程的朋友来说，他们确实⽆法感受到并发的魅⼒以及必要性。

我想，只要你不是整天都写那种int main()到底的代码的⼈，那么或多或少你会遇到代码响应不够⽤的情况，也应该有尝过并发编程的甜头。

就像⼀个快餐点的服务员，既要在前台接待客户点餐，⼜要接电话送外卖，没有分⾝术肯定会忙得你焦头烂额的。

幸运的是确实有这么⼀种技术，让你可以像孙悟空⼀样分⾝，灵魂出窍，乐哉乐哉地轻松应付⼀切状况,这就是多进程/线程技术。

并发技术，就是可以让你在同⼀时间同时执⾏多条任务的技术。

你的代码将不仅仅是从上到下，从左到右这样规规矩矩的⼀条线执⾏。

你可以⼀条线在main函数⾥跟你的客户交流，另⼀条线，你早就把你外卖送到了其他客户的⼿⾥。

所以，为何需要并发？因为我们需要更强⼤的功能，提供更多的服务，所以并发，必不可少。

⼆.多进程什么是进程。

最直观的就是⼀个个pid,官⽅的说法就：进程是程序在计算机上的⼀次执⾏活动。

说得简单点，下⾯这段代码执⾏的时候[cpp]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();[cpp]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. else22. {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 15806the exit pid:15806i am the parent process, my process id is 15805the exit pid:15805这是gcc测试下的运⾏结果。

多线程知识点总结归纳多线程知识点总结归纳如下：1. 线程和进程的区别- 进程是程序的一个执行实例，每个进程都有自己的独立内存空间、代码和数据，相互之间不会直接共享资源。

线程是在进程内部运行的一段代码，多个线程可以共享同一个进程的资源。

2. 多线程的优势- 提高程序的并发性和响应性，能够更有效地利用 CPU 资源。

- 使得程序能够更轻松地实现并发处理和多任务处理。

- 能够通过多线程实现一些复杂任务，如网络编程、图形界面等。

3. 多线程的基本概念- 线程调度：操作系统通过调度算法决定哪个线程应当运行，哪个线程应当阻塞或唤醒。

- 线程同步：多个线程访问共享数据时需要进行同步操作，以避免数据竞争和死锁等问题。

- 线程通信：多个线程之间需要进行通信，以进行资源共享或协作完成任务。

4. 多线程的创建和启动- 使用线程类：在 Java 中，可以通过继承 Thread 类或实现 Runnable 接口来创建线程。

- 线程生命周期：线程的生命周期包括新建、就绪、运行、阻塞和死亡等状态。

5. 线程的安全性- 多线程程序需要考虑线程安全性，以避免数据竞争和死锁等问题。

- 常用的线程安全性方法包括加锁、使用线程安全的数据结构和对象等。

6. 线程的调度- 多线程程序的运行顺序由操作系统的调度算法决定，而且在不同的操作系统上可能有不同的调度策略。

- 线程的调度策略包括抢占式调度和协作式调度等。

7. 线程的优先级- 线程的优先级决定了它在被调度时的优先级，可以通过设置线程的优先级来影响它的调度顺序。

8. 线程的阻塞和唤醒- 线程在执行过程中可能会因为某些原因而阻塞，需要等待一定的条件满足后才能被唤醒继续执行。

- 一些常见的线程阻塞和唤醒操作包括等待、通知、等待超时等。

9. 线程同步的方法- 使用锁机制：在多线程程序中通常使用锁来保护共享资源，以避免数据竞争和执行顺序问题。

- 使用同步代码块：通过 synchronized 关键字或 ReentrantLock 类等来创建同步代码块，保护共享资源的访问。

1.多进程多线程 1.线程是程序执⾏行行的最⼩小单位，⽽而进程是操作系统分配资源的最⼩小单位；2.⼀一个进程由⼀一个或多个线程组成，线程是⼀一个进程中代码的不不同执⾏行行路路线；3.进程之间相互独⽴立，但同⼀一进程下的各个线程之间共享程序的内存空间(包括代码段、数据集、堆等)及⼀一些进程级的资源(如打开⽂文件和信号)，某进程内的线程在其它进程不不可⻅见；4.调度和切换：线程上下⽂文切换⽐比进程上下⽂文切换要快得多。

　a.进程是资源分配的基本单位，线程是cpu调度，或者说是程序执⾏行行的最⼩小单位。

b.进程有独⽴立的地址空间，⽐比如在linux下⾯面启动⼀一个新的进程，系统必须分配给它独⽴立的地址空间，建⽴立众多的数据表来维护它的代码段、堆栈段和数据段，这是⼀一种⾮非常昂贵的多任务⼯工作⽅方式。

⽽而运⾏行行⼀一个进程中的线程，它们之间共享⼤大部分数据，使⽤用相同的地址空间，因此启动⼀一个线程，切换⼀一个线程远⽐比进程操作要快，花费也要⼩小得多。

当然，线程是拥有⾃自⼰己的局部变量量和堆栈（注意不不是堆）的，⽐比如在windows中⽤用beginthreadex创建⼀一个新进程就会在调⽤用CreateThread的同时申请⼀一个专属于线程的数据块（tiddata)。

c.线程之间的通信⽐比较⽅方便便。

同⼀一进程下的线程共享数据（⽐比如全局变量量，静态变量量），通过这些数据来通信不不仅快捷⽽而且⽅方便便，当然如何处理理好这些访问的同步与互斥正是编写多线程程序的难点。

⽽而进程之间的通信只能通过进程通信的⽅方式进⾏行行。

d.由b，可以轻易易地得到结论：多进程⽐比多线程程序要健壮。

⼀一个线程死掉整个进程就死掉了了，但是在保护模式下，⼀一个进程死掉对另⼀一个进程没有直接影响。

e.线程的执⾏行行与进程是有区别的。

每个独⽴立的线程有有⾃自⼰己的⼀一个程序⼊入⼝口，顺序执⾏行行序列列和程序的出⼝口，但是线程不不能独⽴立执⾏行行，必须依附与程序之中， 由应⽤用程序提供多个线程的并发控制。

多线程与多进程的区别（1）多线程多进程的区别维度多进程多线程总结数据共享、同步数据是分开的:共享复杂，需要⽤IPC;同步简单多线程共享进程数据：共享简单；同步复杂各有优势内存、CPU占⽤内存多，切换复杂，CPU利⽤率低占⽤内存少，切换简单，CPU利⽤率⾼线程占优创建销毁、切换创建销毁、切换复杂，速度慢创建销毁、切换简单，速度快线程占优编程调试编程简单，调试简单编程复杂，调试复杂进程占优可靠性进程间不会相互影响⼀个线程挂掉将导致整个进程挂掉进程占优分布式适应于多核、多机分布；如果⼀台机器不够，扩展到多台机器⽐较简单适应于多核分布进程占优然后我们来看下线程和进程间的⽐较⼦进程继承⽗进程的属性：⼦线程继承主线程的属性：实际⽤户ID，实际组ID，有效⽤户ID，有效组ID；附加组ID；进程组ID；会话ID；控制终端；设置⽤户ID标志和设置组ID标志；当前⼯作⽬录；根⽬录；⽂件模式创建屏蔽字（umask）；信号屏蔽和安排；针对任⼀打开⽂件描述符的在执⾏时关闭（close-on-exec）标志；环境；连接的共享存储段；存储映射；资源限制；进程中的所有信息对该进程的所有线程都是共享的；可执⾏的程序⽂本；程序的全局内存；堆内存；栈；⽂件描述符；信号的处理是进程中所有线程共享的（注意：如果信号的默认处理是终⽌该进程那么即是把信号传给某个线程也⼀样会将进程杀掉）；⽗⼦进程之间的区别：⼦线程特有的：fork的返回值(=0⼦进程)；进程ID不同；两个进程具有不同的⽗进程ID；⼦进程的tms_utime,tms_stime,tms_cutime以及tms_ustime均被设置为0；不继承⽗进程设置的⽂件锁；⼦进程的未处理闹钟被清除；⼦进程的未处理信号集设置为空集；线程ID；⼀组寄存器值；栈；调度优先级和策略；信号屏蔽字；errno变量；线程私有数据；1)需要频繁创建销毁的优先⽤线程。

实例：web服务器。

来⼀个建⽴⼀个线程，断了就销毁线程。

Python的多线程（threading）与多进程（multiprocessing）进程：程序的⼀次执⾏（程序载⼊内存，系统分配资源运⾏）。

每个进程有⾃⼰的内存空间，数据栈等，进程之间可以进⾏通讯，但是不能共享信息。

线程：所有的线程运⾏在同⼀个进程中，共享相同的运⾏环境。

每个独⽴的线程有⼀个程序⼊⼝，顺序执⾏序列和程序的出⼝。

线程的运⾏可以被强占，中断或者暂时被挂起（睡眠），让其他的线程运⾏。

⼀个进程中的各个线程共享同⼀⽚数据空间。

多线程import threadingdef thread_job():print "this is added thread,number is {}".format(threading.current_thread())def main():added_thread = threading.Thread(target = thread_job) #添加线程added_thread.start() #执⾏添加的线程print threading.active_count() #当前已被激活的线程的数⽬print threading.enumerate() #激活的是哪些线程print threading.current_thread() #正在运⾏的是哪些线程if __name__ == "__main__":main()this is added thread,number is <Thread(Thread-6, started 6244)>6[<HistorySavingThread(IPythonHistorySavingThread, started 7588)>, <ParentPollerWindows(Thread-3, started daemon 3364)>, <Heartbeat(Thread-5, started daemon 3056)>, <_MainThread(MainThread, started 1528)>, <Thread(Thread-6, started <_MainThread(MainThread, started 1528)>#join 功能等到线程执⾏完之后再回到主线程中去import threadingimport timedef T1_job():print "T1 start\n"for i in range(10):time.sleep(0.1)print "T1 finish"def T2_job():print 'T2 start'print 'T2 finish'def main():thread1 = threading.Thread(target = T1_job) #添加线程thread2 = threading.Thread(target = T2_job)thread1.start() #执⾏添加的线程thread2.start()thread1.join()thread2.join()print 'all done\n'if __name__ == "__main__":main()T1 startT2 startT2 finishT1 finishall done#queue 多线程各个线程的运算的值放到⼀个队列中，到主线程的时候再拿出来,以此来代替#return的功能，因为在线程是不能返回⼀个值的import timeimport threadingfrom Queue import Queuedef job(l,q):q.put([i**2 for i in l])def multithreading(data):q = Queue()threads = []for i in xrange(4):t = threading.Thread(target = job,args = (data[i],q))t.start()threads.append(t)for thread in threads:thread.join()results = []for _ in range(4):results.append(q.get())print resultsif __name__ == "__main__":data = [[1,2,3],[4,5,6],[3,4,3],[5,5,5]]multithreading(data)[[1, 4, 9], [16, 25, 36], [9, 16, 9], [25, 25, 25]]#多线程的锁import threadingimport timedef T1_job():global A,locklock.acquire()for i in xrange(10):A += 1print 'T1_job',Alock.release()def T2_job():global A,locklock.acquire()for i in xrange(10):A += 10print 'T2_job',Aif __name__ == "__main__":lock = threading.Lock()A = 0 #全局变量thread1 = threading.Thread(target = T1_job) #添加线程thread2 = threading.Thread(target = T2_job)thread1.start() #执⾏添加的线程thread2.start()thread1.join()thread2.join() 全局解释器锁ＧＩＬ（Global Interpreter Lock）GIL并不是Python的特性，他是CPython引⼊的概念，是⼀个全局排他锁。

⼀⽂读懂什么是进程、线程、协程（建议收藏）进程我们都知道计算机的核⼼是CPU，它承担了所有的计算任务；⽽操作系统是计算机的管理者，它负责任务的调度、资源的分配和管理，统领整个计算机硬件；应⽤程序则是具有某种功能的程序，程序是运⾏于操作系统之上的。

进程是⼀个具有⼀定独⽴功能的程序在⼀个数据集上的⼀次动态执⾏的过程，是操作系统进⾏资源分配和调度的⼀个独⽴单位，是应⽤程序运⾏的载体。

进程是⼀种抽象的概念，从来没有统⼀的标准定义。

进程⼀般由程序、数据集合和进程控制块三部分组成。

程序⽤于描述进程要完成的功能，是控制进程执⾏的指令集；数据集合是程序在执⾏时所需要的数据和⼯作区；程序控制块(Program Control Block，简称PCB)，包含进程的描述信息和控制信息，是进程存在的唯⼀标志。

进程具有的特征：动态性：进程是程序的⼀次执⾏过程，是临时的，有⽣命期的，是动态产⽣，动态消亡的；并发性：任何进程都可以同其他进程⼀起并发执⾏；独⽴性：进程是系统进⾏资源分配和调度的⼀个独⽴单位；结构性：进程由程序、数据和进程控制块三部分组成。

线程在早期的操作系统中并没有线程的概念，进程是能拥有资源和独⽴运⾏的最⼩单位，也是程序执⾏的最⼩单位。

任务调度采⽤的是时间⽚轮转的抢占式调度⽅式，⽽进程是任务调度的最⼩单位，每个进程有各⾃独⽴的⼀块内存，使得各个进程之间内存地址相互隔离。

后来，随着计算机的发展，对CPU的要求越来越⾼，进程之间的切换开销较⼤，已经⽆法满⾜越来越复杂的程序的要求了。

于是就发明了线程。

线程是程序执⾏中⼀个单⼀的顺序控制流程，是程序执⾏流的最⼩单元，是处理器调度和分派的基本单位。

⼀个进程可以有⼀个或多个线程，各个线程之间共享程序的内存空间(也就是所在进程的内存空间)。

⼀个标准的线程由线程ID、当前指令指针(PC)、寄存器和堆栈组成。

⽽进程由内存空间(代码、数据、进程空间、打开的⽂件)和⼀个或多个线程组成。

Python中的多线程和多进程编程技术随着计算机系统硬件性能的提高，多核心处理器的出现和并行计算能力的加强，多线程和多进程编程技术越来越受到了关注。

在Python编程中，使用多线程和多进程技术可以有效地提高程序的运行效率和性能。

本文将介绍Python中的多线程和多进程编程技术，以及它们的优缺点和适用条件。

一、多线程编程技术在计算机系统中，线程是指进程中的一个单独的执行路径，可以共享进程的资源和数据，每个线程独立地执行任务。

在Python 中，可以使用threading模块来实现多线程编程。

下面是一个基本的多线程示例：```pythonimport threadingdef say_hello(name):print("Hello, %s!" %name)if __name__ == '__main__':t1 = threading.Thread(target=say_hello, args=('Alice',))t2 = threading.Thread(target=say_hello, args=('Bob',))t1.start()t2.start()t1.join()t2.join()```在上面的示例中，我们定义了一个名为say_hello的函数，该函数接收一个参数name，并在控制台打印出“Hello, name!”。

然后，我们使用threading.Thread类创建两个线程t1和t2，将say_hello 函数作为线程的目标函数，并将参数传递给args参数。

然后，我们通过调用t1和t2的start()方法启动这两个线程，并使用join()方法等待它们完成。

多线程编程技术的优点在于可以充分利用多核心处理器的并行计算能力，提高程序的运行效率和性能。

另外，多线程编程适用于一些CPU密集型的任务，例如图像处理、密码破解等。

多任务与多线程的区别1.多任务在计算中，多任务是⼀种多个任务（也称之为进程）共享处理资源（如CPU）的⽅法。

在多任务操作系统上，例如Windows XP，您可以同时运⾏多个应⽤程序。

多任务实质是指操作系统在每个计算任务间快速切换，以致于看上去不同的应⽤似乎在同时执⾏多项操作。

当CPU时钟频率稳步提⾼时，不仅应⽤程序的运⾏速率可以更快，⽽且操作系统在应⽤间的切换速率也更快。

这样就提供了更好的整体性能——⼀台计算机可以同时发⽣多项操作，每项应⽤可以更快速地运⾏。

2. 单核对于拥有单个CPU核的计算机，任意时刻只能运⾏⼀项任务，这也意味着CPU主动地执⾏该任务的指令。

多任务通过调度（Scheduling）哪⼀项任务在哪⼀时刻运⾏以及何时切换到另⼀项任务，解决了这⼀问题。

图1。

单核系统⽀持多任务操作系统。

⽂字处理、Email、r⽹页浏览器、防病毒软件、进程、操作系统、CPU核3. 多核当运⾏于多核系统时，多任务操作系统可以真正地并发执⾏多项任务。

针对不同的任务，多个计算引擎独⽴地⼯作。

例如，在⼀个双核系统，有四项应⽤，如⽂字处理、电⼦邮件、⽹页浏览和防病毒软件，每项应⽤可以同时访问⼀个独⽴的处理器核。

您可以在检查电⼦邮件的同时输⼊⼀封⽂档，真正实现多任务，从⽽改善应⽤的整体性能。

图2。

双核系统⽀持多任务操作系统，如Windows XP，以真正地同时执⾏两项任务。

⽂字处理、Email电⼦邮件、⽹页浏览器、防病毒软件、进程、操作系统、CPU核操作系统通过在独⽴的CPU核之间划分不同的应⽤或进程，从⽽更有效地执⾏多项应⽤。

该计算机可以将⼯作任务分摊化——每个核在管理和切换原先⼀半数量的应⽤任务，并提供更好的整体吞吐量与性能。

实际上，这些应⽤任务是并⾏地执⾏的。

4. 多线程多线程将多任务的思想拓展到应⽤，因此，您可以将单个应⽤中的特定步骤进⼀步分解成⼀个个线程，每个线程可以并⾏运⾏。

操作系统不仅在不同的应⽤任务间分配处理时间，⽽且在⼀项应⽤的每个线程间分配处理时间。

python多进程总结概述由于python中全局解释器锁（GIL）的存在，所以python多线程并不能有效利⽤CPU多核的性能（相当于单核并发）实现多线程多核并⾏，所以在对CPU密集型的程序时处理效率较低，反⽽对IO密集型的才有效率的⼤幅度提⾼。

如果想要充分地使⽤多核CPU的资源，需要使⽤多进程，python中提供multiprocessing实现。

CPU密集型：主要特点是需要进⾏⼤量的计算，消耗CPU资源，⽐如计算圆周率、对视频进⾏⾼清解码等等，全靠CPU的运算能⼒。

这种计算密集型任务虽然也可以⽤多任务完成，但是任务越多，花在任务切换的时间就越多，CPU执⾏任务的效率就越低，所以，要最⾼效地利⽤CPU，计算密集型任务同时进⾏的数量应当等于CPU的核⼼数。

IO密集型：主要涉及到⽹络、磁盘IO的任务都是IO密集型任务，这类任务的特点是CPU消耗很少，任务的⼤部分时间都在等待IO操作完成（因为IO的速度远远低于CPU和内存的速度）。

对于IO密集型任务，任务越多，CPU效率越⾼，但也有⼀个限度。

常见的⼤部分任务都是IO密集型任务，⽐如Web应⽤。

所以python在多线程处理CPU密集型程序时可以选择多进程实现，有效的利⽤多核提升效率；⽽IO密集型的由于99%的时间都花在IO上，花在CPU上的时间很少，所以多线程也能提⾼很⼤效率Process对象multiprocessing.Process类类似于threading.Thread，涉及参数以及属性⽅法如下multiprocessing.Process(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)参数group 应该始终是 None，它仅⽤于兼容 threading.Threadtarget 是由 run() ⽅法调⽤的可调⽤对象，它默认为 None ，意味着什么都没有被调⽤name 是进程名称args 是⽬标调⽤的参数元组kwargs 是⽬标调⽤的关键字参数字典daemon 表是否为守护进程，为 True 或 False⽅法run() 表⽰进程活动的⽅法。

Django框架开发中的多线程和多进程处理在Django框架开发中，多线程和多进程处理是关键的技术点。

本文将着重探讨这两种处理方式在Django框架中的应用和实践。

一、引言Django是一个高效、开放源代码的Web应用程序框架，广泛应用于Web开发领域。

在Django框架的开发中，为了提高系统的并发处理能力和资源利用率，多线程和多进程技术成为了不可或缺的部分。

二、多线程处理多线程处理是指在一个程序中同时运行多个线程，每个线程都可以独立执行任务。

在Django框架中，多线程处理主要用于以下几个方面：1. 提高并发处理能力：通过使用多线程处理，可以同时处理多个用户请求，提高系统的并发能力，加快用户的响应速度。

2. 利用空闲资源：在某些场景下，系统可能存在一些空闲的资源，如数据库连接、文件IO等。

利用多线程处理技术，可以充分利用这些资源，提高系统的资源利用率。

3. 异步任务处理：有些任务可能是异步执行的，例如发送邮件、生成报表等。

通过多线程处理，可以在后台线程中执行这些异步任务，避免阻塞主线程的执行。

三、多进程处理多进程处理是指在一个程序中同时运行多个进程，每个进程都有独立的内存空间和系统资源。

在Django框架中，多进程处理主要用于以下几个方面：1. 充分利用多核CPU：在多核CPU的计算环境下，通过使用多进程处理，可以同时利用多个CPU核心，提高系统的计算能力。

2. 故障隔离和提高稳定性：当一个进程出现故障时，其他进程不会受到影响，从而提高了系统的稳定性和可靠性。

3. 分布式任务处理：在大规模系统中，可能需要将任务分配给多个进程进行处理。

通过多进程处理，可以实现任务的并行处理，提高系统的处理能力。

四、多线程和多进程的选择在Django框架的开发中，选择使用多线程还是多进程处理，需要根据具体场景和需求来决定。

1. 如果系统需要处理大量的IO密集型任务，如网络请求、数据库查询等，多线程处理是一个不错的选择。

进程和线程是什么关系与区别
进程
进程是程序的⼀次执⾏过程，是⼀个动态概念，是程序在执⾏过程中分配和管理资源的基本单位，每⼀个进程都有⼀个⾃⼰的地址空间，⾄少有5 种基本状态，它们是：初始态，执⾏态，等待状态，就绪状态，终⽌状态。

线程
线程是CPU调度和分派的基本单位，它可与同属⼀个进程的其他的线程共享进程所拥有的全部资源。

【进程是资源分配的最⼩单位，线程是CPU调度的最⼩单位】
进程和线程的关系
线程是进程的⼀部分
⼀个线程只能属于⼀个进程，⽽⼀个进程可以有多个线程，但⾄少有⼀个线程
进程和线程的区别
理解它们的差别，我从资源使⽤的⾓度出发。

（所谓的资源就是计算机⾥的中央处理器，内存，⽂件，⽹络等等）
根本区别：进程是操作系统资源分配的基本单位，⽽线程是任务调度和执⾏的基本单位
开销⽅⾯：每个进程都有独⽴的代码和数据空间（程序上下⽂），进程之间切换开销⼤；线程可以看做轻量级的进程，同⼀类线程共享代码和数据空间，每个线程都有⾃⼰独⽴的运⾏栈和程序计数器（PC），线程之间切换的开销⼩
所处环境：在操作系统中能同时运⾏多个进程（程序）；⽽在同⼀个进程（程序）中有多个线程同时执⾏（通过CPU调度，在每个时间⽚中只有⼀个线程执⾏）
内存分配：系统为每个进程分配不同的内存空间；⽽对线程⽽⾔，除了CPU外，系统不会为线程分配内存（线程所使⽤的资源来⾃其所属进程的资源），线程组之间只能共享资源
包含关系：线程是进程的⼀部分，所以线程也被称为轻权进程或者轻量级进程。

Linux学习知识点--进程和线程有什么区别进程和线程的区别学习Linu某来说并不是一件简单的事情，之前作为一个非常的网管大神，遇到Linu某的时候还是表示胡一脸的蒙蔽，真正系统学习了之后才知道这个非常乏味却又充满未知的领域是多么的吸引我的注意。

线程是进程的一个执行流，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。

一个进程由几个线程组成（拥有很多相对独立的执行流的用户程序共享应用程序的大部分数据结构），线程与同属一个进程的其他的线程共享进程所拥有的全部资源。

"进程——资源分配的最小单位，线程——程序执行的最小单位"进程从内核的观点看，进程的目的就是担当分配系统资源（CPU时间、内存等）的基本单位。

是程序执行时的一个实例，即它是程序已经执行到课中程度的数据结构的汇集。

进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。

线程有自己的堆栈和局部变量，但线程没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。

但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。

总的来说就是：进程有独立的地址空间，线程没有单独的地址空间（同一进程内的线程共享进程的地址空间）。

（下面的内容摘自Linu某下的多线程编程）使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务操作方式。

我们知道，在Linu某系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式。

而运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。

python 多进程、多线程、多协程应用场景实例详解（实用版）目录1.Python 多进程、多线程、多协程的概念及区别2.多进程的应用场景实例3.多线程的应用场景实例4.多协程的应用场景实例5.总结正文Python 是一款功能强大的编程语言，其中多进程、多线程和多协程是实现并发编程的重要方式。

它们各自有着不同的应用场景和优缺点，下面我们将通过实例来详细了解它们的使用场景。

一、Python 多进程、多线程、多协程的概念及区别多进程是指在一个程序中同时运行多个进程，每个进程都有自己的独立内存空间和系统资源，它们之间通过进程间通信来交换数据。

多进程适用于 CPU 密集型任务，可以利用多核 CPU 提高程序的执行效率。

多线程是指在一个进程中同时运行多个线程，每个线程共享进程的内存空间和系统资源，它们之间通过共享内存来交换数据。

多线程可以提高程序的执行效率，特别是对于 I/O 密集型任务。

多协程是一种轻量级的并发编程方式，它既不需要切换 CPU，也不需要切换内存，可以在一个线程内部实现多个任务的并发执行。

多协程适用于处理大量 I/O 密集型任务。

二、多进程的应用场景实例假设我们有一个 CPU 密集型任务，需要对大量数据进行计算，我们可以使用多进程来实现并发处理。

例如，我们可以将任务分解为多个子任务，每个子任务由一个进程来完成，这样多个进程可以同时运行，大大提高计算效率。

三、多线程的应用场景实例假设我们有一个I/O密集型任务，需要对大量数据进行读写操作，我们可以使用多线程来实现并发处理。

例如，我们可以使用多个线程同时进行读写操作，这样多个线程可以同时运行，大大提高I/O操作的效率。

四、多协程的应用场景实例假设我们有一个大量I/O密集型任务，需要对大量数据进行异步读写操作，我们可以使用多协程来实现并发处理。

例如，我们可以使用多个协程同时进行异步读写操作，这样多个协程可以同时在一个线程内部执行，大大提高程序的执行效率。

进程、线程、协程之概念理解+线程和进程各⾃有什么区别和优劣⼀、概念⾸先，根据图了解⼀下串⾏，并⾏和并发的基本概念： 1、进程 资源分配的基本单位进程（Process）是计算机中的程序关于某数据集合上的⼀次运⾏活动，是系统进⾏资源分配和调度的基本单位，是操作系统结构的基础。

在早期⾯向进程设计的计算机结构中，进程是程序的基本执⾏实体；在当代⾯向线程设计的计算机结构中，进程是线程的容器。

程序是指令、数据及其组织形式的描述，进程是程序的实体。

Linux系统函数fork（）可在⽗进程中创建⼀个⼦进程，在⽗进程接到新请求时，复制出⼀个⼦进程来处理，即⽗进程监控请求，⼦进程处理，实现并发处理。

注意：必须是Linux系统，windows不能⽤fork。

组成进程是⼀个实体。

每⼀个进程都有它⾃⼰的地址空间，⼀般情况下，包括⽂本区域（text region）、数据区域（data region）和堆栈（stack region）。

⽂本区域存储处理器执⾏的代码；数据区域存储变量和进程执⾏期间使⽤的动态分配的内存；堆栈区域存储着活动过程调⽤的指令和本地变量。

特征动态性：进程的实质是程序在多道程序系统中的⼀次执⾏过程，进程是动态产⽣，动态消亡的。

并发性：任何进程都可以同其他进程⼀起并发执⾏独⽴性：进程是⼀个能独⽴运⾏的基本单位，同时也是系统分配资源和调度的独⽴单位；异步性：由于进程间的相互制约，使进程具有执⾏的间断性，即进程按各⾃独⽴的、不可预知的速度向前推进结构特征：进程由程序、数据和进程控制块三部分组成。

多个不同的进程可以包含相同的程序：⼀个程序在不同的数据集⾥就构成不同的进程，能得到不同的结果；但是执⾏过程中，程序不能发⽣改变。

进程的⼏种状态（1）run（运⾏状态）：正在运⾏的进程或在等待队列中等待的进程，等待的进程只要以得到cpu就可以运⾏（2）Sleep（可中断休眠状态）：相当于阻塞或在等待的状态（3）D（不可中断休眠状态）：在磁盘上的进程（4）T（停⽌状态）：这中状态⽆法直观的看见，因为是进程停⽌后就释放了资源，所以不会留在linux中（5）Z（僵⼫状态）：⼦进程先与⽗进程结束，但⽗进程没有调⽤wait或waitpid来回收⼦进程的资源，所以⼦进程就成了僵⼫进程，如果⽗进程结束后任然没有回收⼦进程的资源，那么1号进程将回收 2、线程 CPU调度和分配的基本单位，程序执⾏的最⼩单位。

进程、线程简介及多线程的优缺点先介绍下进程、线程、多线程，再总结下多线程的优缺点：⼀、进程进程是具有⼀定独⽴功能的程序关于某个数据集合上的⼀次运⾏活动，也就是应⽤程序的执⾏实例，进程是系统进⾏资源分配和调度的⼀个独⽴单位。

每个进程是由私有的虚拟地址空间、代码、数据和其它各种系统资源组成，进程在运⾏过程中创建的资源随着进程的终⽌⽽被销毁，所使⽤的系统资源在进程终⽌时被释放或关闭。

⼆、线程线程是程序中的⼀个执⾏流，⼀个进程中可以包含多个线程，每个线程都有⾃⼰的专有寄存器(栈指针、程序计数器等)，但代码区是共享的，即不同的线程可以执⾏同样的函数。

三、多线程多线程是指程序中包含多个执⾏流，即在⼀个程序（进程）中可以同时运⾏多个不同的线程来执⾏不同的任务，也就是说允许单个程序（进程）创建多个并⾏执⾏的线程来完成各⾃的任务。

在单核处理器的电脑中，线程协调程序在完成⼀个时间⽚之后迅速地在活动的线程之间进⾏切换执⾏。

⽐如⼀个程序执⾏期间，你可以进⾏多个操作，其实就是线程间在飞快的切换，这叫做并发。

在多核电脑中，多线程被实现成混合时间⽚和真实的并⾏，即不同的线程在不同的CPU上执⾏。

1、多线程的优点　多线程处理可以同时运⾏多个线程。

由于多线程应⽤程序将程序划分成多个独⽴的任务,因此可以在以下⽅⾯显著提⾼性能多线程技术使程序的响应速度更快 ,因为⽤户界⾯可以在进⾏其它⼯作的同时⼀直处于活动状态;当前没有进⾏处理的任务时可以将处理器时间让给其它任务;占⽤⼤量处理时间的任务可以定期将处理器时间让给其它任务;可以随时停⽌任务;可以分别设置各个任务的优先级以优化性能2、多线程的缺点线程也是程序，所以线程需要占⽤内存，线程越多占⽤内存也越多；多线程需要协调和管理，所以需要CPU时间跟踪线程；线程之间对共享资源的访问会相互影响，必须解决竞⽤共享资源的问题；线程太多会导致控制太复杂，最终可能造成很多Bug；3、什么时候使⽤多线程耗时或⼤量占⽤处理器的任务阻塞⽤户界⾯操作; 多线程程序⼀般被⽤来在后台执⾏耗时的任务。