Python---进程

Python从入门到高手（内部资源-配学习资料）_哔哩哔哩_bilibili

单核CPU实现多任务原理：操作系统轮流让各个任务交替执行

多核CPU实现多任务原理：真正执行多任务只能在多核CPU上实现，但是由于任务数量远远多于CPU的核心数量，所以，操作系统会自动把很多任务轮流调度到每个核心上执行

并发：当有多个线程在操作是，如果系统只有一个CPU，则它跟本不可能真正同时进行一个以上的线程，它只能把CPU运行时间划分成若干个时间段，再将时间段分配给各个线程执行，在一个时间段的线程代码运行时，其他线程处于挂起状态，这种方式我们称为并发（Concurrent）

并行：当系统有一个以上CPU时，则线程的操作有可能非并发。当一个CPU执行一个线程时，另一个CUP可以执行另一个线程，两个线程互不抢占CPU资源，可以同时进行，这种方式称之为并行

进程>线程>协程

一、多进程

进程是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。

对于操作系统来说，一个任务就是一个进程。

优点：稳定性高，一个进程崩溃了，不影响其他进程

缺点：创建进程开销巨大

操作系统能同时运行进程数目有限

import os
from multiprocessing import Process
from time import sleep


def task1():
    while True:
        sleep(1)
        print('这是任务1.。。。。。。。。。。',os.getpid(),'------',os.getppid())


def task2():
    while True:
        sleep(2)
        print('这是任务2.。。。。。。。。。。',os.getpid(),'------',os.getppid())


if __name__ == '__main__':
    print(os.getpid())
    # 子进程
    p = Process(target=task1, name='任务1')
    p.start()
    print(p.name)
    p1 = Process(target=task2, name='任务2')
    p1.start()
    print(p1.name)

-------------------------------------------------------------------------------------------------------------

''':cvar
from multiprocessing import Process

process=Process(target=函数，name=进程的名字，args=（给函数传递的参数）
process 对象
对象调用方法：
process.start()启动进程并执行任务
process.run 只是执行了任务但是没有启动进程
terminate() 终止
'''

import os
from multiprocessing import Process
from time import sleep


def task1(s, name):
    while True:
        sleep(s)
        print('这是任务1.。。。。。。。。。。', os.getpid(), '------', os.getppid(), name)


def task2(s, name):
    while True:
        sleep(s)
        print('这是任务2.。。。。。。。。。。', os.getpid(), '------', os.getppid(), name)


number = 1

if __name__ == '__main__':
    print(os.getpid())
    # 子进程
    p = Process(target=task1, name='任务1', args=(1, 'aa'))
    p.start()
    print(p.name)
    p1 = Process(target=task2, name='任务2', args=(2, 'bb'))
    p1.start()
    print(p1.name)
    while True:
        number += 1
        sleep(0.2)
        if number == 100:
            p.terminate()
            p1.terminate()
            break
        else:
            print('----------->number', number)

--------------------------------------------------------------------------------------------------------------------

 

''':cvar
多进程对于全局变量访问，在每一个全局变量里面都放一个m变量
保证每个进程访问变量互不干扰
'''

import os
from multiprocessing import Process
from time import sleep

m = 1  # 不可变类型
list1 = []  # 可变类型


def task1(s, name):
    global m
    while True:
        sleep(s)
        m += 1
        list1.append(str(m)+'task1')
        print('这是任务1.。。。。。。。。。。', os.getpid(), '------', os.getppid(), name)
        print('task1', m, list1)


def task2(s, name):
    global m
    while True:
        sleep(s)
        m += 1
        list1.append(str(m) + 'task2')
        print('这是任务2.。。。。。。。。。。', os.getpid(), '------', os.getppid(), name)
        print('task2', m, list1)


if __name__ == '__main__':
    print(os.getpid())
    # 子进程
    p = Process(target=task1, name='任务1', args=(1, 'aa'))
    p.start()
    print(p.name)
    p1 = Process(target=task2, name='任务2', args=(2, 'bb'))
    p1.start()
    print(p1.name)
    while True:
        sleep(1)
        m += 1
        print('------>main:', m, list1)

---------------------------------------------------------------------------------------------------------------------------

# 进程：自定义
from multiprocessing import Process


class MyProcess(Process):
    def __init__(self, name):
        super(MyProcess, self).__init__()
        self.name = name

    # 重写run方法
    def run(self):
        n = 1
        while True:
            # print('进程名字:' + self.name)
            print('{}------>自定义进程,n:{}'.format(n, self.name))
            n += 1


if __name__ == '__main__':
    p = MyProcess('小明')
    p.start()
    p1 = MyProcess('小红')
    p1.start()

-----------------------------------------------------------------------------------------------------------------------------

from multiprocessing import Pool
import time
from random import random
import os

''':cvar
阻塞式：
非阻塞式：全部添加到队列中，立刻返回，并没有等待其他的进程完毕，但是回调函数是等待任务完成之后才调用
'''


# 非阻塞式进程
def task(task_name):
    print('开始做任务！', task_name)
    start = time.time()
    # 使用sleep
    time.sleep(random() * 2)
    end = time.time()
    # print('完成任务:{}用时：{},进程id：{}'.format(task_name, (end - start), os.getpid()))
    return '完成任务:{}用时：{},进程id：{}'.format(task_name, (end - start), os.getpid())


container = []


def callback_func(n):
    container.append(n)


if __name__ == '__main__':
    pool = Pool(5)
    tasks = ['听音乐', '吃饭', '洗衣服', '打游戏', '散步', '看孩子', '做饭']
    for task1 in tasks:
        pool.apply_async(task, args=(task1,), callback=callback_func)

    pool.close()  # 添加任务结束
    pool.join()  # 阻塞后面代码执行
    for c in container:
        print(c)
    print('over!')

----------------------------------------------------------------------------------------------------------------------

# 阻塞式
from multiprocessing import Pool
import time
from random import random
import os

''':cvar
阻塞式：
添加一个执行一个任务，如果一个任务不结束另一个任务就进不来。
进程池：
pool=Pool(max) 创建进程对象池
pool.apply() 阻塞的
pool.apply_async() 非阻塞的

pool.close()
pool.join() 让主进程让步
'''


# 非阻塞式进程
def task(task_name):
    print('开始做任务！', task_name)
    start = time.time()
    # 使用sleep
    time.sleep(random() * 2)
    end = time.time()
    print('完成任务:{}用时：{},进程id：{}'.format(task_name, (end - start), os.getpid()))
    # return '完成任务:{}用时：{},进程id：{}'.format(task_name, (end - start), os.getpid())


if __name__ == '__main__':
    pool = Pool(5)
    tasks = ['听音乐', '吃饭', '洗衣服', '打游戏', '散步', '看孩子', '做饭']
    for task1 in tasks:
        pool.apply(task, args=(task1,))

    pool.close()  # 添加任务结束
    pool.join()  # 阻塞后面代码执行

    print('over!')

-------------------------------------------------------------------------------------------------------------------------

# 进程间通信
from multiprocessing import Queue

q = Queue(5)
q.put('A')
q.put('B')
q.put('C')
q.put('D')
q.put('E')
print(q.qsize())
if not q.full:  # 判断队列是否已满  q.empty() 判断队列是否是空的
    q.put('F', timeout=3)  # put() 如果queue满了则只能等待，除非有’空地‘则添加成功
else:
    print('队列已满！')

# 获取队列信息
print(q.get(timeout=2))
print(q.get(timeout=2))
print(q.get(timeout=2))
print(q.get(timeout=2))
print(q.get(timeout=2))

q.put_nowait()
q.get_nowait()