问题1 ：简述线程同步和异步的区别？
同步：指一个线程需要等待上一个线程执行完之后才开始执行。
异步：指一个线程不需要待上一个线程执行完之后就开始执行。
问题2 ：简述线程和进程的区别？
线程：
操作系统能够进行运算调度的最小单位。 它包含在进程之中，是进程的实际运作单位。 一条线程指的是进程中一个单一顺序的控制流， 一个进程中可以并发多个线程，每一条线程并行执行不同的任务。
进程：
对一堆资源的整合。 比如说QQ就是一个进程。
目的：最大限度的利用CPU,节省时间。
多线程并不会充分调用两个CPU，而是会在一个CPU上充分运转；
而多进程则是会完全调用两个CPU，同时执行；
并行：多个CPU同时执行多个任务，就好像有两个程序，这两个程序是真的在两个不同的CPU内同时被执行。
并发：CPU交替处理多个任务，还是有两个程序，但是只有一个CPU，会交替处理这两个程序，而不是同时执行，只不过因为CPU执行的速度过快，而会使得人们感到是在“同时”执行，执行的先后取决于各个程序对于时间片资源的争夺。
问题3 ：python如何开启一个进程？
知识点一：进程的理论
什么是进程？
进程是指一个程序在一个数据集上的动态执行过程(程序执行过程的抽象)
进程包含
- 程序：我们通过程序来描述一个进程所要执行的内容以及如何执行
- 数据集：数据集代表程序在执行过程中所需要的资源
- 进程控制块：用于描述进程的外部特征，记录进程的执行过程，系统可以用来控制/管理进程，也是操作系统感知进程存在的唯一标识
进程运行的的三种状态:
- 进程执行过程中出现IO，进入阻塞状态(操作系统强行剥夺CPU)
- 进程占用CPU时间过长/出现一个优先级更高的进程，进入就绪状态(CPU被剥夺)
- 就绪态的进程被分配到CPU，进入运行状态
- 阻塞态的进程出现有效输入，进入就绪态，等待操作系统分配CPU
此外，我们能直接控制的只有阻塞状态，减少阻塞，使进程尽可能的保持在就绪状态，提高效率
知识点二：开启进程的两种方式
开启进程：开启进程就是将父进程里面串行执行的程序放到子进程里，实现并发执行，这个过程中，会将父进程数据拷贝一份到子进程。
运行角度：是2个进程
注意：子进程内的初始数据与父进程的一样，如果子进程被创建或者被运行了，那么
子进程里面数据更改对父进程无影响，2个进程是存在运行的
方式一：通过调用multiprocessing模块下面的Process类方法
from multiprocessing import Process
def func(name):
print('%s is running...' % name)
print('%s is ending...' % name)
if __name__ == '__main__':
p = Process(target=func, args=('子进程',))
# 如果只有一个参数，args括号内一定要加逗号，确保以元组的形式传入
# 这一步：只是在向操作系统发我要开启一个子进程的信号（具体开子进程的操作是由操作系统来完成的）
p.start()
# 只是主进程给操作系统发送建立子进程的请求，并非立刻建立子进程
print('主进程')运行结果：主进程
子进程 is running...
子进程 is ending...方式二：借助process类，自定义一个类（继承Process），从而创造一个对象
定义process类的子类，并重写该类的run()方法，run()方法的中写进程需要完成的任务。
from multiprocessing import Process
class MyProcess(Process): # 继承Process类
def run(self): # run名字是固定的，不能更改
print("%s is running" % self.name) # 默认函数对象有name方法 ，结果为：Myprocess-1
print('%s is done' % self.name)
if __name__ == '__main__':
obj = MyProcess()
obj.start() # 本质上是在调用父类的start方法，而start方法下会触发run方法
print('主进程')运行结果：主进程
MyProcess-1 is running
MyProcess-1 is done为什么开启进程要在main内执行？
由于在windows系统下，子进程是通过导入模块的方式拿到父进程的代码，如果没有main会一直开启子进程，
而子进程的申请是需要开辟内存以及申请pid等的。
问题4：python如何开启一个线程？
方式一：通过thread类直接创建
import threading
def foo(n):
print('%s'%n)
def bar(n):
print('%s'%n)
print('33') # 主线程
t1 = threading.Thread(target=foo, args=(1,)) # 线程一
t2 = threading.Thread(target=bar, args=(2,)) # 线程二
t1.start()
t2.start()
# 创建线程，第一个参数是函数名字（不加括号，加括号就执行函数了）。
# 第二个参数是要传给函数的参数，以元组的形式。
# 创建线程之后， obj.start()启动线程。执行结果：33
1
2方式二：继承Thread类：
定义Thread类的子类，并重写该类的run()方法，run()方法的中写线程需要完成的任务。
import threading
# 定义MyThread类，其继承自threading.Thread这个父类
class MyThread(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
def run(self):
print("start t1")
print("end t1")
t1=MyThread() # 对类进行实例化
t1.start() # 启动线程
print("主线程")运行结果：start t1
end t1
主线程补充：Thread类的一些常用方法
- join(): 在子线程完成之前，主线程将一直被阻塞
- setDaemon(True) 方法: 将进程声明为守护线程，必须在
start()方法调用之前
问题5：线程之间如何通信？
方式一：threading.Event 事件
Python提供了非常简单的通信机制 Threading.Event，通用的条件变量(event.isSet==False/True)。多个线程可以等待某个事件的发生，在事件发生后，所有的线程都会被激活。
关于Event的使用，就四个函数：
event = threading.Event()
• event.isSet() # 返回event的状态值。
• event.wait() # 等待接收event的状态值，决定是否阻塞程序执行。如果event.isSet==False,将阻塞线程。
• event.set() # 设置event的状态值为True，使所有设置该event事件的线程执行。
• event.clear() # 重置event的状态值为False，使得所有该event事件都处于待命状态。举个例子：
import time
import threading
class MyThread(threading.Thread):
def __init__(self, name, event):
super().__init__()
self.name = name
self.event = event
def run(self):
print('Thread: {} start at {}'.format(self.name, time.ctime(time.time())))
# 等待event.set()后，才能往下执行
self.event.wait()
print('Thread: {} finish at {}'.format(self.name, time.ctime(time.time())))
threads = []
event = threading.Event()
# 定义三个线程，使用event事件
[threads.append(MyThread(str(i), event)) for i in range(1, 4)]
# 重置event，使得event.wait()起到阻塞作用
event.clear()
# 启动所有线程
[t.start() for t in threads]
print('等待5s...')
time.sleep(5)
print('唤醒所有线程...')
event.set()执行结果：Thread: 1 start at Fri Jul 12 15:05:50 2019
Thread: 2 start at Fri Jul 12 15:05:50 2019
Thread: 3 start at Fri Jul 12 15:05:50 2019
等待5s...
唤醒所有线程...
Thread: 3 finish at Fri Jul 12 15:05:55 2019
Thread: 2 finish at Fri Jul 12 15:05:55 2019
Thread: 1 finish at Fri Jul 12 15:05:55 2019可见在所有线程都启动 start() 后，并不会执行完，而是都在self.event.wait()阻塞了，需要通过event.set()来给所有线程发送执行指令才能往下执行。
方式二：threading.Condition条件
Condition和Event 是类似的，并没有多大区别。
Condition需要掌握几个函数：
cond = threading.Condition() # 创建一个cond条件 , 默认锁为 Rlock.
• cond.acquire() # 类似lock.acquire()
• cond.release() # 类似lock.release()
• cond.wait() # 等待指定触发，同时会释放锁,直到被notify才重新占有琐。
• cond.notify() # 发送指定，触发执行一个线程
• cond.notifyAll() # 发送指定，触发执行所有线程举个生产消费的例子：
import threading
import time
from random import randint
class Producer(threading.Thread):
def run(self):
global L
while True:
val=randint(0,100)
print('生产者',self.name,":Append"+str(val), L)
if lock_con.acquire():
L.append(val)
lock_con.notify()
lock_con.release()
time.sleep(3)
class Consumer(threading.Thread):
def run(self):
global L
while True:
lock_con.acquire()
if len(L)==0:
lock_con.wait()
print('消费者',self.name,":Delete"+str(L[0]),L)
del L[0]
lock_con.release()
time.sleep(0.25)
if __name__=="__main__":
L=[]
lock_con=threading.Condition()
threads=[]
for i in range(5):
threads.append(Producer())
threads.append(Consumer())
for t in threads:
t.start()
for t in threads:
t.join()执行结果：生产者 Thread-1 :Append48 []
生产者 Thread-2 :Append9 [48]
生产者 Thread-3 :Append73 [48, 9]
生产者 Thread-4 :Append11 [48, 9, 73]
生产者 Thread-5 :Append94 [48, 9, 73, 11]
消费者 Thread-6 :Delete48 [48, 9, 73, 11, 94]
消费者 Thread-6 :Delete9 [9, 73, 11, 94]
消费者 Thread-6 :Delete73 [73, 11, 94]
消费者 Thread-6 :Delete11 [11, 94]
消费者 Thread-6 :Delete94 [94]可见通过cond来通信，阻塞自己，并使对方执行。
方式三：queue.Queue队列
从一个线程向另一个线程发送数据最安全的方式可能就是使用 queue 库中的队列了。
创建一个被多个线程共享的 Queue 对象，这些线程通过使用put() 和 get() 操作来向队列中添加或者删除元素。
队列需要掌握的函数：
q = Queue(maxsize=0) # maxsize默认为0，不受限。
- q.get() # 阻塞程序，等待队列消息。
- q.get(timeout=5.0) # 获取消息，设置超时时间。
- q.put() # 发送消息。
- q.join() # 等待所有的消息都被消费完。
举一个老师点名的例子：
from threading import Thread
from queue import Queue
import time
class Student(Thread):
def __init__(self, name, queue):
super().__init__()
self.name = name
self.queue = queue
def run(self):
while True:
# 阻塞程序，时刻监听老师，接收消息
msg = self.queue.get()
# 一旦发现点到自己名字，就赶紧答到
if msg == self.name:
print("{}：到！".format(self.name))
class Teacher:
def __init__(self, queue):
self.queue = queue
def call(self, student_name):
print("老师：{}来了没？".format(student_name))
# 发送消息，要点谁的名
self.queue.put(student_name)
queue = Queue()
teacher = Teacher(queue=queue)
s1 = Student(name="小明", queue=queue)
s2 = Student(name="小亮", queue=queue)
s1.start()
s2.start()
print('开始点名~')
teacher.call('小明')
time.sleep(1)
teacher.call('小亮')总结：
学习了以上三种通信方法，我们很容易就能发现Event 和 Condition 是threading模块原生提供的模块，原理简单，功能单一，它能发送 True 和 False 的指令，所以只能适用于某些简单的场景中。
而Queue则是比较高级的模块，它可能发送任何类型的消息，包括字符串、字典等。其内部实现其实也引用了Condition模块（譬如put和get函数的阻塞），正是其对Condition进行了功能扩展，所以功能更加丰富，更能满足实际应用。
问题6：进程之间如何通信？
方式一：Queue队列，用于多个进程间实现通信
一个进程向 Queue 中放入数据，另一个进程从 Queue 中读取数据。
multiprocessing 模块下的 Queue 和 queue 模块下的 Queue 基本类似，它们都提供了 qsize()、empty()、full()、put()、put_nowait()、get()、get_nowait() 等方法。
区别只是 multiprocessing 模块下的 Queue 为进程提供服务，而 queue 模块下的 Queue 为线程提供服务。
from queue import Queue # 为线程提供服务
from multiprocessing import Queue # 为进程提供服务举个例子：
import multiprocessing
def fun(que):
print('(%s) 进程开始放入数据...' % multiprocessing.current_process().pid)
que.put('Python') # 向 Queue 中放入数据
if __name__ == '__main__':
que = multiprocessing.Queue() # 创建进程通信的Queue
p = multiprocessing.Process(target=fun, args=(que,)) # 创建子进程
p.start() # 启动子进程
print('(%s) 进程开始取出数据...' % multiprocessing.current_process().pid) # 先走主进程
print(que.get()) # 从 Queue 中读取数据执行结果：(6364) 进程开始取出数据...
(12716) 进程开始放入数据...
Python方式二：Pipe管道，用于两个进程的通信
使用 Pipe 实现进程通信，程序会调用 multiprocessing.Pipe() 函数来创建一个管道，该函数会返回两个 PipeConnection 对象，代表管道的两个连接端，用于连接通信的两个进程。
PipeConnection 对象包含如下常用方法：
• send(obj)：发送一个 obj 给管道的另一端，另一端使用 recv() 方法接收。
• recv()：接收另一端通过 send() 方法发送过来的数据。
• fileno()：关于连接所使用的文件描述器。
• close()：关闭连接。
• poll([timeout])：返回连接中是否还有数据可以读取。
• send_bytes(buffer[, offset[, size]])：发送字节数据。
• recv_bytes([maxlength])：接收通过 send_bytes() 方法发迭的数据，maxlength 指定最多接收的字节数。
• recv_bytes_into(buffer[, offset])：功能与 recv_bytes() 方法类似，只是该方法将接收到的数据放在 buffer 中。举一个例子：
import multiprocessing
def f(conn):
print('(%s) 进程开始发送数据...' % multiprocessing.current_process().pid)
# 使用conn发送数据
conn.send('Python')
if __name__ == '__main__':
parent_conn, child_conn = multiprocessing.Pipe() # 创建Pipe，该函数返回两个PipeConnection对象
p = multiprocessing.Process(target=f, args=(child_conn, )) # 创建子进程
p.start()
print('(%s) 进程开始接收数据...' % multiprocessing.current_process().pid)
# 通过conn读取数据
print(parent_conn.recv()) # Python
p.join()执行结果：(13796) 进程开始接收数据...
(14792) 进程开始发送数据...
Python
