Python并发编程_程序,进程,算法,软件的区别-CSDN博客

现代的计算机系统主要是由一个或者多个处理器，内存、硬盘、键盘、鼠标、显示器、打印机、网络接口及其他输入输出设备组成的
- 一般而言，现代计算机系统是一个复杂的系统
其一：
- 如果每位应用程序员都必须掌握该系统所有的细节，那就不可能再编写代码了（严重影响了开发效率）
其二：
- 管理这些部件并加以优化使用，是一件极富挑战的工作，于是，计算安装了一层软件（系统软件），称为操作系统
- 它的任务就是为应用程序提供一个更好、更简单、更清晰的计算机模型，并管理刚才提到的所有设备

总结：

程序员无法把所有硬件操作细节都了解，管理这些硬件并且加以优化使用是非常繁琐的工作，这个繁琐的工作就是操作系统来干的，有了它，程序员就从这些繁琐的工作中解脱了出来，只需考虑自己的应用软件的编写就可以了，应用软件直接使用操作系统提供的功能来间接使用硬件

3.什么是操作系统

精简来说，操作系统就是一个协调、管理和控制计算机硬件资源和软件资源的控制程序，操作系统所处的位置如图

操作系统位于计算机硬件与应用软件之间，本质也是一个软件
操作系统由操作系统的内核（运行于内核态，管理硬件资源）以及系统调用（运行于用户态，为应用程序员写的应用程序提供系统调用接口）两部分组成
所以，单纯的说操作系统是运行于内核态的是不准确的

（1）操作系统的功能

隐藏了丑陋的硬件调用接口，为应用程序员提供调用硬件资源的更好，更简单，更清晰的模型（系统调用接口）
应用程序员有了这些接口后，就不用再考虑操作硬件的细节，专心开发自己的应用程序即可
（例如：操作系统提供了文件这个抽象概念，对文件的造作就是对磁盘的操作，有了文件我们就无需考虑关于磁盘的读写控制比如控制磁盘转动，移动磁头读写数据等细节了）、
将应用程序对硬件资源的竟态请求变得有序化
（例如：很多应用软件其实是共享一套计算机硬件，比方说有可能有三个应用程序同时需要申请打印机来输出内容，那么a程序竞争到了打印机资源就打印，然后可能是b竞争到打印机资源，也可能是c，这就导致了无序，打印机可能打印一段a的内容然后又去打印c...,操作系统的一个功能就是将这种无序变得有序。）

（2）操作系统的功能详解

现代计算机或者网络都是多用户的，多个用户不仅共享硬件，而且共享文件，数据库等信息，共享意味着冲突和无序
操作系统主要是用来：
- 记录哪个程序使用了什么资源
- 对资源请求进行分配
- 为不同的程序和用户调解互相冲突的资源请求
我们可以将上述操作系统的功能总结为：处理来自做个程序发起的多个（多个即多路）共享（共享即复用）资源的请求，简称多路复用

（3）多路复用的两种实现方式

时间上的复用
当一个资源在时间上复用时，不同的程序或用户轮流使用它，第一个程序获取该资源使用结束后，在轮到第二个。。。第三个
空间上的复用
每个客户都获取了一个大的资源中的一小部分资源，从而减少了排队等待资源的时间

（4）操作系统与普通软件的区别

主要区别是：
- 你不想用暴风影音了你可以选择用迅雷播放器或者干脆自己写一个
- 但是你无法写一个属于操作系统一部分的程序（时钟中断处理程序）
- 操作系统由硬件保护，不能被用户修改。
操作系统与用户程序的差异并不在于二者所处的地位。
- 特别地，操作系统是一个大型、复杂、长寿的软件，
大型：
- linux或windows的源代码有五百万行数量级。
  - 按照每页50行共1000行的书来算，五百万行要有100卷，要用一整个书架子来摆置，这还仅仅是内核部分。
- 用户程序
  - 如GUI，库以及基本应用软件（如windows Explorer等），很容易就能达到这个数量的10倍或者20倍之多。
长寿：
- 操作系统很难编写，如此大的代码量，一旦完成，操作系统所有者便不会轻易扔掉，再写一个。
- 而是在原有的基础上进行改进。

二.并发编程

1.进程与程序的区别

程序仅仅是一堆代码，没有生命周期
而进程是指程序运行的过程，这个任务做完了进程也就不存在了

