浅谈多进程多线程和超线程共23页
编程思想之多线程与多进程(2)——线程优先级与线程安全
编程思想之多线程与多进程(2)——线程优先级与线程安全线程优先级现在主流操作系统(如Windows、Linux、Mac OS X)的任务调度除了具有前面提到的时间片轮转的特点外，还有优先级调度(Priority Schedule)的特点。
优先级调度决定了线程按照什么顺序轮流执行，在具有优先级调度的系统中，线程拥有各自的线程优先级(Thread Priority)。
具有高优先级的线程会更早地执行，而低优先级的线程通常要等没有更高优先级的可执行线程时才会被执行。
线程的优先级可以由用户手动设置，此外系统也会根据不同情形调整优先级。
通常情况下，频繁地进入等待状态(进入等待状态会放弃之前仍可占用的时间份额)的线程(如IO线程)，比频繁进行大量计算以至于每次都把所有时间片全部用尽的线程更受操作系统的欢迎。
因为频繁进入等待的线程只会占用很少的时间，这样操作系统可以处理更多的任务。
我们把频繁等待的线程称之为IO密集型线程(IO Bound Thread)，而把很少等待的线程称之为CPU密集型线程(CPU Bound Thread)。
IO密集型线程总是比CPU密集型线程更容易得到优先级的提升。
线程饿死:在优先级调度下，容易出现一种线程饿死的现象。
一个线程饿死是说它的优先级较低，在它执行之前总是有比它优先级更高的线程等待执行，因此这个低优先级的线程始终得不到执行。
当CPU密集型的线程优先级较高时，其它低优先级的线程就很可能出现饿死的情况；当IO密集型线程优先级较高时，其它线程相对不容易造成饿死的善，因为IO线程有大量的等待时间。
为了避免线程饿死，调度系统通常会逐步提升那些等待了很久而得不到执行的线程的优先级。
这样，一个线程只要它等待了足够长的时间，其优先级总会被提升到可以让它执行的程度，也就是说这种情况下线程始终会得到执行，只是时间的问题。
在优先级调度环境下，线程优先级的改变有三种方式：1. 用户指定优先级；2. 根据进入等待状态的频繁程度提升或降低优先级(由操作系统完成)；3. 长时间得不到执行而被提升优先级。
多线程和多进程的区别（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测试下的运⾏结果。
C语言中的多线程与进程并发编程实践
C语言中的多线程与进程并发编程实践在C语言中，多线程与进程并发编程是非常重要的主题，它们可以帮助我们实现更高效的程序。
本文将介绍多线程和进程的概念，以及它们在C语言中的实践应用。
一、概念介绍多线程是指在一个程序中同时执行多个线程，每个线程有自己的代码和执行流程。
它们共享程序的内存和资源，但每个线程有自己的栈空间。
多线程可以提高程序的并发性和响应性，特别适合处理多任务和多用户的情况。
进程是指在操作系统中运行的程序实例，它有自己的地址空间、文件描述符、堆栈等资源。
每个进程都是独立运行的，它们之间不共享内存。
进程之间通过进程间通信（IPC）机制来进行数据共享和通信。
二、多线程编程实践在C语言中，我们使用pthread库来进行多线程编程。
以下是一个示例代码，演示了如何创建和管理多个线程：```c#include <stdio.h>#include <pthread.h>#define NUM_THREADS 5void* thread_func(void* arg) {int tid = *((int*)arg);printf("Hello from thread %d\n", tid);pthread_exit(NULL);}int main() {pthread_t threads[NUM_THREADS];int thread_args[NUM_THREADS];int i;for (i = 0; i < NUM_THREADS; i++) {printf("Creating thread %d\n", i);thread_args[i] = i;pthread_create(&threads[i], NULL, thread_func, &thread_args[i]); }for (i = 0; i < NUM_THREADS; i++) {pthread_join(threads[i], NULL);}pthread_exit(NULL);}```在这个例子中，我们首先定义了一个线程函数 `thread_func`，它会打印出自己的线程id。
多线程概述
多线程概述进程和线程都是操作系统的概念。
进程是应用程序的执行实例，每个进程是由私有的虚拟地址空间、代码、数据和其它各种系统资源组成，进程在运行过程中创建的资源随着进程的终止而被销毁，所使用的系统资源在进程终止时被释放或关闭。
线程是进程内部的一个执行单元。
系统创建好进程后，实际上就启动执行了该进程的主执行线程，主执行线程以函数地址形式，比如说main或WinMain函数，将程序的启动点提供给Windows系统。
主执行线程终止了，进程也就随之终止。
每一个进程至少有一个主执行线程，它无需由用户去主动创建，是由系统自动创建的。
用户根据需要在应用程序中创建其它线程，多个线程并发地运行于同一个进程中。
一个进程中的所有线程都在该进程的虚拟地址空间中，共同使用这些虚拟地址空间、全局变量和系统资源，所以线程间的通讯非常方便，多线程技术的应用也较为广泛。
多线程可以实现并行处理，避免了某项任务长时间占用CPU时间。
要说明的一点是，目前大多数的计算机都是单处理器（CPU）的，为了运行所有这些线程，操作系统为每个独立线程安排一些CPU时间，操作系统以轮换方式向线程提供时间片，这就给人一种假象，好象这些线程都在同时运行。
由此可见，如果两个非常活跃的线程为了抢夺对CPU的控制权，在线程切换时会消耗很多的CPU资源，反而会降低系统的性能。
这一点在多线程编程时应该注意。
Win32 SDK函数支持进行多线程的程序设计，并提供了操作系统原理中的各种同步、互斥和临界区等操作。
Visual C++ 6.0中，使用MFC类库也实现了多线程的程序设计，使得多线程编程更加方便。
Win32 API对多线程编程的支持Win32 提供了一系列的API函数来完成线程的创建、挂起、恢复、终结以及通信等工作。
下面将选取其中的一些重要函数进行说明。
1、HANDLE CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes,DWORD dwStackSize,LPTHREAD_START_ROUTINE lpStartAddress,LPVOID lpParameter,DWORD dwCreationFlags,LPDWORD lpThreadId);该函数在其调用进程的进程空间里创建一个新的线程，并返回已建线程的句柄，其中各参数说明如下：lpThreadAttributes：指向一个SECURITY_ATTRIBUTES 结构的指针，该结构决定了线程的安全属性，一般置为NULL；dwStackSize：指定了线程的堆栈深度，一般都设置为0；lpStartAddress：表示新线程开始执行时代码所在函数的地址，即线程的起始地址。
多进程和多线程的优缺点
多进程和多线程的优缺点Linux内核对多进程和多线程的⽀持⽅式：线程机制⽀持并发程序设计技术，在多处理器上能真正保证并⾏处理。
⽽在linux实现线程很特别，linux把所有的线程都当作进程实现。
linux下线程看起来就像普通进程(只是该进程和其他进程共享资源，如地址空间)。
上述机制与Microsoft windows或是Sun Solaris实现差异很⼤。
Linux的线程实现是在核外进⾏的，核内提供的是创建进程的接⼝do_fork()。
内核提供了两个系统调⽤__clone()和fork()，最终都⽤不同的参数调⽤do_fork()核内API。
do_fork() 提供了很多参数，包括CLONE_VM（共享内存空间）、CLONE_FS（共享⽂件系统信息）、CLONE_FILES（共享⽂件描述符表）、CLONE_SIGHAND（共享信号句柄表）和CLONE_PID（共享进程ID，仅对核内进程，即0号进程有效）。
当使⽤fork系统调⽤产⽣多进程时，内核调⽤do_fork()不使⽤任何共享属性，进程拥有独⽴的运⾏环境。
当使⽤pthread_create()来创建线程时，则最终设置了所有这些属性来调⽤__clone()，⽽这些参数⼜全部传给核内的do_fork()，从⽽创建的”进程”拥有共享的运⾏环境，只有栈是独⽴的，由 __clone()传⼊。
即：Linux下不管是多线程编程还是多进程编程，最终都是⽤do_fork实现的多进程编程，只是进程创建时的参数不同，从⽽导致有不同的共享环境。
Linux线程在核内是以轻量级进程的形式存在的，拥有独⽴的进程表项，⽽所有的创建、同步、删除等操作都在核外pthread库中进⾏。
pthread 库使⽤⼀个管理线程（__pthread_manager() ，每个进程独⽴且唯⼀）来管理线程的创建和终⽌，为线程分配线程ID，发送线程相关的信号，⽽主线程pthread_create()）的调⽤者则通过管道将请求信息传给管理线程。
谈谈你对Java多线程的理解以及多线程的实现方式
谈谈你对Java多线程的理解以及多线程的实现⽅式说线程之前先说进程，何为进程？进程就是正在进⾏中的程序.⽐如电脑同时在运⾏QQ进程、cmd进程、wps进程、飞秋进程等。
在某⼀时刻，CPU只能执⾏⼀个程序，只是在做快速切换，我们⾁眼看不出来。
⽐如：我有⼀些箱⼦，我⼀个⼈去搬，搬了⼀个⼜⼀个，很累，如果有5个⼈⼀起搬，就更快了5个⼈同时去搬都在⼀个进程中完成，这5个⼈叫线程，线程是进程中的内容。
进程：是⼀个正在执⾏中的程序每⼀个进程执⾏都有⼀个执⾏顺序，该顺序是⼀个执⾏路径，或者叫⼀个控制单元。
线程：就是进程中的⼀个独⽴的控制单元。
线程在控制着进程的执⾏。
⼀个进程中⾄少有⼀个线程，⾄少有⼀个控制单元。
java VM 启动的时候会有⼀个进程java.exe，该进程中⾄少有⼀个线程负责Java程序的执⾏⽽且这个线程运⾏的代码存在于main⽅法中，该线程称之为主线程。
JVM启动不⽌⼀个线程，还有负责垃圾回收机制的线程。
任何⼀个代码执⾏的时候都会进内存，线程的控制单元依次往下执⾏，⽽负责执⾏的代码都在线程。
线程的出现让我们的程序有同时出现的效果，多线程能帮我们提⾼效率，⽬的在于能使多个代码同时运⾏。
线程是程序中的执⾏线程，Java虚拟机允许应⽤程序并发的运⾏多个线程每个线程都有⼀个优先级，⾼优先级线程的执⾏优于低优先级的线程。
当某个线程中运⾏的代码创建⼀个新Thread对象时，该线程的初始优先级被设定为创建线程的优先级。
从语义上去理解，想成为异常就继承exception，想成为线程就继承Thread，成为我的⼩弟你就是我的了，你就拥有了我所有⽤的属性及⽅法了。
那么如何在代码中⾃定义⼀个线程？通过对api的查找，Java已经提供了对线程这类事务的描述，就是Thread类创建线程的第⼀种⽅式：继承Thread类步骤：1、定义类继承Thread2、覆写Thread类中的run⽅法3、调⽤该⽅法：调⽤线程的start⽅法该⽅法有两个作⽤：启动线程，调⽤run⽅法new⼀个对象就是在创建线程，创建了之后并没有执⾏，所以要调⽤start⽅法才能被执⾏那怎么执⾏呢？调⽤run⽅法⽽：可以看到，执⾏顺序会乱，⽽且每次运⾏的结果都不同。
进程、线程、多线程相关总结
一、说说概念1、进程（process）狭义定义：进程就是一段程序的执行过程。
广义定义：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。
它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。
简单的来讲进程的概念主要有两点：第一，进程是一个实体。
每一个进程都有它自己的地址空间，一般情况下，包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。
文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。
第二，进程是一个“执行中的程序”。
程序是一个没有生命的实体，只有处理器赋予程序生命时，它才能成为一个活动的实体，我们称其为进程。
进程状态：进程有三个状态，就绪、运行和阻塞。
就绪状态其实就是获取了出cpu 外的所有资源，只要处理器分配资源就可以马上执行。
就绪状态有排队序列什么的，排队原则不再赘述。
运行态就是获得了处理器分配的资源，程序开始执行。
阻塞态，当程序条件不够时候，需要等待条件满足时候才能执行，如等待i/o操作时候，此刻的状态就叫阻塞态。
2、程序说起进程，就不得不说下程序。
先看定义：程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
而进程则是在处理机上的一次执行过程，它是一个动态的概念。
这个不难理解，其实进程是包含程序的，进程的执行离不开程序，进程中的文本区域就是代码区，也就是程序。
3、线程通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。
线程可以利用进程所拥有的资源，在引入线程的操作系统中，通常都是把进程作为分配资源的基本单位，而把线程作为独立运行和独立调度的基本单位，由于线程比进程更小，基本上不拥有系统资源，故对它的调度所付出的开销就会小得多，能更高效的提高系统多个程序间并发执行的程度。
2021年设计并发服务器使用多进程与多线程有什么区别
设计并发服务器使用多进程与多线程有什么区别
设计并发服务器，使用多进程与多线程有什么区别？
根本区别就一点：用多进程每个进程有自己的地址空间(address space)，线程则共享地址空间。
所有其它区别都是由此而来的：
1。
速度：线程产生的速度快，线程间的通讯快、切换快等，因为他们在同一个地址空间内。
2。
资源利用率：线程的资源利用率比较好也是因为他们在同一个地址空间内。
3。
同步问题：线程使用公共变量/内存时需要使用同步机制还是因为他们在同一个地址空间内。
1，进程：子进程是父进程的复制品。
子进程获得父进程数据空间、堆和栈的复制品。
2，线程：相对与进程而言，线程是一个更加接近与执行体的'概念，它可以与同进程的其他线程共享数据，但拥有自己的栈空间，拥有独立的执行序列。
两者都可以提高程序的并发度，提高程序运行效率和响应时间。
线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源管理和保护;而进程正相反。
同时，线程适合于在SMP机器上运行，而进程则可以跨机器迁移。
模板,内容仅供参考。
什么是多进程和多线程及区别
进程池内部维护一个进程序列，当使用时，去进程池中获取一个进程，如果进程池 序列中没有可供使用的进程，那么程序就会等待，直到进程池中有可用进程为止。 在上面的程序中产生了10个进程，但是只能有5同时被放入进程池，剩下的都被暂 时挂起，并不占用内存空间，等前面的五个进程执行完后，再执行剩下5个进程。
谢谢观看
递归锁
RLcok类的用法和Lock类一模一样，但它支持嵌套，，在多个锁没有释放的时候一般会使用使用RLcok类。
互斥锁（mutex）
为了方式上面情况的发生，就出现了互斥锁(Lock)
线程锁
由于线程之间是进行随机调度，并且每个线程可能只执行n条执行之后，当多个线程同时修改同一条数据时可能会出现脏 数据，所以，出现了线程锁，即同一时刻允许一个线程执行操作。线程锁用于锁定资源，你可以定义多个锁, 像下面的 代码, 当你需要独占某一资源时，任何一个锁都可以锁这个资源，就好比你用不同的锁都可以把相同的一个门锁住是一 个道理。 由于线程之间是进行随机调度，如果有多个线程同时操作一个对象，如果没有很好地保护该对象，会造成程序结果的不 可预期，我们
方法 start() setName() getName() setDaemon(True) join() 注释 线程准备就绪，等待CPU调度 为线程设置名称 获取线程名称 设置为守护线程 逐个执行每个线程，执行完毕后继续往 下执行
run()
线程被cpu调度后自动执行线程对象的 run方法，如果想自定义线程类，直接 重写run方法就行了
多进程和多线程及区别
进程与线程区别
1.同一个进程中的线程共享同一内存空间，但是进程之间是独立的。 2.同一个进程中的所有线程的数据是共享的（进程通讯），进程之间的数据是 独立的。 3.对主线程的修改可能会影响其他线程的行为，但是父进程的修改（除了删除
进程、线程、协程之概念理解+线程和进程各自有什么区别和优劣
进程、线程、协程之概念理解+线程和进程各⾃有什么区别和优劣⼀、概念⾸先，根据图了解⼀下串⾏，并⾏和并发的基本概念： 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调度和分配的基本单位，程序执⾏的最⼩单位。
浅谈多进程、多线程与超线程
所以好姑娘一般都喜欢同步的男生，异步也就意味着异心，很显然，同步 存在等待时间，所以追到好姑娘需要耐心。
多线程
服务举例
此Server的功能为：接收上游批量 发过来的广告信息，通过一定算法 逻辑给这条广告评分，然后将广告 信息以及评分结果写入本地文件。
多线程
单线程服务抽象
假设只有一个CPU，单线程处理，Server的工作方式如下
超线程
超线程
1. 我们回顾一下多线程概念，电脑在执行命令的时候会锁定了下个将被执行的 指令的内存储存位置，使CPU精确地知道从哪儿得到这些指令。 2. 当一个线程发送到CPU，这线程的内存地址就被锁定，所以CPU明白从哪里 开始执行线程。电脑能够递增处理每个指令，一直到处理完一个线程为止。 在此线程执行以后，电脑就会重新读入下个要执行的指令位置。
3. worker.c是支持混合的多线程与多进程的多路处理模块。Apache创建 多个子进程，每个子进程有多个线程。每个线程在某个确定的时间只 能维持一个连接。
鱼还是熊掌
Apache的两种工作模式
1. 在大多数平台上，Prefork MPM在效率上要比Worker MPM要高，但 是内存使用大得多。prefork的无线程设计在某些情况下将比worker更 有优势：他能够使用那些没有处理好线程安全的第三方模块，并 且 对于那些线程调试困难的平台而言，他也更容易调试一些。 2. 通常来说，在一个高流量的HTTP服务器上，Worker MPM是个比较 好的选择，因为Worker MPM的内存使用比Prefork MPM要低得多。 但worker MPM也由不完善的地方，假如一个线程崩溃，整个进程就 会连同其任何线程一起“死掉”。由于线程共享内存空间，所以一个程 式在运行时必须被系统识别为“每个线程都是安全的”。
线程、进程、多线程、多进程和多任务之间的区别与联系
线程、进程、多线程、多进程和多任务之间的区别与联系可能学习操作系统开发的读者都听说过这些专业名词，但又多少人理解了？首先，从定义开始，先看一下教科书上进程和线程定义：进程：资源分配的最小单位。
线程：程序执行的最小单位。
1进程进程是程序执行时的一个实例，即它是程序已经执行到课中程度的数据结构的汇集。
从内核的观点看，进程的目的就是担当分配系统资源（CPU时间、内存等）的基本单位。
举例说明进程：想象一位有一手好厨艺的计算机科学家正在为他的女儿烘制生日蛋糕，他有做生日蛋糕的食谱，厨房里有所需的原料:面粉、鸡蛋、糖、香草汁等。
在这个比喻中，做蛋糕的食谱就是程序(即用适当形式描述的算法)计算机科学家就是处理器(CPU)，而做蛋糕的各种原料就是输入数据。
进程就是厨师阅读食谱、取来各种原料以及烘制蛋糕等一系列动作的总和。
现在假设计算机科学家的儿子哭着跑了进来，说他的头被一只蜜蜂蛰了。
计算机科学家就记录下他照着食谱做到哪儿了(保存进程的当前状态)，然后拿出一本急救手册，按照其中的指示处理蛰伤。
这里，我们看到处理机制是从一个进程(做蛋糕)切换到另一个高优先级的进程(实施医疗救治)，每个进程拥有各自的程序(食谱和急救手册)。
当蜜蜂蛰伤处理完之后，这位计算机科学家又回来做蛋糕，从他离开时的那一步继续做下去。
2线程线程是CPU调度的最小单位(程序执行流的最小单元)，它被包含在进程之中，是进程中的实际运作单元。
一条线程是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。
一个标准的线程有线程ID、当前指令指针(PC),寄存器集合和堆栈组成。
另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单元，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其他线程共享进程所拥有的全部资源。
一个线程可以创建和撤销另一个线程，同一进程中的多个线程之间可以并发执行。
由于线程之间的相互制约，致使线程在运行中呈现处间断性。
浅谈多核CPU、多线程、多进程
浅谈多核CPU、多线程、多进程1.CPU发展趋势核⼼数⽬依旧会越来越多，依据摩尔定律，由于单个核⼼性能提升有着严重的瓶颈问题，普通的桌⾯PC有望在2017年末2018年初达到24核⼼（或者16核32线程），我们如何来⾯对这突如其来的核⼼数⽬的增加？编程也要与时俱进。
笔者⽃胆预测，CPU各个核⼼之间的⽚内总线将会采⽤4路组相连：），因为全相连太过复杂，单总线⼜不够给⼒。
⽽且应该是⾮对称多核处理器，可能其中会混杂⼏个DSP处理器或流处理器。
2.多线程与并⾏计算的区别(1)多线程的作⽤不只是⽤作并⾏计算，他还有很多很有益的作⽤。
还在单核时代，多线程就有很⼴泛的应⽤，这时候多线程⼤多⽤于降低阻塞（意思是类似于while(1){if(flag==1)break;sleep(1);}这样的代码）带来的CPU资源闲置,注意这⾥没有浪费CPU资源，去掉sleep(1)就是纯浪费了。
阻塞在什么时候发⽣呢？⼀般是等待IO操作（磁盘，数据库，⽹络等等）。
此时如果单线程，CPU会⼲转不⼲实事（与本程序⽆关的事情都算不⼲实事，因为执⾏其他程序对我来说没意义），效率低下（针对这个程序⽽⾔），例如⼀个IO操作要耗时10毫秒，CPU就会被阻塞接近10毫秒，这是何等的浪费啊！要知道CPU是数着纳秒过⽇⼦的。
所以这种耗时的IO操作就⽤⼀个线程Thread去代为执⾏，创建这个线程的函数（代码）部分不会被IO操作阻塞，继续⼲这个程序中其他的事情，⽽不是⼲等待（或者去执⾏其他程序）。
同样在这个单核时代，多线程的这个消除阻塞的作⽤还可以叫做“并发”，这和并⾏是有着本质的不同的。
并发是“伪并⾏”，看似并⾏，⽽实际上还是⼀个CPU在执⾏⼀切事物，只是切换的太快，我们没法察觉罢了。
例如基于UI的程序（俗话说就是图形界⾯），如果你点⼀个按钮触发的事件需要执⾏10秒钟，那么这个程序就会假死，因为程序在忙着执⾏，没空搭理⽤户的其他操作；⽽如果你把这个按钮触发的函数赋给⼀个线程，然后启动线程去执⾏，那么程序就不会假死，继续相应⽤户的其他操作。
【转】聊聊Python中的多进程和多线程
【转】聊聊Python中的多进程和多线程今天，想谈⼀下Python中的进程和线程。
最近在学习Django的时候，涉及到了多进程和多线程的知识点，所以想着⼀下把Python中的这块知识进⾏总结，所以系统地学习了⼀遍，将知识梳理如下。
1. 进程和线程的关系既然谈论到进程和线程，当然要⽼⽣常谈⼀个问题，那就是什么是进程，什么⼜是线程呢？⽤最简单的话解释就是⼀台电脑能同时运⾏多个QQ就是进程，每个QQ你打开不同窗⼝聊天，发图⽚，发视频就是线程。
再⽐如Linux系统中我们通过ps -ef查看所有进程，每个进程都有⼀个pid，且唯⼀，其中pid=1的进程是⽤来回收所有孤⼉进程的，⼀旦kill掉，系统就关闭了。
我们看⼀下定义：进程是系统进⾏资源分配和调度的⼀个独⽴单位。
线程是进程的⼀个实体，是CPU调度和分派的基本单位，它是⽐进程更⼩的能独⽴运⾏的基本单位。
线程⾃⼰基本上不拥有系统资源，只拥有⼀点在运⾏中必不可少的资源（如程序计数器，⼀组寄存器和栈），但是它可与同属⼀个进程的其他的线程共享进程所拥有的全部资源。
⽽它们有以下4点主要区别：⼀个程序⾄少有⼀个进程，⼀个进程⾄少有⼀个线程。
线程的划分尺度⼩于进程（资源⽐进程少），使得多线程程序的并发性⾼。
进程在执⾏过程中拥有独⽴的内存单元，⽽多个线程共享内存，从⽽极⼤地提⾼了程序的运⾏效率。
线线程不能够独⽴执⾏，必须依存在进程中。
线程执⾏开销⼩，但不利于资源的管理和保护，⽽进程正相反。
⽽且同⼀进程多个线程之间是数据共享的，多个进程之间数据相互独⽴，但是可以采取⼀些⽅式进⾏信息交互（⽐如队列）。
2. Python中的进程说的远了，我们这⾥谈的Python中的多进程和多线程，⾸先我们说⼀下多进程。
2.1 多进程创建⽅式可以归纳为三种：fork，multiprocessing以及进程池Pool。
（1） fork⽅式Python的os模块封装了常见的系统调⽤，其中就包括fork，可以在Python程序中轻松创建⼦进程：import os# 注意，fork函数，只在Unix/Linux/Mac上运⾏，windows不可以pid = os.fork()if pid == 0:print('哈哈1')else:print('哈哈2')注意：fork()函数只能在Unix/Linux/Mac上⾯运⾏，不可以在Windows上⾯运⾏。
线程，进程，多进程，多线程。并发，并行的区别与关系
线程，进程，多进程，多线程。
并发，并⾏的区别与关系⼀：线程与进程1.概念线程：是程序执⾏流的最⼩单元，是系统独⽴调度和分配CPU（独⽴运⾏）的基本单位。
进程：是资源分配的基本单位。
⼀个进程包括多个线程。
进程 ≥ 线程2.区别：1.线程与资源分配⽆关，它属于某⼀个进程，并与进程内的其他线程⼀起共享进程的资源。
2.每个进程都有⾃⼰⼀套独⽴的资源（数据），供其内的所有线程共享。
3.不论是⼤⼩，开销线程要更“轻量级”4.⼀个进程内的线程通信⽐进程之间的通信更快速，有效。
（因为共享变量）⼆.多线程与多进程多线程：同⼀时刻执⾏多个线程。
⽤浏览器⼀边下载，⼀边听歌，⼀边看视频，⼀边看⽹页。
多进程：同时执⾏多个程序。
如，同事运⾏YY，QQ，以及各种浏览器。
三.并发与并⾏并发当有多个线程在操作时,如果系统只有⼀个CPU,则它根本不可能真正同时进⾏⼀个以上的线程，它只能把CPU运⾏时间划分成若⼲个时间段,再将时间段分配给各个线程执⾏，在⼀个时间段的线程代码运⾏时，其它线程处于挂起状。
.这种⽅式我们称之为并发(Concurrent)。
并⾏：当系统有⼀个以上CPU时,则线程的操作有可能⾮并发。
当⼀个CPU执⾏⼀个线程时，另⼀个CPU可以执⾏另⼀个线程，两个线程互不抢占CPU资源，可以同时进⾏，这种⽅式我们称之为并⾏(Parallel)。
以下为详细的概念的讲解并发：并发，在中，是指⼀个时间段中有⼏个程序都处于已启动运⾏到运⾏完毕之间，且这⼏个程序都是在同⼀个上运⾏，但任⼀个时刻点上只有⼀个程序在处理机上运⾏。
并发当有多个线程在操作时,如果系统只有⼀个CPU,则它根本不可能真正同时进⾏⼀个以上的线程，它只能把CPU运⾏时间划分成若⼲个时间段,再将时间段分配给各个线程执⾏，在⼀个时间段的线程代码运⾏时，其它线程处于挂起状。
.这种⽅式我们称之为并发(Concurrent)。
并⾏：当系统有⼀个以上CPU时,则线程的操作有可能⾮并发。
Python并发：多线程与多进程的详解
Python并发：多线程与多进程的详解本篇概要1.线程与多线程2.进程与多进程3.多线程并发下载图⽚4.多进程并发提⾼数字运算关于并发在计算机编程领域，并发编程是⼀个很常见的名词和功能了，其实并发这个理念，最初是源于铁路和电报的早期⼯作。
⽐如在同⼀个铁路系统上如何安排多列⽕车，保证每列⽕车的运⾏都不会发⽣冲突。
后来在20世纪60年代，学术界对计算机的并⾏计算开始进⾏研究，再后来，操作系统能够进⾏并发的处理任务，编程语⾔能够为程序实现并发的功能。
线程与多线程什么是线程⼀个线程可以看成是⼀个有序的指令流（完成特定任务的指令），并且可以通过操作系统来调度这些指令流。
线程通常位于进程程⾥⾯，由⼀个程序计数器、⼀个堆栈和⼀组寄存器以及⼀个标识符组成。
这些线程是处理器可以分配时间的最⼩执⾏单元。
线程之间是可以共享内存并且互相通信的。
但是当两个线程之间开始共享内存，就⽆法保证线程执⾏的顺序，这可能导致程序错误，或者产⽣错误的结果。
这个问题我们⽇后会专门提及。
下⾯这个图⽚展⽰了多个线程在多个CPU中的存在⽅式：线程的类型在⼀个典型的操作系统⾥⾯，⼀般会有两种类型的线程：1.⽤户级线程：我们能够创建、运⾏和杀死的线程；2.内核级线程：操作系统运⾏的低级别线程；Python⼯作在⽤户级线程上，我们介绍的内容也主要是在⽤户级的线程上运⾏的。
什么是多线程现在的CPU基本上都是多线程的CPU，⽐如我们随意从京东上找⼀个Inter的酷睿i5处理器，看看它的产品规格：这些CPU能够同时运⾏多个线程来处理任务，其实从本质上来说，这些CPU是利⽤⼀个能够在多个线程之间快速切换的单个内核来完成多线程的运⾏的，切换线程的速度⾜够快，所以我们并不会感觉到。
但实质上，它们并不是同时运⾏的。
为了形象的理解多线程，我们来回忆⼀个场景。
在⼤学时代，期末的时候，有些科⽬的⽼师为了不为难⼤家，把考试设为开卷考试，不知道⼤家⾯对开卷考试的时候，做题的顺序是怎样的？在单线程的⼯作模式下，我们从选择题到填空题到简答题再到分析题，⼀个⼀个按顺序的写。
Python3多进程与多线程区别及使用（1.进程）
Python3多进程与多线程区别及使⽤（1.进程）进程和线程参考：是什么：进程是指在系统中正在运⾏的⼀个应⽤程序；程序⼀旦运⾏就是进程，或者更专业化来说：进程是指程序执⾏时的⼀个实例。
线程是进程的⼀个实体。
进程——资源分配的最⼩单位，线程——程序执⾏的最⼩单位。
线程进程的区别体现在⼏个⽅⾯：第⼀：因为进程拥有独⽴的堆栈空间和数据段，所以每当启动⼀个新的进程必须分配给它独⽴的地址空间，建⽴众多的数据表来维护它的代码段、堆栈段和数据段，这对于多进程来说⼗分“奢侈”，系统开销⽐较⼤，⽽线程不⼀样，线程拥有独⽴的堆栈空间，但是共享数据段，它们彼此之间使⽤相同的地址空间，共享⼤部分数据，⽐进程更节俭，开销⽐较⼩，切换速度也⽐进程快，效率⾼，但是正由于进程之间独⽴的特点，使得进程安全性⽐较⾼，也因为进程有独⽴的地址空间，⼀个进程崩溃后，在保护模式下不会对其它进程产⽣影响，⽽线程只是⼀个进程中的不同执⾏路径。
⼀个线程死掉就等于整个进程死掉。
第⼆：体现在通信机制上⾯，正因为进程之间互不⼲扰，相互独⽴，进程的通信机制相对很复杂，譬如管道，信号，消息队列，共享内存，套接字等通信机制，⽽线程由于共享数据段所以通信机制很⽅便。
3.属于同⼀个进程的所有线程共享该进程的所有资源，包括⽂件描述符。
⽽不同过的进程相互独⽴。
4.线程⼜称为轻量级进程，进程有进程控制块，线程有线程控制块；5.线程必定也只能属于⼀个进程，⽽进程可以拥有多个线程⽽且⾄少拥有⼀个线程；第四：体现在程序结构上，举⼀个简明易懂的列⼦：当我们使⽤进程的时候，我们不⾃主的使⽤if else嵌套来判断pid，使得程序结构繁琐，但是当我们使⽤线程的时候，基本上可以甩掉它，当然程序内部执⾏功能单元需要使⽤的时候还是要使⽤，所以线程对程序结构的改善有很⼤帮助。
进程与线程的选择取决以下⼏点：1、需要频繁创建销毁的优先使⽤线程；因为对进程来说创建和销毁⼀个进程代价是很⼤的。
Python之多进程多线程
Python之多进程多线程⼀、多进程与多线程的概念 1.多进程的概念 进程是程序在计算机上的的⼀次执⾏活动。
当你运⾏⼀个程序，你就启动了⼀个进程。
显然，程序是死的（静态的），进程是活的（动态的）。
进程可以分为系统进程和⽤户进程。
凡是⽤于完成操作系统的各种功能的进程就是系统进程，它们就是处于运⾏状态下的操作系统本⾝；由⽤户本⾝启动的进程都是⽤户进程。
进程是操作系统进⾏资源分配的单位。
在操作系统的管理下，所有正在运⾏的进程轮流使⽤CPU，每个进程运⾏占⽤CPU时间⾮常短，⽤户根本感觉不出来CPU是在轮流为多个进程服务，就好像所有的进程都在不间断地运⾏⼀样。
但实际上在任何⼀个时间内有且仅有⼀个进程占有CPU。
2.多线程的概念 每个正在系统上运⾏的都是⼀个。
每个包含⼀到多个线程。
也可能是整个或者是部分程序的动态执⾏。
线程是⼀组的集合，或者是的特殊段，它可以在程序⾥独⽴执⾏。
也可以把它理解为运⾏的上下⽂。
所以线程基本上是轻量级的，它负责在单个⾥执⾏多。
通常由负责多个线程的调度和执⾏。
线程是中⼀个单⼀的顺序控制流程.在单个程序中同时运⾏多个线程完成不同的⼯作,称为多线程.多线程是为了同步完成多项，不是为了提⾼运⾏效率，⽽是为了提⾼使⽤效率来提⾼系统的效率。
线程是在同⼀时间需要完成多项的时候实现的。
3.多进程与多线程的区别： 多进程使⽤的是CPU的⼀个核，适合IO密集型 多线程使⽤的是CPU的多个核，适合运算密集型⼆、多进程实例 创建⼀个进程(Process)对象: p = multiprocessing.Process(target=worker 1, args=(2,)) target = 函数名字 args = 函数需要的参数，以tuple的形式传⼊ 注意：单个元素的tuple的表现形式 multiprocessing⽤到的两个⽅法： cpu_count() 统计CPU总数 active_children() 获得所有⼦进程 实例⼀：程序代码如下：import multiprocessingimport timedef worker(interval):time.sleep(interval)print ("hello world")if__name__ == "__main__":p = multiprocessing.Process(target=worker, args=(5,))p.start()print (p.is_alive())p.join(timeout = 3) #等待⼦进程执⾏完毕或超时退出print ("end main")print ()print (p.pid) 结果： 实例⼆：程序代码如下：import multiprocessingimport timedef worker(name,interval):print ("{0} start".format(name))time.sleep(interval)print ("{0} end".format(name))if__name__ == "__main__":print ("main start")print ("this computer has {0}".format(multiprocessing.cpu_count()))p1 = multiprocessing.Process(target=worker,args=("worker1",2))p2 = multiprocessing.Process(target=worker,args=("worker2",3))p3 = multiprocessing.Process(target=worker,args=("worker3",4))p1.start()p2.start()p3.start()for p in multiprocessing.active_children():print ("the pid of {0} is {1}".format(,p.pid))print ("main end") 结果：三、多进程锁 Lock组件：当我们⽤多进程来读写⽂件的时候，如果⼀个进程是写⽂件，⼀个进程是读⽂件，如果两个⽂件同时进⾏，肯定是不⾏的，必须是⽂件写结束以后，才可以进⾏读操作。