正文

当面临这些问题的时候,有两个关键词无法绕开,那就是并行和并发。

首先,要先了解几个概念:
  1.进程是程序的一次执行。
  2.进程是资源分配的基本单位(调度单位)。
  3.一个进程可以包括多个线程。
  4.在单CPU计算机中,有一个资源是无法被多个程序并行使用的:CPU。
  5.操作系统调度器:拆分CPU为一段段时间的运行片,轮流分配给不同的程序。
  6.操作系统内存管理模块:管理物理内存、虚拟内存相关的事务。

  由于CPU同时刻只能执行一个进程,如果我们不加以控制的话,一个进程可能使用CPU直到运行结束,于是出现了操作系统调度器,而进程也成为了调度单位。

  进程的运行不仅仅需要CPU,还需要很多其他资源,如内存啊,显卡啊,GPS啊,磁盘啊等等,统称为程序的执行环境,也就是程序上下文。

  在这里就出现了并发的概念,调度器切换CPU给不同进程使用的速度非常快,于是在使用者看来程序是在同时运行,这就是并发,而实际上CPU在同一时刻只在运行一个进程。

  CPU进程无法同时刻共享,但是出现一定要共享CPU的需求呢?此时线程的概念就出现了。线程被包含在进程当中,进程的不同线程间共享CPU和程序上下文。(共享进程分配到的资源)

  单CPU进行进程调度的时候,需要读取上下文+执行程序+保存上下文,即进程切换。

  如果这个CPU是单核的话,那么在进程中的不同线程为了使用CPU核心,则会进行线程切换,但是由于共享了程序执行环境,这个线程切换比进程切换开销少了很多。在这里依然是并发,唯一核心同时刻只能执行一个线程。

  如果这个CPU是多核的话,那么进程中的不同线程可以使用不同核心,真正的并行出现了。

  线程是CPU调度和分配的基本单位,一定要和 进程是操作系统进行资源分配(包括cpu、内存、磁盘IO等)的最小单位 区别清楚。有句话说CPU只能看到线程,可以这么理解,假设我是CPU,我闭着眼,操作系统调度器将一个进程分配给我之后,我拿到进程睁开眼,我看到的是什么?我看到的是进程中的很多线程,那么我现在能调度和分配的是什么?进程?不行,因为我看不到其他进程,何来调度分配,只能调度我看到的那些线程,如果我是4核的话,把线程ABCD分配到核心1234,其他的线程依然要等待分配,至于等待多久,如何分配,暂不在本文讨论范围。于是线程是CPU调度和分配的基本单位。

  最后说一下操作系统内存管理模块这里做的事:在这之前,程序员需要为每个程序安排运行的空间,这里的空间指的是内存的物理地址,但是这么的问题就是,每个程序都要协商如何使用同一内存的不同空间,而且程序员还要关心底层内存分配问题。解决办法就是,提出进程的概念,每个进程用一样的虚拟地址空间,CPU上增加了MMU模块负责转换虚拟地址和物理地址,虚拟地址经过操作系统和MMU之后,虚拟地址会映射到不同的物理地址,不同的进程就能获得各自独立的物理内存空间。

  另外在有的操作系统里,进程不是调度单位,线程是最基本的调度单位,调度器只调度线程,不调度进程,如VxWorks。

总结:

  1. 单CPU中进程只能是并发,多CPU计算机中进程可以并行。
  2. 单CPU单核中线程只能并发,单CPU多核中线程可以并行。
  3. 无论是并发还是并行,使用者来看,看到的是多进程,多线程。


拓展 2019.9.23

下面是我自己总结的相关问题,如果你很清楚明白,恭喜你已经入门了。如果还是含糊不清看看下面博客吧~

  1. python不同进程之间如何通信?
  2. 就python而言,为什么多线程适合处理IO密集型却不适合CPU密集型?
  3. 有了GIL,为什么在编写多线程是依旧要使用锁(如互斥锁)来保证线程安全?
  4. 在python编程中,用多进程代替多线程提高程序执行效率的原理?
  5. 多进程数量与cpu核数比例?原理?

拓展 2019.10.8

协程是一种用户态的轻量级线程,协程的调度完全由用户控制。协程拥有自己的寄存器上下文和栈。协程调度切换时,将寄存器上下文和栈保存到其他地方,在切回来的时候,恢复先前保存的寄存器上下文和栈,直接操作栈则基本没有内核切换的开销,可以不加锁的访问全局变量,所以上下文的切换非常快。

