1 .内容回顾
#__author : 'liuyang'
#date : 2019/4/17 0017 上午 9:01
# 利大于弊，则做之
# 会死于斯，则不去
# 2个 人 晚上 5个题 面试题
# 今晚 7点 考试题
# 五一之前 要考试
#其它内容（40%） 网编并发数据库（60%） #锁
#互斥锁
#能够保护数据的安全性
#保证对于数据的修改操作同一时刻多个进程只有一个进程执行
#进程数据不安全：同时修改文件/数据库/其它共享资源的数据 # 队列---实现了进程之间的通信（IPC） #进程队列 ----进程安全
#从mutltiprocessing 导入Queue
#q = Queue()
#put/get
# 基于管道+管道 ，管道 进程不安全
# 管道 基于文件级别的socket 实现的 import queue
from multiprocessing import Queue
# 生产者消费模型
# put get 两个阻塞方法
# put_nowait（丢数据）/ get_nowait 非阻塞方法
q = Queue(5) #队列里有五个
q.put(1)
q.put(1)
q.put(1)
q.put(1)
q.put(1)
print('_____________')
try :
q.put_nowait(1) #也传一个
except queue.Full:
# 存在这里
pass
# q.put(1)
print('______')
# q.put(1)
print('__')
print(q.get())
print(q.get())
print(q.get())
print(q.get())
print(q.get())
print(q.get())
# print(q.get()) # print(q.get())
# print(q.get())
# print(q.get()) try :
print(q.get_nowait())
except queue.Empty:
pass # 网页版的 qq
# sereve 端 djiong 写的
# 信息一直没有 一直夯在这 于是 用get_nowait() 没数据立刻返回
# 隔个0.5秒 再返回来查看 # 生产者 消费者 模型
# 达到效率平衡
# 一个生产数据和消费数据的完整的流程解耦解耦成两个部分：生产和消费
#由于生产速度和消费速度不一致，所以需要我们调整生产者和消费者额d个数来达到效率平衡
2.今日内容
#1 互斥锁
#2 进程之间的数据共享
#关于数据安全的问题
#3 进程池
#from multiprocessing import Pool
# 事件\信号量\管道
# 4 线程的概念（面试的重点）
# 5 认识线程模块
3.什么是互斥锁
# 在多个进程中 或者一个进程中
# 有acquire（）acquire（）就阻在那里了
#__author : 'liuyang'
#date : 2019/4/17 0017 上午 9:27
# from multiprocessing import Lock
# #1 互斥锁：不能在同一个进程内，‘也’有锁的竞争关系
# # 在同一个进程中连续acquire多次会产生死锁
# lock = Lock()
# lock.acquire() #拿走钥匙
# print(1)
# lock.acquire() #被拿走了又想要钥匙 卡住 #互斥
# print(2)
# # lock.release() #没还钥匙 卡在第一个开锁那
# lock.release()
# lock.release()
4.数据共享（进程内可以但是不大需要）
# 本来是数据隔离的
# 加上Manager就可以分享了
#__author : 'liuyang'
#date : 2019/4/17 0017 上午 9:35
#数据共享几乎不用
# 数据共享： 可以， Manager 但是不安全
# 可以 安全 加锁 from multiprocessing import Process,Manager,Lock
def func(dic):
dic['count'] -= 1 # 数据不共享 正常情况下数据隔离 子进程改
if __name__ == '__main__':
lock = Lock()
m = Manager()
dic = m.dict({'count':100})
p_l = []
for i in range(100):
p = Process(target=func,args=(dic,lock))
p.start()
p_l.append(p)
for p in p_l : p.join()
print(dic) #{'count': 0} 性能越好 越不得零 # 100 减 100次 1 这么慢？ 不是减操作造成的
# 慢是因为 开100个进程 所以慢 开和管理 销毁进程拖慢了程序的运行效率 # 为什么在这里出现了数据不安全的现象？
# 正常不会数据共享 隔离 肯定通过socket 文本或者网络传过来的
# （不丢失）性能快的时候，比如两个 子进程同时对一样的值操作了，返回的一样的值 #什么情况会出现数据不安全：Manager 类当中对字典/列表 += -= *= /=
#添加值 不会
#如何解决 ： 加锁 # 修改的 异步 性能高了会出错对同一个进行操作 #加锁同步安全
# 查看的 异步快 # cpu个数 最多起cpu*2个
#
5.多线程
cpython解释器内置的 GIL锁，同步
为了数据安全
解释性语言（一边解释一边编译 解释的字节码 无序 所以操作造成异步操作 数据不安全）
编译型语言可以实现多进程
#__author : 'liuyang'
#date : 2019/4/17 0017 上午 10:18
# 线程是进程中的一个单位
# 进程是计算机中最小的资源分配单位
# 线程是计算机中被CPU调度的最小单位 # 开启进程 关闭进程 切换进程都需要时间
# 你的电脑的资源还是优先的
# 开启过多的进程会导致你的计算机崩溃 # count_cpu*2 = 8 #4 核
# 同时对8个客户端服务
# qps 每秒的请求数 2W # 2000/8 = 250 台机器 # 进程： 数据隔离的
#ftp server端
#qq server端（不用隔离，本来就不传输，得写了才传）
# 并发： 同一时刻能同时接受多个客户端的请求
# 进程有大 有数据隔离 开多了还不行 （有的不需要隔离，还要ipc传输过来、） #线程：
# 轻型进程 轻量级的进程
# 在同一个进程中的多个线程是可以共享一部分数据的
# 线程的开启\销毁\切换都比进程要高级很多 #1.多个进程可不可以利用多核（多个CPU）
#2.多个线程可不可以利用多核（多个CPU）
# 都可以 # 多进程和多线程之间的区别
#进程 数据隔离 开销大 （必须数据隔离是才会进程）
#线程 数据共享 开销小 # python 当中的多线程
# Cpython 解释器 有一个GIL锁 （怕麻烦 要不太多修改的）
# # （解释性语言） 编译 --》字节码（bytes） 没法正常排序的-->机器码(0101)
# python 代码机器语言
from dis import dis
def func():
a = []
a.append(1)
dis(func)
'''
42 0 BUILD_LIST 0
2 STORE_FAST 0 (a) 43 4 LOAD_FAST 0 (a)
6 LOAD_ATTR 0 (append)
8 LOAD_CONST 1 (1) #加载他们几个存在内存里
10 CALL_FUNCTION 1 #调用
12 POP_TOP
14 LOAD_CONST 0 (None)
16 RETURN_VALUE''' #默认返回空
# 两个程序在两个cpu上同时触发，就可能造成数据不安全
# python 解释器（自动加锁） 同一时刻 只能有一个线程执行（单线程） # 解释性语言(python,php) 都不能多个程序（线程）访问多个cpu #（异步执行无序）所以数据不安全
# 编译型语言(c,java) 都能多个程序（线程）访问多个cpu # GIL 锁 历史遗留问题(python诞生时没有多核)
#线程中的状态 就不如编译型语言 那么完美 # python 当中的多线程（不是python的锅，可以解决的，没必要）
# 不能访问多个cpu
# 是Cpython(解决不了高运算) 解释器导致的 #不同的工具不同的功能
#每个工具都不是万能的
# GIL = 全局解释器锁 导致了同一时刻只能有一个线程访问cpu
# pypy 没有GIL锁 Jpython 解释成java 可以多线程访问多核的 （但是他们的执行效率慢） # 研究pypy（和cpython速度相近了） 不如直接研究 go
# go 的执行效率 和 c相近了 #利用 多核意味着 多个CPU可以同时计算线程中的代码 # IO 操作
#accept负责从网络上读取数据
#open（） 调用操作系统的指令 0.9ms的时间 （cpu执行450万条指令（在阻塞））
#read #7个指令 一行代码 50w/7 7w条 python 代码 千分之一秒 执行的 # 分布式\多进程
#大量的计算 可以开 多进程 进多核 高额业务 # ftp 这样的大部分都是网络和进程都无关
# web 框架 #大部分时间 都是金阻塞 io呢 文件呢 网络呢 没大进cpu进行
#所以单进程多线程就够了
#Django flask tornado twistwed scrapy sanic
#都 并发 多线程 没有用进程 # 解释性和 编译型 的 因为一边翻译 一边编译 不如 直接汉语好 英语放过来
6.python代码实现 thread(进程)
#__author : 'liuyang'
#date : 2019/4/17 0017 上午 11:34
# 利 = 1
# 弊 = 2
# do = 'do'
# if 利 > 弊:
# do
#
import threading
# threading 和 multtiprocessing
# 先有的threading模块
#没有池的功能
#multiprocessing 完全模仿threading 模块完成的
#实现了池的功能
#concurrent.futures
#实现了线程池\进程池 # import os
# import time
# from threading import Thread
# def func(i): #子线程
# time.sleep(1) #阻塞了之后 cpu就绪 执行就不在控制范围内 了所以不按顺序
# print('in func',i, os.getpid())
#
# print('in main',os.getpid())
# #一个线程的时间开启和管理的时间不是固定的 开的时候有可能cpu很闲
# #直接执行了
#
# for i in range(20): #并发 #异步不是一起执行
# Thread(target=func,args=(i,)).start()
#func() #同步20 秒 20倍差别
#in main 4676
# in func 4676
# 在一个进程里 # if __name__ =='__main__': #多个线程都是 共享的 没有import没有导入
# 不会被执行 所以 不用
# 在线程部分不需要通过import来为新的线程获取代码
# 因为新的线程和之前的主线程共享同一段代码
# 不需要import 也就不存在 子进程中有重复了一次 # 开销 # 进程和线程的代码管理 是一样的 因为都是开和关 没必要有差距
# 数据隔离
#
# from multiprocessing import Process
# from threading import Thread
# import time
# def func(a):
# a += 1
# if __name__ =='__main__':
# start = time.time()
# t_l = []
#
# for i in range(100):
# t = Thread(target=func,args=(i,))
# t.start()
# t_l.append(t)
# for t in t_l : t.join() # 确保前面都执行完
# print('thread',time.time() - start )
#
# start = time.time()
# t_l = []
#
# for i in range(100):
# t = Process(target=func, args=(i,))
# t.start()
# t_l.append(t)
# for t in t_l: t.join() # 确保前面都执行完
# print('process',time.time() - start)
#
# #t 0.0870048999786377
# # p 7.8074469566345215
# 100倍 开进程倍 # 多个线程之间的全局变量是共享的
#
# from multiprocessing import Process
# from threading import Thread
# import time
# tn = 0
# def func(a):
# global tn
# tn += 1
# if __name__ =='__main__':
# start = time.time()
# t_l = []
#
# for i in range(100):
# t = Thread(target=func,args=(i,))
# t.start()
# t_l.append(t)
# for t in t_l : t.join() # 确保前面都执行完
# print('thread',time.time() - start )
# print(tn)
#
# # 进程之间数据隔离
# pn = 0 # 这里定义了 所以不报错
# def func(a):
# global pn
# pn += 1
#
# if __name__ == '__main__':
#
# start = time.time()
# t_l = []
#
# for i in range(100):
# t = Process(target=func, args=(i,))
# t.start()
# t_l.append(t)
# for t in t_l: t.join() # 确保前面都执行完
# print('process',time.time() - start)
# print(pn) # 线程中的几个替他方法
from threading import Thread,currentThread #线程对象
import os
def func():
t = currentThread() #线程属于哪个id的
print(t.name,t.ident,os.getpid())
# print(currentThread(),os.getpid()) tobj = Thread(target=func)
tobj.start()
print('tobj:',tobj)
# print(currentThread(),os.getpid())
'''
Thread-1 9224 9612
<_MainThread(MainThread, started 4108)> 9612
<Thread(Thread-1, started 9224)> 9612
'''
'''
Thread-1 8800 9588 #巧了 异步一样
tobj: <Thread(Thread-1, stopped 8800)>''' lst = [1,2,3,4,5,6,7,8,9,10]
#按照顺序把列表中的每一个元素都计算一个平方
#使用多线程方式
# #并且将结果按照顺序返回
from threading import Thread #线程对象
import time
import random
dic = {}
def func(i):
t = currentThread()
time.sleep(random.random())
dic[t.ident] = i**2
t_l = []
for i in range(1,11):
t = Thread(target=func, args=(i,))
t.start()
t_l.append(t)
for t in t_l:
t.join() # 确保前面都执行完
print(dic[t.ident])
print(dic) #{7936: 81, 6056: 4, 9344: 49, 10188: 9, 6648: 100, 7264: 64, 4072: 16, 9924: 36, 8796: 1, 7216: 25}
#这不是 按顺序添加的 只是显示是顺序的 添加是按顺序的 # from threading import active_count
# # 返回当前正在工作的线程
# from threading import Thread #线程对象
# import time
# import random
# l = []
# def func(a):
# t = currentThread()
# time.sleep(random.random())
# for i in range(1,11):
# t = Thread(target=func, args=(i,))
# #t.start() 11 个 不start() 就不执行
# print(active_count()) #1 #只有一个主线程 # 线程有terminate 么？
#没有terminate 不能强制结束
#所有的子线程都会在执行完所有的任务之后结束 # 统计线程的id 统计正在执行的线程数 用法差不多 没有terminate # 1 . 通读博客 ：操作系统 ，进程，线程
# 2 . 把课上的代码都搞明白
# 3. 多线程实现一个并发 tcp协议的socket_server
# 4. 明天默写和线程相关的