就好比厨师做菜，厨师做一道菜、应该有菜谱，安装菜谱的程序一步一步的做，在这个过程中，菜谱就是程序，程序就是路程. 做菜的过程就是进程，厨师就是线程，如果做菜完毕了，进程就不存在了，线程是进程中实际做事儿的.

在一个进程中可以有多个线程，一个进程只有一个线程也是可以的
一个进程至少有一个线程

进程和线程他们都是有操作系统来调度的，程序员级别是无法来调度的，协程就是程序员级别的，协程的调度就是由我们程序员自己来调度的，在操作系统中是没有协程这个概念的，是我们人为抽象出来的

进程 >>>> 线程 >>>> 协程

他们三个消耗资源的对比：进程 >>> 线程 >>> 协程

2.进程调度算法（四种算法）

CPU的工作机制：

遇到I/O的时候，CPU会交出执行权限
当CPU遇到耗时比较长的时候也会自动交出执行权限，切换到其他任务

I/O密集型：
它会被时间所阻塞，不会占用大量的CPU资源，比如sleep（3）
计算密集型：
不占用大量的时候会占用大量的CPU资源，这种情况就是计算密集型，没有时间的大量消耗
for i in range（1000000000）：
i += 1

先来先服务调度算法
短作业优先调度算法
时间片轮转法
多级反馈队列

3.进程并行与并发概念

并行：统一时刻同时运行
- 如果CPU是单核的，同一时刻不能同时执行多个任务
- 如果是多核的，同一时刻就能够做到了
- 2核，同一时刻最多执行两个任务
- 4核，同一时刻最多执行4个任务
并发：一段时间内看起来是同时运行

4.同步异步，阻塞非阻塞

同步：
- 就是在触发一个功能调用时，在没有得到结果之前，该调用就不会返回
- 按照这个定义，其实绝大多数函数都是同步调用
- 但是一般而言，我们在说同步，异步的时候，特指哪些需要其他部件协作或者需要一定时间完成的任务
异步：
- 当一个异步功能调用发出后，调用者不能立刻得到结果
- 当异步功能完成后，通过状态，通知或回调来通知调用者
  - 如果异步功能用状态来通知，那么调用者就需要每隔一定时间检查一次，导致效率低（有些初学多线编程的人，总喜欢用一个循环去检查某个变量的值，这其实是一种很严重的错误）
  - 如果是使用通知的方式，效率则跟高，因为异步功能几乎不需要做额外的操作
阻塞：
- 阻塞调用是指调用结果返回之前，当前线程会被挂起（如遇I/O操作）
  - 函数只有在得到结果之后才会被阻塞的线程激活，有人也许会把阻塞调用和同步调用等同起来，实际上他们是不同的，对于同步调用来说，很多时候当前线程还是激活的，只是从逻辑上当前函数没有返回而已
非阻塞：
- 指不能立刻得到结果之前也会立刻返回，同时该函数不会阻塞当前进程

小结：同步与异步针对的是函数/任务的调用方式：

同步就是当一个进程发起一个函数（任务）调用的时候一直等到函数（任务）完成，而进程继续处于激活状态

而异步情况下是当一个进程发起一个函数（任务）调用的时候，不会等函数返回，而是继续往下执行，当函数返回的时候通过状态、通知、事件等方式通知进程任务完成

阻塞与非阻塞针对的是进程或线程：

阻塞是当前请求不能满足的时候就将进程挂起，而非阻塞则不会阻塞当前进程

5.进程的创建

from multiprocessing import Process


def task():
    with open('a.txt', 'w', encoding='utf-8') as f:
        f.write('helloworld')


"""现在这个写法还没有开启进程"""
"""Windows平台上必须写在这个里面"""
if __name__ == '__main__':
    p = Process(target=task)  # 实例出来一个进程类， 让这个进程执行task任务
    p.start()  # 真正的开启进程

Process类的参数

from multiprocessing import Process


def task(name, age, gender):
    print(name, age, gender)
    with open('a.txt', 'w', encoding='utf-8') as f:
        f.write('helloworld')

