进程
1、进程间内存是否共享？如何实现通讯？
不能共享 ,通过ipc 机制,管道队列实现
2、请聊聊进程队列的特点和实现原理？
先进先出.后进后出的特点. 实现原理是管道加pickel
3、请画出进程的三状态转换图
就绪 运行
阻塞
4、你了解生产者模型消费者模型么？如何实现？
from mu......ing import Proess
from mu...ing import Queue
def Prouter(q,food_name):
for i in rang(10):
food ='%s,%s'%(food_name,i)
print('生产了%s'%food')
q.put(food)
def Couster(q,name):
while 1:
food =q.get()
if not food:break
print('%s吃了%s'%(name,food))
q =Queque(5)
p1 =Process(targer=Product ,args =(q,'baozi'))
p2 =Process(targer=Product ,args =(q,'jiaozi'))
c1 =Process(targer=Couster,args=((q,''libai')))
c2 =Process(targer=Couster,args=((q,''dufu')))
p1.start()
p2.start()
c1.start()
c2.start()
p1.join()
p2.join()
q.put(None)
q.put(None)
5、从你的角度说说进程在计算机中扮演什么角色？
进程是计算机中最小的资源分配单位
线程
1、GIL锁是怎么回事?
GIL锁是线程中的全局解释器,保证同一时刻只能允许一个线程运行,以此来控制同一时间内共享数据只能被一个任务所修改，进而保证数据安全。
2、在python中是否线程安全？
安全
3、什么叫死锁？
多个进程在运行过程中----抢夺资源而造成的一种僵局
如果没有外力推进-----处于僵局中的进程无法继续进行
导致死锁的4个必要条件：
互斥。一次------只有一个进程----可以使用一个资源
不可抢占。不能抢占---进程已经占有的资源
循环等待。存在封闭的进程链---每个进程----此链中---下一个进程需要的资源
占有且等待。一个进程等待其他进程---继续占有----已经分配到的资源
4、logging模块是否是线程安全的？
安全
5、threading.local的作用？
线程中保证数据独立
6、程序从flag a执行到falg b的时间大致是多少秒？
import threading
import time
def _wait():
time.sleep(60)
# flag a
t = threading.Thread(target=_wait,daemon = False)
t.start()
# flag b
小于1m
7、程序从flag a执行到falg b的时间大致是多少秒？
import threading
import time
def _wait():
time.sleep(60)
# flag a
t = threading.Thread(target=_wait,daemon = True)
t.start()
# flag b
小于1秒
8、程序从flag a执行到falg b的时间大致是多少秒？
import threading
import time
def _wait():
time.sleep(60)
# flag a
t = threading.Thread(target=_wait,daemon = True)
t.start()
t.join()
# flag b
大于60miao
9、读程序，请确认执行到最后number是否一定为0
import threading
loop = int(1E7)
def _add(loop:int = 1):
global number
for _ in range(loop):
number += 1
def _sub(loop:int = 1):
global number
for _ in range(loop):
number -= 1
number = 0
ta = threading.Thread(target=_add,args=(loop,))
ts = threading.Thread(target=_sub,args=(loop,))
ta.start()
ts.start()
ta.join()
ts.join()
10、读程序，请确认执行到最后number是否一定为0
import threading
loop = int(1E7)
def _add(loop:int = 1):
global number
for _ in range(loop):
number += 1
def _sub(loop:int = 1):
global number
for _ in range(loop):
number -= 1
number = 0
ta = threading.Thread(target=_add,args=(loop,))
ts = threading.Thread(target=_sub,args=(loop,))
ta.start()
ta.join()
ts.start()
ts.join()
11、读程序，请确认执行到最后number的长度是否一定为1
import threading
loop = int(1E7)
def _add(loop:int = 1):
global numbers
for _ in range(loop):
numbers.append(0)
def _sub(loop:int = 1):
global number
while not numbers:
time.sleep(1E-8)
numbers.pop()
number = [0]
ta = threading.Thread(target=_add,args=(loop,))
ts = threading.Thread(target=_sub,args=(loop,))
ta.start()
ta.join()
ts.start()
ts.join()
12、读程序，请确认执行到最后number的长度是否一定为1
import threading
loop = int(1E7)
def _add(loop:int = 1):
global numbers
for _ in range(loop):
numbers.append(0)
def _sub(loop:int = 1):
global number
while not numbers:
time.sleep(1E-8)
numbers.pop()
number = [0]
ta = threading.Thread(target=_add,args=(loop,))
ts = threading.Thread(target=_sub,args=(loop,))
ta.start()
ts.start()
ta.join()
ts.join()
协程
1、什么是协程？常用的协程模块有哪些？
协程是一种用户态的轻量级线程，协程的调度完全由用户控制。
greenlet
gevent
2、协程中的join是用来做什么用的？它是如何发挥作用的？
等待开启的协成结束
3、使用协程实现并发的tcp server端
import socket
from gevent import monkey
monkey.patch_all()
import gevent
def talk(conn):
while True:
msg = conn.recv(1024).decode()
conn.send(msg.upper().encode('utf-8'))
sk =socket.socket()
sk.bind(('127.0.0.1',8500))
sk.listen()
while True:
conn,addr = sk.accept()
gevent.spawn(talk,conn)
4、在一个列表中有多个url，请使用协程访问所有url，将对应的网页内容写入文件保存
from gevent import monkey
monkey.patch_all()
import gevent
from urllib import request
import time
def func(name,url):
ret = request.urlopen(url)
with open(name+'2.html','wb')as f:
f.write(ret.read())
url_lst = [
('python','https://www.python.org/'),
('blog','http://www.cnblogs.com/Eva-J/articles/8324673.html'),
('pypi','https://pypi.org/project/pip/'),
('blog2','https://www.cnblogs.com/z-x-y/p/9237706.html'),
('douban','https://www.douban.com/')
]
start = time.time()
g_list =[]
for url_item in url_lst:
g = gevent.spawn(func,*url_item)
g_list.append(g)
gevent.joinall(g_list)
end = time.time()
print('协程打开方式',end-start)
综合
1、进程和线程的区别
1、每启动一个进程，进程内都至少有一个线程。
2、进程本身只是一个资源单位，并不能真正执行，进程内开的线程才是真正的运行单位。
3、一个进程内可以启动多个线程，同一进程内线程间共享资源。
4、启线程的开销远远小于开进程。
5、线程可以相当程度控制相同进程下的线程，进程只能控制其子进程。
6、对主线程的更改（取消、优先级更改等）可能会进程的其他线程的行为；对父进程的修改则不会影响子进程。
2、进程池、线程池的优势和特点
进程池:节省进程资源,速度比进程快
线程池:速度比线程快.提高线程的可管理性,提高响应速度
3、线程和协程的异同?
协程是一种用户态的轻量级线程，协程的调度完全由用户控制。
协程与线程区别：
1、必须在只有一个单线程里实现并发
2、线程进程都是同步机制，而协程则是异步
3、修改共享数据不需加锁（本质是一个一个执行，因此不需要考虑加锁）
4、协程能保留上一次调用时的状态，每次过程重入时，就相当于进入上一次调用的状态（自己控制切换）
4、请简述一下互斥锁和递归锁的异同？
互斥锁lock为资源引入一个状态：锁定/非锁定。某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。
RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源
5、请列举一个python中数据安全的数据类型？
6、Python中如何使用线程池和进程池
import os
import time
from multiprocessing import Pool
def fun1(i):
time.sleep(1)
print(i,os.getpid())
if __name__ == '__main__':
p =Pool(4)
for i in range(10):
p.apply_async(fun1,args=(i,))
p.close()
p.join()
from threading import current_thread
from concurrent.futures import ThreadPoolExecutor
import time
def fun1(i):
time.sleep(1)
print('子线程%s'%i,current_thread().ident)
return i**2
tp =ThreadPoolExecutor(4)
rel_1 =[]
for i in range(20):
ret =tp.submit(fun1,i)
rel_1.append(ret)
for i in rel_1:
print(i.result())
7、简述 进程、线程、协程的区别 以及应用场景？
8、什么是IO多路复用及其作用
9、select、poll、epoll 模型的区别？
10、什么是并行，什么是并发？
-
并发是指一个处理器同时处理多个任务，看起来多个进程像在同时运行
-
并行是指多个处理器或者是多核的处理器同时处理多个不同的任务。
11、请解释同步和异步这两个概念？
12、请谈谈对异步非阻塞的了解？
13、简述信号量的实现原理
14、程序中的阻塞有哪些？给程序带来了哪些影响？
15、请分别用多进程、多线程、协程实现生产者消费者模型？
