什么是多进程和多线程及区别
多线程和多进程的区别（C++）
多线程和多进程的区别（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.多进程多线程 1.线程是程序执⾏行行的最⼩小单位，⽽而进程是操作系统分配资源的最⼩小单位；2.⼀一个进程由⼀一个或多个线程组成，线程是⼀一个进程中代码的不不同执⾏行行路路线；3.进程之间相互独⽴立，但同⼀一进程下的各个线程之间共享程序的内存空间(包括代码段、数据集、堆等)及⼀一些进程级的资源(如打开⽂文件和信号)，某进程内的线程在其它进程不不可⻅见；4.调度和切换：线程上下⽂文切换⽐比进程上下⽂文切换要快得多。
a.进程是资源分配的基本单位，线程是cpu调度，或者说是程序执⾏行行的最⼩小单位。
b.进程有独⽴立的地址空间，⽐比如在linux下⾯面启动⼀一个新的进程，系统必须分配给它独⽴立的地址空间，建⽴立众多的数据表来维护它的代码段、堆栈段和数据段，这是⼀一种⾮非常昂贵的多任务⼯工作⽅方式。
⽽而运⾏行行⼀一个进程中的线程，它们之间共享⼤大部分数据，使⽤用相同的地址空间，因此启动⼀一个线程，切换⼀一个线程远⽐比进程操作要快，花费也要⼩小得多。
当然，线程是拥有⾃自⼰己的局部变量量和堆栈（注意不不是堆）的，⽐比如在windows中⽤用beginthreadex创建⼀一个新进程就会在调⽤用CreateThread的同时申请⼀一个专属于线程的数据块（tiddata)。
c.线程之间的通信⽐比较⽅方便便。
同⼀一进程下的线程共享数据（⽐比如全局变量量，静态变量量），通过这些数据来通信不不仅快捷⽽而且⽅方便便，当然如何处理理好这些访问的同步与互斥正是编写多线程程序的难点。
⽽而进程之间的通信只能通过进程通信的⽅方式进⾏行行。
d.由b，可以轻易易地得到结论：多进程⽐比多线程程序要健壮。
⼀一个线程死掉整个进程就死掉了了，但是在保护模式下，⼀一个进程死掉对另⼀一个进程没有直接影响。
e.线程的执⾏行行与进程是有区别的。
每个独⽴立的线程有有⾃自⼰己的⼀一个程序⼊入⼝口，顺序执⾏行行序列列和程序的出⼝口，但是线程不不能独⽴立执⾏行行，必须依附与程序之中， 由应⽤用程序提供多个线程的并发控制。
c语言 多进程和多线程
进程是一个具有独立功能的程序关于某个数据集合的一次可以并发执行的运行活动，是处于活动状态的计算机程序。进程作为构成系统的基本细胞，不仅是系统内部独立运行的实体，而且是独立竞争资源的基本实体。
进程是资源管理的最小单位，线程是程序执行的最小单位。进程管理着资源（比如cpu、内存、文件等等），而将线程分配到某个cpu上执行。在操作系统设计上，从进程演化出线程，最主要的目的就是更好的支持多处理器系统和减小上下文切换开销。
进程的状态系统为了充分的利用资源,对进程区分了不同的状态.将进程分为新建,运行,阻塞,就绪和完成五个状态.
新建表示进程正在被创建,
运行是进程正在运行,
阻塞是进程正在等待某一个事件发生,
就绪是表示系统正在等待CPU来执行命令,
完成表示进程已经结束了系统正在回收资源.
由于UNIX系统是分时多用户系统, CPU按时间片分配给各个用户使用,而在实质上应该说CPU按时间片分配给各个进程使用,每个进程都有自己的运行环境以使得在CPU做进程切换时不会"忘记"该进程已计算了一半的"半成品”.以DOS的概念来说,进程的切换都 是一次"DOS中断"处理过程, 包括三个层次:
char *string;
说明:
本调用将参数string传递给一个命令解释器(一般为sh)执行,即string被解释为一条命令,由sh执行该命令.若参数string为一个空指针则为检查命令解释器是否存在.
该命令可以同命令行命令相同形式,但由于命令做为一个参数放在系统调用中,应注意编译时对特殊意义字符的处理.命令的查找是按PATH环境变量的定义的.命令所生成的后果一般不会对父进程造成影响.
}
pclose(fd);
2.
多线程与多进程的区别
多线程与多进程的区别（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）
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中的多线程和多进程编程技术，以及它们的优缺点和适用条件。
一、多线程编程技术在计算机系统中，线程是指进程中的一个单独的执行路径，可以共享进程的资源和数据，每个线程独立地执行任务。
在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多进程总结概述由于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框架中的应用和实践。
一、引言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学习知识点--进程和线程有什么区别进程和线程的区别
Linux学习知识点--进程和线程有什么区别进程和线程的区别学习Linu某来说并不是一件简单的事情，之前作为一个非常的网管大神，遇到Linu某的时候还是表示胡一脸的蒙蔽，真正系统学习了之后才知道这个非常乏味却又充满未知的领域是多么的吸引我的注意。
线程是进程的一个执行流，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。
一个进程由几个线程组成（拥有很多相对独立的执行流的用户程序共享应用程序的大部分数据结构），线程与同属一个进程的其他的线程共享进程所拥有的全部资源。
"进程——资源分配的最小单位，线程——程序执行的最小单位"进程从内核的观点看，进程的目的就是担当分配系统资源（CPU时间、内存等）的基本单位。
是程序执行时的一个实例，即它是程序已经执行到课中程度的数据结构的汇集。
进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。
线程有自己的堆栈和局部变量，但线程没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。
但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。
总的来说就是：进程有独立的地址空间，线程没有单独的地址空间（同一进程内的线程共享进程的地址空间）。
（下面的内容摘自Linu某下的多线程编程）使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务操作方式。
我们知道，在Linu某系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式。
而运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。
j2-11线程
NORM_PRIORITY 为普通优先级，通常为 5
对新建的线程通常继承其父类的优先级。用户可以通 过setPriority(int n) 方法来修改系统自动设定的线程 优先级。
四、同步
Java 的运行时环境中，线程是从相同的内存空间开 始运行的，它们共享变量和方法的访问权。 同步问题：A、B线程共享某一对象
class runPrimes { public static void main(String args[]) { primeThread getPrimes = new primeThread () ; //创建一个线程对象 getPrimes . start(); //启动线程 while (primeThread . isAlive()) //isAlive()是ng.Thread的类方法 { System.out.println("Counting the prime number...\n"); try {
三、优先级和调度
在多线程系统中，每个线程都被赋予一个优先级，它决定了线 程获得CPU被调度执行的优先程度。优先级高的线程可以在 短时间段内获得更多的执行时间，线程的优先级如果完全相等， 将被依据“先来先服务”的原则进行调度。
Thread 类有3个有关线程的静态常量：
MIN_PRIORITY MAX_PRIORITY 最小，通常为 1 最大，通常为 10
13．2 Java的多线程实现机制
Java实现多线程的两种方式为：
（1）创建类Thread 的子类，并抑制其run() 方法。
ng.Thread类用于在多线程应用程序构造和访问单个的 多线程。
（2）根据Runnable 接口创建一个类。
applets扩展自Applet类，Java不支持多重继承。因此不能由 Applet类和Thread类派生。Java提供Runnable接口来解决这 个问题。
python 多进程、多线程、多协程应用场景实例详解
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、什么时候使⽤多线程耗时或⼤量占⽤处理器的任务阻塞⽤户界⾯操作; 多线程程序⼀般被⽤来在后台执⾏耗时的任务。
多线程的概念
多线程的概念多线程的概念多线程是指在一个程序中同时运行多个线程，每个线程都可以独立地执行不同的任务。
与单线程相比，多线程可以提高程序的并发性和响应速度，使得程序具有更好的用户体验和更高的效率。
一、多线程的基本概念1. 线程：是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中真正执行任务的部分。
2. 进程：是一个正在执行中的程序，它由代码、数据集合以及一组系统资源组成。
3. 上下文切换：是指CPU从一个进程或者线程切换到另外一个进程或者线程时所需要保存和恢复的所有状态信息。
4. 并发性：是指两个或多个事件在同一时间间隔内发生。
二、多线程的优点1. 提高程序响应速度：当一个任务被阻塞时，其他任务可以继续执行，从而提高了程序响应速度。
2. 提高系统资源利用率：通过充分利用CPU时间片和IO等待时间来提高系统资源利用率。
3. 改善用户体验：当一个任务需要较长时间才能完成时，用户可以同时进行其他操作，从而改善了用户体验。
三、多线程实现方式1. 继承Thread类：通过继承Thread类并重写run()方法来实现多线程。
2. 实现Runnable接口：通过实现Runnable接口并重写run()方法来实现多线程。
3. 实现Callable接口：通过实现Callable接口并重写call()方法来实现多线程，可以返回执行结果。
四、多线程的应用场景1. 网络编程：在网络编程中，一个客户端连接到服务器时，服务器需要为该客户端创建一个新的线程来处理请求。
2. GUI编程：在GUI编程中，一个事件处理程序可以启动一个新的线程来执行长时间运行的任务，从而不阻塞GUI线程。
3. 多媒体处理：在音视频处理中，需要同时进行多个任务，如播放、录制、转码等。
4. 数据库操作：在数据库操作中，可以使用多个线程同时进行查询或更新操作，提高数据库操作效率。
五、多线程的注意事项1. 线程安全问题：当多个线程同时访问同一资源时，可能会出现数据竞争和死锁等问题。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
进程池内部维护一个进程序列，当使用时，去进程池中获取一个进程，如果进程池 序列中没有可供使用的进程，那么程序就会等待，直到进程池中有可用进程为止。 在上面的程序中产生了10个进程，但是只能有5同时被放入进程池，剩下的都被暂 时挂起，并不占用内存空间，等前面的五个进程执行完后，再执行剩下5个进程。
谢谢观看
递归锁
RLcok类的用法和Lock类一模一样，但它支持嵌套，，在多个锁没有释放的时候一般会使用使用RLcok类。
互斥锁（mutex）
为了方式上面情况的发生，就出现了互斥锁(Lock)
线程锁
由于线程之间是进行随机调度，并且每个线程可能只执行n条执行之后，当多个线程同时修改同一条数据时可能会出现脏 数据，所以，出现了线程锁，即同一时刻允许一个线程执行操作。线程锁用于锁定资源，你可以定义多个锁, 像下面的 代码, 当你需要独占某一资源时，任何一个锁都可以锁这个资源，就好比你用不同的锁都可以把相同的一个门锁住是一 个道理。 由于线程之间是进行随机调度，如果有多个线程同时操作一个对象，如果没有很好地保护该对象，会造成程序结果的不 可预期，我们
方法 start() setName() getName() setDaemon(True) join() 注释 线程准备就绪，等待CPU调度 为线程设置名称 获取线程名称 设置为守护线程 逐个执行每个线程，执行完毕后继续往 下执行
run()
线程被cpu调度后自动执行线程对象的 run方法，如果想自定义线程类，直接 重写run方法就行了
多进程和多线程及区别
进程与线程区别
1.同一个进程中的线程共享同一内存空间，但是进程之间是独立的。 2.同一个进程中的所有线程的数据是共享的（进程通讯），进程之间的数据是 独立的。 3.对主线程的修改可能会影响其他线程的行为，但是父进程的修改（除了删除
以外）不会影响其他子进程。 4.线程是一个上下文的执行指令，而进程则是与运算相关的一簇资源。 5.同一个进程的线程之间可以直接通信，但是进程之间的交流需要借助中间代 理来实现。 6.创建新的线程很容易，但是创建新的进程需要对父进程做一次复制。 7.一个线程可以操作同一进程的其他线程，但是进程只能操作其子进程。 8.线程启动速度快，进程启动速度慢（但是两者运行速度没有可比性）。
多进程
多进程不受GIL的限制，所以可以充分利用多处理器，
提高并发。 优点：并行执行多个任务，提高效率。创建方便。运 行独立，不受其他进程影响。数据安全 缺点：在进程的创建和删除过程中消耗计算机资源较 多
在linux中，每个进程都是由父进程提供的。每启动一个子进程就从父进 程克隆一份数据，但是进程之间的数据本身是不能共享的。
线程
线程是操作系统能够进行运算调度的最小单位。它被
包含在进程之中，是进程中的实际运作单位。一条线 程指的是进程中一个单一顺序的控制流，一个进程中 可以并发多个线程，每条线程并行执行不同的任务。 一个线程是一个execution context（执行上下文）， 即一个cpu执行时所需要的一串指令。
进程锁（进程同步）
数据输出的时候保证不同进程的输出内容在同一块屏幕正常显示，防止数据乱序的情况。 Without using the lock output from the different processes is liable to get all mixed up.
进程池
由于进程启动的开销比较大，使用多进程的时候会导致大量内存空间被 消耗。为了防止这种情况发生可以使用进程池，（由于启动线程的开销 比较小，所以不需要线程池这种概念，多线程只会频繁得切换cpu导致系 统变慢，并不会占用过多的内存空间） 进程池中常用方法： apply() 同步执行（串行） apply_async() 异步执行（并行） terminate() 立刻关闭进程池 join() 主进程等待所有子进程执行完毕。必须在close或terminate()之 后。 close() 等待所有进程结束后，才关闭进程池。