标签：__ task 阻塞 开启 线程 time 进程
进程概念
# 进程、线程都是操作系统中的基本概念，也就是说进程和线程都是操作系统层面的东西，专业术语表达就是进程和线程的使用都是有操作系统来调度的. 而不时有我们程序员自己来操控的
在操作系统这门课里面，进程和线程是操作系统的概念，协程不是操作系统中的概念，而是我们程序员层面的
协程是有我们程序员自己来调用的，不是有操作系统来调用的，也就是说，在操作系统中没有协程这个概念
进程是用来干什么的：
进程可以用来做任务的，比如：听歌、看视频等
什么是进程?
"""
eg：
厨师做饭，厨师按照菜谱来做菜，那么，菜谱就是程序，而做饭的过程就是进程，在这个过程中，厨师就是线程，所以，厨师才是真正做事的，言外之意线程才是真正干活的，而进程不是，进程只是一个过程
"""
列如：电脑的任务管理器
进程和程序的区别：
1. 程序就是一堆死的东西，没有生命周期
： 进程是程序的一次执行过程，是动态概念。
： 程序是一组有序的指令集和，是静态概念。
2. 进程是有生命周期的，当一个任务进行完毕之后，进程就不存在了
: 当操作系统要完成某个任务时，它会创建一个进程。当进程完成任务之后，系统就会撤销这个进程，收回它所占用的资源。
从创建到撤销的时间段就是进程的生命期。
"""进程中是要有线程的，进程中如果没有线程是没有意义的，一个进程中是可以有多个线程的，一个进程中至少要有一个线程"""
进程和线程都是有操作系统来调度的
进程是操作系统的一个独立的单位
补充：CPU的工作机制
1. 当CPU遇到I/O操作的时候，会剥夺CPU的执行权限
2. 当遇到的任务需要占用大量的时间的时候，也会剥夺执行权限
"""其实CPU的工作机制是来回切换做到的"""
I/O密集型:
input output
"""遇到阻塞，但是不需要占用大量的CPU资源，需要等待，比如：sleep"""
计算密集型
"""没有遇到阻塞，但是需要占用大量的CPU资源，也不需要等待"""
操作系统的调度算法(了解)
1. 先来先服务调度算法
： 它根据进程到达时间决定先运行哪一个进程，非抢占。
2. 短作业优先调度算法
： 是根据服务的时间经行选择。
3. 时间片轮转算法
： 当中断发生时，当前运行的程序置于就绪队列（队尾）中，然后基于FCFS选择下一个就绪作业运行。
4. 多级反馈队列
: 在作业调度中，优先级调度算法每次从后备作业队列中选择优先级最髙的一个或几个作业，将它们调入内存，
分配必要的资源，创建进程并放入就绪队列。在进程调度中，优先级调度算法每次从就绪队列中选择优先级最高的进程，将处理机分配给它，使之投入运行。
"""操作系统会自行选择哪一种算法"""
进程的并发和并行
1. 并行：在'同一时刻'，同时执行任务
CPU是有多个核的，单核的，多核的
单核的CPU能不能做到并行?
做不到的
"""在同一时刻要想执行多个任务，必须要求CPU有多个处理器（核）"""
2. 并发：在一段时间内，看起来是同时执行任务，事实上，不是同一时刻
同步异步阻塞非阻塞
同步：依赖于上一次的结果
: 就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回。也就是必须一件一件事做,等前一件做完了才能做下一件事。
例如普通B/S模式（同步）：提交请求->等待服务器处理->处理完毕返回 这个期间客户端浏览器不能干任何事
异步：不依赖于上一次的结果
: 异步的概念和同步相对。当一个异步过程调用发出后，调用者不能立刻得到结果。实际处理这个调用的部件在完成后，通过状态、通知和回调来通知调用者。
例如 ajax请求(后面才学，也可以先了解一下)（异步）: 请求通过事件触发->服务器处理（这是浏览器仍然可以作其他事情）->处理完毕
# 异步的效率肯定是不同步的效率高
阻塞：
阻塞调用是指调用结果返回之前，当前线程会被挂起（线程进入非可执行状态，在这个状态下，cpu不会给线程分配时间片，即线程暂停运行）。函数只有在得到结果之后才会返回。
有人也许会把阻塞调用和同步调用等同起来，实际上他是不同的。对于同步调用来说，很多时候当前线程还是激活的，只是从逻辑上当前函数没有返回,它还会抢占cpu去执行其他逻辑，也会主动检测io是否准备好。
非阻塞:
非阻塞和阻塞的概念相对应，指在不能立刻得到结果之前，该函数不会阻塞当前线程，而会立刻返回。
再简单点理解就是：
1. 同步，就是我调用一个功能，该功能没有结束前，我死等结果。
2. 异步，就是我调用一个功能，不需要知道该功能结果，该功能有结果后通知我（回调通知）
3. 阻塞，就是调用我（函数），我（函数）没有接收完数据或者没有得到结果之前，我不会返回。
4. 非阻塞，就是调用我（函数），我（函数）立即返回，通过select通知调用者
如何开启进程
# 使用的是内置的模块：multiprocess
from multiprocessing import Process # 从多进程里面加载一个单线程出来
def task(): # 定义一个task函数出来
with open('a.txt', 'w', encoding="utf8") as f: # 读文件
f.write('helloworld')
# 开一个进程来执行task这个任务
# 如何开进程
"""在Windows系统中，开启进程必须写在__main__中, 在其他系统中不用加"""
if __name__ == '__main__':
p = Process(target=task) # task不加括号哦， 得到一个对象，还没有开启进程呢，知识实例化了一个进程对象
p.start() # 调用start这个方法才是真正的开启进程
Process类的参数:
def task(name, name1, age, gender):
print(name)
print(name1)
print("age:", age)
print("gender:", gender)
# import time
# time.sleep(5)
# with open('a.txt', 'w', encoding="utf8") as f:
# f.write('helloworld')
# task('kevin')
# 开一个进程来执行task这个任务
# 如何开进程
"""在Windows系统中，开启进程必须写在__main__中, 在其他系统中不用加"""
if __name__ == '__main__':
"""
group=None, target=None, name=None, args=(), kwargs={},
*, daemon=None
每一个进程都有：进程名，进程id等属性
name: 代表的是进程的名字
args=(), 传参数的
kwargs={},
daemon:守护进程
"""
# p = Process(target=task) # 得到一个对象，还没有开启进程呢，知识实例化了一个进程对象
"""这个开启进程只是通知操作系统去开进程，因为开启进程需要时间的，所以，在一瞬间进程并没有开起来，然后代码往下执行了"""
# 开启的这个进程叫子进程
p = Process(target=task, name='ly_1', args=('kevin', 'jason'), kwargs={'age':18, 'gender':'male'}) # 得到一个对象，还没有开启进程呢，知识实例化了一个进程对象
# 守护进程的作用：主进程结束，子进程也结束
# 注意：p.daemon = True 必须要写在
p.daemon = True # 把p进程设置为守护进程p.start()之前
p.start() # 调用这个方法才是真正的开启进程
# 如何查看一个进程的名字
# Process-1, ly_1
# print(p.name) # 看的是p进程的名字
print("123")
"""现在的现象是：主进程代码先执行，然后执行子进程里的代码，并且主进程代码执行完毕之后，子进程的代码并没有结束"""
方法介绍
# p.terminate() # 杀死进程
# # True
# import time
# time.sleep(1)
#
# # False
# print(p.is_alive()) # 查看p进程是否存活
# join
# 现在让你先执行子进程中的代码，在执行主进程中的代码?
p.join() # 先等待子进程执行完毕，在执行主进程
如何开启多进程
import time
def task(i):
print("task:", i)
time.sleep(1)
from multiprocessing import Process
if __name__ == '__main__':
start_time = time.time()
ll = [] # 存的5个进程对象
for i in range(5): # 用for循环，可以同时开启5次
# 开启多进程之后，有可能是没有顺序的
p = Process(target=task, args=(i,)) # 循环一次，就打印一次i
p.start() # 谁先开启的就谁
# p.join() # 5个进程变成了串行 等这个今个进程执行完才进行下一个进程
ll.append(p) # 每开一个进程，都会把进程对象放在列表里面
for j in ll:
j.join() # 每一个进程都加join
"""想让所有的子进程先执行完，在执行主进程"""
print(123)
print("time:", time.time() - start_time)
# 打印顺序为：
# task: 0
# task: 1
# task: 2
# task: 3
# task: 4
# 123
# time: 1.4832251071929932
进程锁
# 锁：以后你遇到的所有关于加锁的都是为了保证数据的安全
MySQL中：行锁、表锁、悲观锁、乐观锁、等
进程锁、互斥锁、GIL锁、死锁等
def task(i, lock):
# 上一把锁
lock.acquire()
print("第%s个进程进来了" % i)
print("第%s个进程走了" % i)
# 释放锁
lock.release()
from multiprocessing import Process
from multiprocessing import Lock
if __name__ == '__main__':
lock = Lock()
for i in range(5):
p = Process(target=task, args=(i, lock))
p.start()
进程间的通信（IPC机制）
# 进程是可以开启多个的，进程与进程之间是相互独立的，互补影响，进程是操作系统的一个独立单元
一个进程崩溃了，其他的进程不收影响
"""在一个进程中不能修改另外一个进程的数据，言外之意是进程之间的数据是隔离的，互补影响"""
# 要想在一个进程中使用另外一个进程中的数据，需要让进程之间通信（IPC）
标签：__,
task,
阻塞,
开启,
线程,
time,
进程
From： https://www.cnblogs.com/huangchunfang/p/17528566.html