通俗的理解:在⼀个线程中的某个函数,可以在任何地⽅保存当前函数的⼀
些临时变量等信息,然后切换到另外⼀个函数中执⾏,注意不是通过调⽤函
数的⽅式做到的,并且切换的次数以及什么时候再切换到原来的函数都由开
发者⾃⼰确定

协程多与线程进行比较

  1. 一个线程可以多个协程,一个进程也可以单独拥有多个协程,这样python中则能使用多核CPU。
  2. 线程进程都是同步机制,而协程则是异步
  3. 协程能保留上一次调用时的状态,每次过程重入时,就相当于进入上一次调用的状态
  4. 不需要锁,并发性高,如果单线程内切换函数,性能远高于线程切换,并发性更高。

阻塞与非阻塞指的是程序的两种运行状态:

  • 阻塞:阻塞的概念往往伴随着线程。是指在调用结果返回之前,当前线程会被挂起(释放cpu等资源)。调用线程只有在得到结果之后才会被唤醒执行后续的操作。
  • 非阻塞:在结果没有返回之前,该调用不会阻塞住当前线程,力求尽可能多的占有CPU

同步与异步指的是提交任务的两种方式(请求发出后,是否需要等待请求结果,才能继续执行其他操作。):

  • 同步调用:提交完任务后,就在原地等待,直到任务运行完毕后,拿到任务的返回值,才继续执行下一行代码
  • 异步调用:提交完任务后,不在原地等待(不需要依赖返回结果),直接执行下一行代码

其实,这两者存在本质的区别,面向的对象是不同的。

  • 阻塞/非阻塞:进程/线程需要操作的数据如果尚未就绪,是否妨碍了当前进程/线程的后续操作。
  • 同步/异步:数据如果尚未就绪,是否需要等待数据结果。

一个小故事

故事:小A烧开水。

出场人物:小A出场道具:普通水壶(放在煤气灶上的那种,为了方便简称:水壶);会响的水壶(水烧开了会响的那种,简称:响壶)。故事目的:小A要拿开水泡咖啡

  • 小A为了实现目的,指定了4个计划:

1- 用水壶烧水,并且站在煤气灶旁边,啥事不干,两眼直勾勾的盯着水壶,等水烧开。烧开后就去泡咖啡。同步阻塞

  • 假设烧水和泡咖啡是在同一个线程中执行。

2- 仍然用水壶煮水,不过此时不再傻傻得站在那里看水开没开,而是去玩局LOL,每当自己死了,就过来看看水开了没有。如果水开了就去泡咖啡。同步非阻塞

  • 假设这里玩LOL,是另一个线程运行的。

3- 动用响壶烧水,仍然站在煤气灶旁边,不过此时不两眼直勾勾的盯着壶了,而是听响,因为响壶水开时会用响声通知小A。异步阻塞
4- 在计划3的基础上,小A不站在煤气灶旁边了,而是去玩局LOL,等听到响壶的声音提醒后,再去跑咖啡。异步非阻塞

所以协程属于异步非阻塞

线程阻塞示例

# encoding: UTF-8
import threading
import time

class MyThread(threading.Thread):
    def run(self):
        for i in range(3):
            time.sleep(1)
            msg = "I'm "+self.name+' @ '+str(i)
            print msg
def test():
    for i in range(5):
        t = MyThread()
        t.start()
if __name__ == '__main__':
    test()

执行结果:
I'm Thread-1 @ 0
I'm Thread-2 @ 0
I'm Thread-5 @ 0
I'm Thread-3 @ 0
I'm Thread-4 @ 0
I'm Thread-3 @ 1
I'm Thread-4 @ 1
I'm Thread-5 @ 1
I'm Thread-1 @ 1
I'm Thread-2 @ 1
I'm Thread-4 @ 2
I'm Thread-5 @ 2
I'm Thread-2 @ 2
I'm Thread-1 @ 2
I'm Thread-3 @ 2

从代码和执行结果我们可以看出,多线程程序的执行顺序是不确定的。当执行到sleep语句时,线程将被阻塞(Blocked)(sleep未完成妨碍后续操作),到sleep结束后,线程进入就绪(Runnable)状态,等待调度。而线程调度将自行选择一个线程执行。上面的代码中只能保证每个线程都运行完整个run函数,但是线程的启动顺序、run函数中每次循环的执行顺序都不能确定。

此外需要注意的是:

  1. 每个线程一定会有一个名字,尽管上面的例子中没有指定线程对象的name,但是python会自动为线程指定一个名字。
  2. 当线程的run()方法结束时该线程完成。
  3. 无法控制线程调度程序,但可以通过别的方式来影响线程调度的方式。

参考

仅有一条评论

  1. 夜华:

    厉害

    2019-08-22 22:09 回复

preView