"""现在这个写法还没有开启进程"""
"""Windows平台上必须写在这个里面"""
if __name__ == '__main__':
    """
    group=None, target=None, name=None, args=(), kwargs={},
                 *, daemon=None
    """
    p = Process(target=task, name='process-2', args=(), kwargs={'name':'jerry', 'age':20, 'gender':'male'})  # 实例出来一个进程类， 让这个进程执行task任务
    p.start()  # 真正的开启进程
    # 操作系统是负责把这个进程开起来
    # 开启一个进程来执行task任务，真正是谁在执行这个任务，是线程，进程里面至少要有一个线程
    """进程的几个属性：1. 进程名 2. 进程号pid kill """
    # 如何查看进程的名称
    print(p.name) # Process-1
    # 怎么改进程名字
    # p.name = '这是新的进程名'
    # print(p.name)  # 这是新的进程名

Process类的几个方法

from multiprocessing import Process

import time
def task(name, age, gender):
    print(name, age, gender)
    # with open('a.txt', 'w', encoding='utf-8') as f:
    #     f.write('helloworld')
    time.sleep(3)
    print("子进程的代码")

"""现在这个写法还没有开启进程"""
"""Windows平台上必须写在这个里面"""
if __name__ == '__main__':
    """
    group=None, target=None, name=None, args=(), kwargs={},
                 *, daemon=None
    """
    # 子进程  主进程
    """只是通知操作系统去开进程，并不是立马把进程开起来，他是需要消耗一定的时间的，侧面的反应了开启进程其实消耗很大"""
    p = Process(target=task, name='process-2', args=(), kwargs={'name':'jerry', 'age':20, 'gender':'male'})  # 实例出来一个进程类， 让这个进程执行task任务
    p.start()  # 真正的开启进程
    # 操作系统是负责把这个进程开起来
    # 开启一个进程来执行task任务，真正是谁在执行这个任务，是线程，进程里面至少要有一个线程
    """进程的几个属性：1. 进程名 2. 进程号pid kill """
    # 如何查看进程的名称
    # print(p.name) # Process-1
    # 怎么改进程名字
    # p.name = '这是新的进程名'
    # print(p.name)  # 这是新的进程名

    ## 如何查看进程号
    # print(p.pid) # process id

    # print(p.is_alive()) # True
    # p.terminate() # 杀死进程，结束任务
    # import time
    # time.sleep(1)
    # print(p.is_alive())
    p.join() # 等待子进程的代码全部执行完毕，在走主进程的
    print("主进程的代码执行完毕")

6.如何开启多进程

多进程意味着可以同时做多个任务，一个进程做一个任务，多个进程肯定做多个任务

from multiprocessing import Process

import time
def task(name):
    # print(name)
    # with open('a.txt', 'a', encoding='utf-8') as f:
    #     f.write('helloworld')
    print("子进程")
    time.sleep(1)
if __name__ == '__main__':
    """理论上你是可以一直开进程，单是你需要考虑资源的消耗情况"""
    start_time = time.time()
    ll = []
    for i in range(10):
        p=Process(target=task, kwargs={'name':'kevin'})
        p.start()
        # p.join() #
        ll.append(p)

    for j in ll:
        j.join()

    print("主进程, 总时间：", time.time() - start_time)

7.基于TCP协议的高并发程序

一个服务端不能够同时给多个客户端发送信息

import socket  # python提供的socket模块

def task(conn):
    while True:
        try:
            # 异常了一个bug，粘包现象
            data = conn.recv(1024)  # 括号里面写的是接收的字节数，最多接收1024个字节
            if len(data) == 0:
                continue
            print(data)  # 还是bytes类型

            # 服务端开始给客户端也发送一个数据
            conn.send(data.upper())
        except Exception as e:
            print(e)
            break

    conn.close()


from multiprocessing import Process

if __name__ == '__main__':
    # 1. 买手机
    # SOCK_STREAM  ====> 代表的是TCP协议
    # socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # udp协议
    server = socket.socket()  # 默认是TCP协议

    # 2. 买手机卡
    # '0.0.0.0'  =====> 代表允许任何的ip链接
    # server.bind(('0.0.0.0', 8000)) # 服务端绑定一个地址
    server.bind(('127.0.0.1', 8001))  # 服务端绑定一个地址

    # 3. 开机
    server.listen(1)  # 监听，半连接池
    print('服务端正在准备接收客户端消息：')
    while True:
        conn, client_addr = server.accept()  # 接收,  程序启动之后，会在accept这里夯住，阻塞
        p = Process(target=task, args=(conn,))
        p.start()