进程之间的相互通信、生产者消费者模型、线程以及创建方式、线程对象以及常用的方法、守护线程、

有关于人工智能一些高端功能的网站：

1、百度api

http://ai.baidu.com/?track=cp:ainsem|pf:pc|pp:tongyong-pinpai|pu:pinpai-baiduAI|ci:|kw:10003812

2、科大讯飞（语音方面很专业）

https://www.xfyun.cn/?ch=bdtg&renqun_youhua=646957

3、图灵机器人

http://www.turingapi.com/

进程之间的相互通信：

队列:先进先出

堆栈:先进后出

代码理解队列:

from multiprocessing import Queue
q = Queue(5)  # 括号内可以传参数 表示的是这个队列的最大存储数
# 往队列中添加数据
q.put(1)
q.put(2)
# print(q.full())  # 判断队列是否满了
q.put(3)
q.put(4)
q.put(5)
# print(q.full())
# q.put(6)  # 当队列满了之后 再放入数据 不会报错 会原地等待 直到队列中有数据被取走(阻塞态)
print(q.get())
print(q.get())
print(q.get())
print(q.empty())  # 判断队列中的数据是否取完
print(q.get())
print(q.get())
print(q.empty())
# print(q.get_nowait())  # 取值 没有值不等待直接报错
# print(q.get())  # 当队列中的数据被取完之后 再次获取 程序会阻塞 直到有人往队列中放入值
"""
full
get_nowait
empty
都不适用于多进程的情况
"""

进程间通信的ipc机制：

from multiprocessing import Process,Queue

def producer(q):
    q.put('hello GF~')

def consumer(q):
    print(q.get())

if __name__ == '__main__':
    q = Queue()
    p = Process(target=producer,args=(q,))
    c = Process(target=consumer, args=(q,))
    p.start()
    c.start()


"""
子进程放数据 主进程获取数据
两个子进程相互放 取数据
"""

生产者消费者模型：

"""
生产者:生产/制造数据的
消费者:消费/处理数据的
例子:做包子的,买包子的
        1.做包子远比买包子的多
        2.做包子的远比包子的少
        供需不平衡的问题
"""
from multiprocessing import Process,Queue,JoinableQueue
import random
import time


def producer(name,food,q):
    for i in range(10):
        data = '%s生产了%s%s'%(name,food,i)
        time.sleep(random.random())
        q.put(data)
        print(data)

def consumer(name,q):
    while True:
        data = q.get()
        if data == None:break
        print('%s吃了%s'%(name,data))
        time.sleep(random.random())
        q.task_done()  # 告诉队列你已经从队列中取出了一个数据 并且处理完毕了



if __name__ == '__main__':
    q = JoinableQueue()
    p = Process(target=producer,args=('大厨egon','馒头',q))
    p1 = Process(target=producer,args=('跟班tank','生蚝',q))
    c = Process(target=consumer,args=('许兆龙',q))
    c1 = Process(target=consumer,args=('吃货jerry',q))
    p.start()
    p1.start()
    c.daemon = True
    c1.daemon = True
    c.start()
    c1.start()
    p.join()
    p1.join()

    q.join()  # 等到队列中数据全部取出
    # q.put(None)
    # q.put(None)

线程：

什么是线程

    进程线程其实都是虚拟单位,都是用来帮助我们形象的描述某种事物
    进程:资源单位
    线程:执行单位
        将内存比如成工厂
        那么进程就相当于是工厂里面的车间
        而你的线程就相当于是车间里面的流水线
    ps:每个进程都自带一个线程,线程才是真正的执行单位,进程只是在线程运行过程中
    提供代码运行所需要的资源
为什么要有线程
    开进程
        1.申请内存空间  耗资源
        2."拷贝代码"    耗资源
    一个进程内可以起多个线程,并且线程与线程之间数据是共享的
    ps:开启线程的开销要远远小于开启进程的开销

线程的两种创建方式：

方式一：

