进程的基本使用

目录

进程基础（操作系统中的概念）

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

进程的并行和并发概念

同步异步阻塞非阻塞的概念

创建进程（进程类Process）

Process类的参数

Process类的方法

如何开启多进程

基于TCP协议的高并发程序

---

进程基础（操作系统中的概念）

进程和线程都是有操作系统来调用，我们程序员是不能控制的，这里就涉及到调度算法

  

程序：

        其实是一个死的东西，一堆代码就是程序，他没有生命周期

进程：

        它是有声明周期的，这个任务做完，进程就不存在了

 线程：

        线程就是进程中实际做事的

         例如：厨师做饭，厨师做一道菜，应该有菜谱，按照菜谱的程序一步一步的做，在这个过程中菜谱就是程序，程序就是路程，做菜的过程就是进程，厨师就是线程，如果菜做完了，进程就不存在了，线程就是进程中实际做事的

一个进程可以有多个线程，也可以只有一个线程

一个进程中至少必须得有一个线程

 进程，线程，协程，三个小号资源对比：

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

单个cpu一次只能执行一个任务

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

CPU的工作机制：

        1. 遇到I/O的时候就会交出执行权限

        2. 当cpu遇到耗时比较长的时候，也会自动交出执行权限，切换到其他任务

I/O密集型：

        消耗时间，他会被时间所阻塞，不会占用大量的CPU资源，

计算密集型：

        不占用大量的时间，会占用大量的CPU资源，这种情况就是计算密集型，没有时间大量消耗

        

四种算法：

        1.  先来先服务调度算法

        2. 短作业优先调度算法

        3. 时间片轮转发

        4. 多级反馈队列

继承里的并行和并发概念

并行：同一时刻同时运行

        例：

                如果cpu是单核，同一时刻不能做到同时执行多个任务

                如果cpu是多核，同一时刻就能够做到同时执行多个任务

并发：一段时间内看起来是同时运行

        例：

                如果cpu是单核的，能做到多个任务一起操作，因为这是cpu切换达到的

        

同步异步阻塞非阻塞概念

同步：

        每一次运行都要依赖上一步的结果

异步：

        每一次运行的结果不依赖于上次的结果

异步的优点：异步的执行效率比同步的高

阻塞和阻塞这两个概念于程序（线程）等待消息的通知（无所谓同步或异步）时的状态有关，也就是说阻塞于与非阻塞主要是程序（线程）等待消息通知时的状态角度来说的

效率最高的：异步 + 非阻塞

效率最慢的：同步 + 阻塞

如何创建进程

from multiprocessing import Process

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

'''现在还没有开启进程'''

'''在windows平台上开启进程的代码必须写在if __name__ == 'main':里面

if __name__ == 'main':
'''p = Process(target=task,args=('keivn',))这段代码是通知操作系统去开进程，并不是把程序脸开起来，它需要消耗一定的时间'''
    p = Process(target=task,args=('keivn',))    # 实例出一个进程类，让这个类执行task任务
    
    p.start()  # 执行进程

'''
    1. 操作系统是负责把这个进程开起来
    2. 开启一个进程执行task任务，真正是执行这个任务的是线程
'''

'''进程的几个属性：1. 进程名    2. 进程号：pid '''

# 如何查看进程名：
    print(p.name)

# 如何修改进程名：
    p.name = 'xxx'

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

# 杀死进程
  p.terminate()    # 杀死进程结束任务

# 查看进程是否存在,存在则返回True
    print(p.is_alive())

# 等待子进程的所有代码执行完毕，在执行主进程
    p.join()

如何开启多线程

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

方法一：  

from multiprocessing import Process

import time

def task(name):
    print('子进程')
    time.sleep(2)

if __name__ == '__main__'

    p = Process(target = task,args = ('keivn',))
    
    p.start()

    p1 = Process(target = task,args = ('keivn',))
    
        p.start()

    p2 = Process(target = task,args = ('keivn',))
    
        p.start()

    p3 = Process(target = task,args = ('keivn',))
    
        p.start()


print('主进程')

方法二：

        

from multiprocessing import Process

import time 

def task(name):
    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()

        ll.append(p)

    for j in ll:
        j.join()


    print('主进程，总时间：time.time() - start_time')

基于TCP协议的高并发程序

import socket

def task(coon):
    while True:
        try:
            # 异常了一个bug，粘包现象
            data = coon.recv(1024)
            if len(data) == 0:
                continue
            print(data)    # 还是bytes类型

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

    conn.close()



from multiprocessing import Process

if __name__ == '__main__':

    server = socket.socket()    # 默认是TCP协议
    
    server.bind(('127.0.0.1',8000))    # 服务端绑定一个地址

    server.listen(1)    # 监听，也称半链接池
    
    print('服务端正在准备接收客户端消息：')
    while True:
        coon,client_addr = server.accept()    # 接收，程序启动后，会在accept这里阻塞

        p = Process(target = task,args = (coon,))

        p.start()