python学习Day39--复习（前期+进程和线程相关）

一、前期复习

1、C/S架构与B/S架构：

　　C/S架构：客服端 服务器模式

　　B/S架构：浏览器 服务器模式

　　B/S架构的客服端对PC机的性能要求较低。统一了应用的接口。B/S架构隶属于C/S架构。

2、TCP/UDP的区别：

　　TCP：面向连接，可靠的，面向字节流

　　UDP：不面向了解，不可靠，速度快，面向数据包的

3、TCP会发生粘包：

　　粘包：数据混乱。发送端发送了数据后，接收端不知道应该如何去接收，导致数据混乱。

　　合包机制：Nagle算法

　　拆包机制

　　注意：只有TCP协议才会发生粘包。

4、arp协议：

　　通过目标的IP地址获取到目标的MAC地址。

5、OSI五层模型：

　　应用层:　　　　　　　　http, https, ftp

　　传输层：　　　　　　　 tcp, udp

　　网络层：　　　　　　     ip协议

　　数据链路层：　　　　　 arp协议　　　　　　　　网卡

　　物理层：　　　　　　　　　　　　　　　　　　　网线，电信号，集线器

6、交换机与路由器的区别：

　　交换机主要用来组织局域网，进行同一网段之间的信息传输。

　　路由器主要用来跨网段的信息传输，路由出最佳路径。

7、交换机的通信方式

　　单播：点对点

　　广播：吼一嗓子

　　组播：点对多（一组或多台）

8、如何判断两台电脑是否处于同一网段？

　　子网掩码 & ip地址

9、并行和并发？

　　并行：同一时间点多个任务同时进行

　　并发：在统一时间段内多个任务同时进行

10、进程和线程的区别？

　　进程：是资源分配的基本单位

　　线程：是最小的执行单位，线程不能独立拥有资源，必须依赖于所属进程。

　　当计算密集时，多进程比较好。IO密集时，使用多线程。

11、锁

　　GIL锁：全局解释锁。锁的是线程，宝成同一时间只允许一个线程访问CPU。

　　互斥锁：一把锁配一把钥匙。主要用于保护数据安全

　　　　共享资源，又叫做临界资源、共享代码，又叫做临界代码。

　　　　对临界资源进行操作时，一定要加锁。

　　递归锁：一把万能 钥匙配好多把锁。

12、信号量

　　也是用来保护数据安全的。一把锁配多把钥匙。

13、事件：

　　wait( )：判断is_set的bool值，如果为True，wait是非阻塞。

　　set：将is_set的bool值设置为True。

　　is_set：标识

　　clear：将is_set的bool值设置为False

14、多线程：

　　条件：Condition

　　定时器：Timer(t, func)

15、多进程之间的通信：

　　队列和管道

　　队列是安全的，队列=管道+锁

　　管道是不安全的。

16、队列实现生产者消费者模型

　　这个模型主要是为了解耦

17、进程池的模块：Pool

　　p.map

　　p.apply( )：同步提交任务

　　p.apply_async( )：异步提交任务

　　回调函数：在进程池中，是父进程调用的回调函数。

二、进程池和线程池

1、同一个进程内的队列（多线程）

　　优先级队列：queue.PriorityQueue( )

　　q.put( )　　接收的是一个元组

　　元组中的第一个参数：表示当前数据的优先级

　　元组中的第二个参数：需要存放到队列的数据

　　　　优先级比较：（首先保证整个队列中，所有表示优先级的东西必须一致）

　　　　① int：比较数值大小

　　　　② str：比较字符串的大小，从第一个字符的ASCII码开始比较

2、线程池

　　在一个池子里，放固定数量的线程，这些线程等待任务，一旦有任务来，就有线程自发的去执行任务。

from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
from multiprocessing import Pool

#  concurrent.futures 这个模块是异步调用的机制
#  concurrent.futures 提交任务都是用submit
#  for + submit 多个任务的提交
#  shutdown 是等效于Pool中的close+join，是指不允许再继续向池中增加任务，然后让父进程(线程)等待池中所有进程执行完所有任务。

# from multiprocessing import Pool.apply / apply_async
import time

def func(num):
    sum = 0
    for i in range(num):
        for j in range(i):
            for x in range(j):
                sum += x ** 2
    print(sum)