# from threading import Thread
# import time
#
# def task(name):
#     print('%s is running'%name)
#     time.sleep(3)
#     print('%s is over'%name)
# # 开线程不需要在__main__代码块内 但是习惯性的还是写在__main__代码块内
# t = Thread(target=task,args=('egon',))
# t.start()  # 告诉操作系统开辟一个线程  线程的开销远远小于进程
# # 小的代码执行完 线程就已经开启了
# print('主')

方式二：

from threading import Thread
import time

class MyThread(Thread):
    def __init__(self,name):
        super().__init__()
        self.name = name

    def run(self):
        print('%s is running'%self.name)
        time.sleep(3)
        print('%s is over'%self.name)

t = MyThread('egon')
t.start()
print('主')

线程对象以及常用的方法：

from threading import Thread,current_thread,active_count
import time
import os

def task(name,i):
    print('%s is running'%name)
    print('子current_thread:', current_thread().name)
    print('子',os.getpid())
    time.sleep(i)

    print('%s is over'%name)
# 开线程不需要在__main__代码块内 但是习惯性的还是写在__main__代码块内
t = Thread(target=task,args=('egon',1))
t1 = Thread(target=task,args=('jason',2))
t.start()  # 告诉操作系统开辟一个线程  线程的开销远远小于进程
t1.start()  # 告诉操作系统开辟一个线程  线程的开销远远小于进程
t1.join()  # 主线程等待子线程运行完毕再执行
#因为这个代码需要等t1运行完毕才执行，所以当在等t1执行结束的过程中t也运行结束所以活跃数为1
print('当前正在活跃的线程数',active_count())
# 小的代码执行完 线程就已经开启了，所以不是先打印主
print('主')
print('主current_thread:',current_thread().name)
print('主',os.getpid())

守护线程：

即当主线程结束时，设置的守护子线程也会结束。

daemon：需要设置在start之前。

守护进程的小例子：加深理解！

from threading import Thread
from multiprocessing import Process
import time


def foo():
    print(123)
    time.sleep(1)
    print("end123")


def bar():
    print(456)
    time.sleep(3)
    print("end456")


"""
因为主线程需要等待其他非守护线程结束才能结束，
所以当t1被设置为守护线程之后，
理论上当主线程打印完毕后就结束了运行了，不会运行sleep后的代码了
但是这个时候t2（非守护线程）的运行并没有结束，所以主线程也不会结束
所以线程t1也继续运行。
"""

if __name__ == '__main__':
    t1 = Thread(target=foo)
    t2 = Thread(target=bar)
    t1.daemon = True
    t1.start()
    t2.start()
    print("main-------")

from threading import Thread,current_thread
import time


def task(i):
    print(current_thread().name)
    time.sleep(i)
    print('GG')


for i in range(3):
    t = Thread(target=task,args=(i,))
    # 设置为守护线程后，主线程结束，子线程立马结束。
    t.daemon = True
    t.start()
print('主')

# t = Thread(target=task,args=(1,))
# t.daemon = True
# t.start()
# print('主')
# 主线程运行结束之后需要等待子线程结束才能结束呢?
"""
主线程的结束也就意味着进程的结束
主线程必须等待其他非守护线程的结束才能结束
(意味子线程在运行的时候需要使用进程中的资源,而主线程一旦结束了资源也就销毁了)
"""

线程之间的数据是共享的:

验证代码：

from threading import Thread
money = 666
def task():
    global money
    money = 999
t = Thread(target=task)
t.start()
t.join()
print(money)

互斥锁：

from threading import Thread,Lock
import time
"""
在不设置互斥锁时，100个线程同时运行，
每个线程得到的数字n都是100，都进行减一，所以结果为99
当多个线/进程去处理一个数据时会发生错乱时，需要加锁
设置互斥锁之后，锁只需要加在处理数据的部分，100个线程之间进行抢锁，
使并发变成了串行，降低了效率，提高了数据的安全性。所以结果变为了0
"""

n = 100

def task(mutex):
    global  n
    mutex.acquire()
    tmp = n
    time.sleep(0.1)
    n = tmp - 1
    mutex.release()

t_list = []
mutex = Lock()
for i in range(100):
    t = Thread(target=task,args=(mutex,))
    t.start()
    t_list.append(t)
for t in t_list:
    t.join()
print(n)