什么是防火墙以及作用?
# 答案:
'''
在互联网上防火墙是一种非常有效的网络安全模型，通过它可以隔离风险区域(即Internet或有一定风险的网络)与安全区域(局域网)的连接，同时不会妨碍人们对风险区域的访问。所以它一般连接在核心交换机与外网之间。
1.过滤进出网络的数据
2.2.管理进出访问网络的行为
3.3.封堵某些禁止业务
4.4.记录通过防火墙信息内容和活动
5.5.对网络攻击检测和告警
'''
select、poll、epoll模型的区别?
# 答案:
'''
I/O多路复用的本质就是用select/poll/epoll，去监听多个socket对象，如果其中的socket对象有变化，只要有变化，用户进程就知道了。
select是不断轮询去监听的socket，socket个数有限制，一般为1024个；
poll还是采用轮询方式监听，只不过没有个数限制；
epoll并不是采用轮询方式去监听了，而是当socket有变化时通过回调的方式主动告知用户进程。
'''
简述进程、线程、协程的区别以及应用场景?
# 答案:
'''
1.进程是操作系统资源分配的最小单位，拥有独立的资源和地址空间
2.线程是CPU调度的单位
3.统一进程中的线程是资源共享的。
4.协程是用户级别的，程序之间的切换由用户自行处理，节省了CPU的调度时间。
'''
什么是GIL锁?
# 答案:
'''
全局解释锁，每次只能一个线程获得cpu的使用权：为了线程安全，也就是为了解决多线程之间的数据完整性和状态同步而加的锁，因为我们知道线程之间的数据是共享的。
'''
Python中如何使用线程池和进程池?
# 答案:
# 线程池
import threadpool, time
with open(r'../uoko_house_id.txt', 'r', encoding='utf-8') as f: # with open语句表示通用的打开文件的方式，此处用来获取需要爬取参数的列表
roomIdLi = f.readlines()
roomIdList =[x.replace('\n','').replace(' ','') for x in roomIdLi]
print(roomIdList)
li = [[i, item] for i, item in enumerate(roomIdList)] # enumerate()将列表中元素和其下标重新组合输出
def run(roomId):
"""对传入参数进行处理"""
print('传入参数为：', roomId)
time.sleep(1)
def main():
roomList = li # 房间信息
start_time = time.time()
print('启动时间为：', start_time)
pool = threadpool.ThreadPool(10)
requests = threadpool.makeRequests(run, roomList)
[pool.putRequest(req) for req in requests]
pool.wait()
print("共用时:", time.time()-start_time)
if __name__ == '__main__':
main()
# 进程池
from multiprocessing.pool import Pool
from time import sleep
def fun(a):
sleep(5)
print(a)
if __name__ == '__main__':
p = Pool()
for i in range(10):
p.apply_async(fun, args= (i, ))
p.close()
p.join()
print("end")
threading.local的作用?
# 答案:
# 为每个线程创建一个独立的空间，使得线程对自己的空间中的数据进行操作（数据隔离）。
import threading
from threading import local
import time
obj = local()
def task(i):
obj.xxxxx = i
time.sleep(2)
print(obj.xxxxx,i)
for i in range(10): #开启了10个线程
t = threading.Thread(target=task,args=(i,))
t.start()
进程之间如何进行通信?
# 答案:
# python提供了多种进程通信的方式，主要Queue和Pipe这两种方式，Queue用于多个进程间实现通信，Pipe是两个进程的通信。
# Queue
from multiprocessing import Process, Queue
import os,time,random
#写数据进程执行的代码
def proc_write(q,urls):
print 'Process is write....'
for url in urls:
q.put(url)
print 'put %s to queue... ' %url
time.sleep(random.random())
#读数据进程的代码
def proc_read(q):
print('Process is reading...')
while True:
url = q.get(True)
print('Get %s from queue' %url)
if __name__ == '__main__':
#父进程创建Queue，并传给各个子进程
q = Queue()
proc_write1 = Process(target=proc_write,args=(q,['url_1','url_2','url_3']))
proc_write2 = Process(target=proc_write,args=(q,['url_4','url_5','url_6']))
proc_reader = Process(target=proc_read,args=(q,))
#启动子进程，写入
proc_write1.start()
proc_write2.start()
proc_reader.start()
#等待proc_write1结束
proc_write1.join()
proc_write2.join()
#proc_raader进程是死循环，强制结束
proc_reader.terminate()
# PIPE
import multiprocessing
import os,time,random
#写数据进程执行的代码
def proc_send(pipe,urls):
#print 'Process is write....'
for url in urls:
print 'Process is send :%s' %url
pipe.send(url)
time.sleep(random.random())
#读数据进程的代码
def proc_recv(pipe):
while True:
print('Process rev:%s' %pipe.recv())
time.sleep(random.random())
if __name__ == '__main__':
#父进程创建pipe，并传给各个子进程
pipe = multiprocessing.Pipe()
p1 = multiprocessing.Process(target=proc_send,args=(pipe[0],['url_'+str(i) for i in range(10) ]))
p2 = multiprocessing.Process(target=proc_recv,args=(pipe[1],))
#启动子进程，写入
p1.start()
p2.start()
p1.join()
p2.terminate()
什么是并发和并行?
# 答案:
# 并发：同一时刻只能处理一个任务，但可以交替处理多个任务。(一个处理器同时处理多个任务)
# 并行：同一时刻可以处理多个任务。(多个处理器或者是多核的处理器同时处理多个不同的任务)
# 类比：并发是一个人同时吃三个馒头，而并行是三个人同时吃三个馒头。
同步和异步，阻塞和非阻塞的区别？
# 答案:
'''
同步：执行一个操作之后，需要主动等待返回结果；
异步：执行一个操作之后，不需要主动等待返回结果，若接收到结果通知，再回来执行刚才没执行完的操作。
同步和异步关心的问题是：要不要主动等待结果。
阻塞：在执行一个操作时，不能做其他操作；
非阻塞：在执行一个操作时，能做其他操作。
阻塞和非阻塞关心的问题是：能不能做其他操作。
'''
路由器和交换机的区别?
# 答案:
'''
1：交换机：是负责内网里面的数据传递（arp协议）根据MAC地址寻址。
路由器：在网络层，路由器根据路由表，寻找该ip的网段。
2：路由器可以把一个IP分配给很多个主机使用，这些主机对外只表现出一个IP。
交换机可以把很多主机连起来，这些主机对外各有各的IP。
3：交换机是做端口扩展的，也就是让局域网可以连进来更多的电脑。
路由器是用来做网络连接，也就是连接不同的网络。
'''