if __name__ == '__main__':
    pass
    # pool的进程池的效率演示
    # p = Pool(5)
    # start = time.time()
    # for i in range(100):
    #     p.apply_async(func,args=(i,))
    # p.close()
    # p.join()
    # print('Pool进程池的效率时间是%s'%(time.time() - start))


    # 多进程的效率演示
    # tp = ProcessPoolExecutor(5)
    # start = time.time()
    # for i in range(100):
    #     tp.submit(func, i)
    # tp.shutdown()  # 等效于 进程池中的 close + join
    # print('进程池的消耗时间为%s' % (time.time() - start))




    # 多线程的效率
    # tp = ThreadPoolExecutor(20)
    # start = time.time()
    # for i in range(1000):
    #     tp.submit(func,i)
    # tp.shutdown()# 等效于 进程池中的 close + join
    # print('线程池的消耗时间为%s'%(time.time() - start))


# 结果：针对计算密集的程序来说
#   不管是Pool的进程池还是ProcessPoolExecutor()的进程池，执行效率相当
#   ThreadPoolExecutor 的效率要差很多
#   所以 当计算密集时，使用多进程。

from concurrent.futures import ThreadPoolExecutor
import time


def func(num):
    sum = 0
    # time.sleep(5)
    # print(num) # 异步的效果
    for i in range(num):
        sum += i ** 2
    return sum

t = ThreadPoolExecutor(20)


# 下列代码是用map的方式提交多个任务，对应 拿结果的方法是__next__()  返回的是一个生成器对象
res = t.map(func,range(1000))
t.shutdown()
print(res.__next__())
print(res.__next__())
print(res.__next__())
print(res.__next__())

# 下列代码是用for + submit提交多个任务的方式，对应拿结果的方法是result
# res_l = []
# for i in range(1000):
#     re = t.submit(func,i)
#     res_l.append(re)
# # t.shutdown()
# [print(i.result()) for i in res_l]

# 在Pool进程池中拿结果，是用get方法。   在ThreadPoolExecutor里边拿结果是用result方法

3、回调函数

　　无论是ProcessPoolExecutor的进程池，还是Pool的进程池，回调函数都是父进程调用的。

from concurrent.futures import ProcessPoolExecutor
# 不管是ProcessPoolExecutor的进程池  还是Pool的进程池，回调函数都是父进程调用的。
import os
import requests


def func(num):
    sum = 0
    for i in range(num):
        sum += i ** 2
    return sum

def call_back_fun(res):
    # print(res.result(),os.getpid())
    print(os.getpid())

if __name__ == '__main__':
    print(os.getpid())
    t = ProcessPoolExecutor(20)
    for i in range(1000):
        t.submit(func,i).add_done_callback(call_back_fun)
    t.shutdown()

4、条件

　　条件涉及的4个方法：

con.acquire()
con.release()
con.wait()  # 假设有一个初始状态为False，阻塞。一旦接受到notify的信号后，变为True，不再阻塞
con.notify(int)  给wait发信号，发int个信号，会传递给int个wait，让int个线程正常执行

from threading import Condition,Thread
import time


def func(con,i):
    con.acquire()# 主线程和10个子线程都在抢夺递归锁的一把钥匙。
    # 如果主线程抢到钥匙，主线程执行while 1，input，然后notify发信号，还钥匙。但是，此时如果主线程执行特别快
    # 极有可能接下来主线程又会拿到钥匙，那么此时哪怕其他10个子线程的wait接收到信号，但是因为没有拿到钥匙，所以其他子线程还是不会执行
    con.wait()
    print('第%s个线程执行了'%i)
    con.release()

con = Condition()
for i in range(10):
    t = Thread(target=func,args = (con,i))
    t.start()
while 1:
    # print(123)
    con.acquire()
    num = input('>>>')
    con.notify(int(num))
    con.release()
    time.sleep(0.5)

# 条件 涉及 4个方法：
#     con.acquire()
#     con.release()
#     con.wait()  # 假设有一个初始状态为False，阻塞。一旦接受到notify的信号后，变为True，不再阻塞
#     con.notify(int)  给wait发信号，发int个信号，会传递给int个wait，让int个线程正常执行

5、queue模块

from multiprocessing import Queue# 是用于多进程的队列，就是专门用来做进程间通信（IPC）。
import queue# 是用于同一进程内的队列，不能做多进程之间的通信

# q = queue.Queue()
# # 先进先出
# q.put(1)
# q.put(2)
# q.put(3)
# print(q.get())
# print(q.get())

# q = queue.LifoQueue()
# # 后进先出的队列
# q.put(1)
# q.put(2)
# q.put(3)
# print(q.get())

q = queue.PriorityQueue()
# 优先级队列，put()方法接收的是一个元组（），第一个位置是优先级，第二个位置是数据
# 优先级如果是数字，直接比较数值
# 如果是字符串，是按照 ASCII 码比较的。当ASCII码相同时，会按照先进先出的原则
q.put((1,'abc'))
q.put((5,'qwe'))
q.put((-5,'zxc'))
print(q.get())
print(q.get())
print(chr(48))