#__author : 'liuyang'

#date : 2019/4/16 0016 上午 11:32

# 多进程之间的数据是隔离的

# 进程之间的数据交互

# 是可以通过网络/文件来实现的

# socket 来实现

# IPC   inter process communication

        # 多个进程之间的通信

  #通过python的模块实现的

    # 基于原生socket

    # 基于进程队列的   *****

  #第三方的软件/工具来实现：

    # 不需要写socket（写好了）

    # 需要安装

    #memcache  redis  rabbitMQ  kafka

#  网络

def son():

    pass

from multiprocessing import Queue   #可以完成进程之间的通信的特殊的队列

# from queue import Queue  #不能完成进程之间的通信

# q = Queue()

# q.put(1)

# q.put(2)

# print(q.get())

# print(q.get())

#

from multiprocessing import Queue,Process

# def son(q):

#     print(q.get())

# if __name__ == '__main__':

#     q = Queue()

#     Process(target=son,args=(q,)).start()

#     # Process

#     q.put('wahah')

#生产者消费者模型

    #python 程序

    #模仿浏览器去访问一个网页

    #urllib.urlopen(url)

# 开多线程  同样的时间 可以爬更多的网站

# 紧耦合  松耦合 ？（包一个包子 买一个包子）（包很多包子 买很多包子）

# 获得数据  生产者

# 处理数据  消费者

# 调节生产者的个数或者消费者的个数让程序的效率达到最平衡和最大化

# 解耦思想

import time

import random

# def producer(q):        #爬虫

#     for i in range(10):

#         time.sleep(random.random())#爬虫的时间

#         food = '泔水%s'%i

#         print('%s 生产了 %s'%('taibai',food))

#         q.put(food)

#     # num = random.randint(1,100)

#     # print('producer 生产了一个数据%s'%num,)

#         q.put(food)

# def consumer(q,name):

#     while True:         # 处理数据

#         food = q.get()    # food = shiwu / None

#         if  not food : break

#         time.sleep(random.uniform(1,2))  #处理数据再短也要处理一会

#         print('%s 吃了 %s '%(name,food))

    # num = q.get()

    # print('消费者受到了一个%s'%num)

# if __name__ == '__main__':

#     q = Queue()

#     p1 = Process(target=producer,args=(q,))

#     p1.start()

#     c1 = Process(target=consumer,args=(q,'alex'))

#     c1.start()

#     c2 = Process(target=consumer,args=(q,'wusir'))

#     c2.start()

#     p1.join()         #阻在这里

#     q.put(None)       #传过去None  判断退出

#     q.put(None)

from multiprocessing import JoinableQueue,Process

# 放任务   取任务

#生产数据    放进来  计数器  加 1

        # q.join()  阻塞  直到为零

#反回 一个消息 q.task_done

def consumer(jq,name):

    while True:  # 处理数据

        food = jq.get()

        # if  food : break

        time.sleep(random.uniform(1,2))  #处理数据再短也要处理一会

        print('%s 吃了 %s '%(name,food))

        jq.task_done()

def producer(jq):        #爬虫

    for i in range(10):

        time.sleep(random.random())#爬虫的时间

        food = '泔水%s'%i

        print('%s 生产了 %s'%('taibai',food))

        jq.put(food)

    jq.join()

if __name__ == '__main__':

    jq = JoinableQueue()

    c1 = Process(target=consumer,args = (jq,'alex'))

    p1 = Process(target=producer,args = (jq,))

    c1.daemon = True

    c1.start()

    p1.start()

    p1.join()

# consumer 所有数据消费完

# 队列join 结束

# producer 继承结束

# p1 进程阻塞结束

# 主进程的代码结束

# 守护进程结束

# 锁  同一时刻 同一段代码， 只能有一个进程来执行这段代码

    #保证数据的安全

    #多进程中，只有去操作一些，进程之间可以共享的数据资源的时候才需要枷锁

    #lock = Lock()

    #acquire()   release

    #with lock :

    #Lock  互斥锁

# 队列

    #IPC

        #PUT

        #GET

    # 生产者消费者模型 基于队列把生产者和消费者数据的过程分开了

    #补充：

        #队列  是进程安全的（自带了锁）   ：一个人来取得时候不会有另个人来

        ##AttributeError: module 'socket' has no attribute 'socket

        #队列 基于什么实现的 文件家族的socket服务

        # 基于文件家族的socket 服务实现的ipc不止一个,管道pipe

                                #pipe  会出现安全问题 没带锁

        # 队列 = 管道+锁

        #管道 是基于文件家族的socket 服务实现

from multiprocessing import Pipe

#__author : 'liuyang'

#date : 2019/4/16 0016 上午 10:31

# 抢票  的   多台机器服务  （请求票的时候有可能信息修改了） #票的信息都存到一个大的

    #

from multiprocessing import Process

import json

import time

        # 数据的安全性  一张票  被很多个人买了

def search_ticket(name):

    with open('ticket',encoding='utf-8')as f:

        dic = json.load(f)

        print('%s查询余票为%s'%(name,dic['count']))

# def buy_ticket(name):

#     with open('ticket', encoding='utf-8')as f:

#         dic = json.load(f)

#     time.sleep(0.2)

#     if dic['count'] >= 1 :

#         print('%s买到票了'%name)

#         dic['count'] -= 1

#         time.sleep(0.2)

#         with open('ticket', encoding='utf-8')as f:

#             # dic = json.load

#     else:

#         print('没了')

#十个人同时查票

def user(name):

    #不涉及买  随便 并发

    search_ticket(name)

    # buy_ticket(name)

    # with 还会处理异常 前一个 出错了 以后的都可以释放  跳出异常

        # 不等了

if __name__ == '__main__':

    l = ['alex','b','c']

    for name in l:

        search_ticket(name)

        # p = Process(target=search_ticket,args=(name,))

        # p.start()

# 1. 牺牲了效率  ，保证了数据安全  关闭了 多进程 异步  并发

            #  在数据安全面前 效率不值一提 （和钱打交道的app都巨慢）

            #  不涉及钱的 可以 牺牲一点安全

#2 用户就觉得 很慢 体验很差.

#  join()  是同步 加单道了  一个个执行

# 锁的应用场景

#     # 内存里还有   子进程结束 子进程没了   变量  join 加入内存里了

#__author : 'liuyang'

#date : 2019/4/16 0016 上午 10:31

# 抢票  的   多台机器服务  （请求票的时候有可能信息修改了） #票的信息都存到一个大的

    #

from multiprocessing import Process

import json

import time

        # 数据的安全性  一张票  被很多个人买了

def search_ticket(name):

    with open('ticket',encoding='utf-8')as f:

        dic = json.load(f)

        print('%s查询余票为%s'%(name,dic['count']))

# def buy_ticket(name):

#     with open('ticket', encoding='utf-8')as f:

#         dic = json.load(f)

#     time.sleep(0.2)

#     if dic['count'] >= 1 :

#         print('%s买到票了'%name)

#         dic['count'] -= 1

#         time.sleep(0.2)

#         with open('ticket', encoding='utf-8')as f:

#             # dic = json.load

#     else:

#         print('没了')

#十个人同时查票

def user(name):

    #不涉及买  随便 并发

    search_ticket(name)

    # buy_ticket(name)

    # with 还会处理异常 前一个 出错了 以后的都可以释放  跳出异常

        # 不等了

if __name__ == '__main__':

    l = ['alex','b','c']

    for name in l:

        search_ticket(name)

        # p = Process(target=search_ticket,args=(name,))

        # p.start()

# 1. 牺牲了效率  ，保证了数据安全  关闭了 多进程 异步  并发

            #  在数据安全面前 效率不值一提 （和钱打交道的app都巨慢）

            #  不涉及钱的 可以 牺牲一点安全

#2 用户就觉得 很慢 体验很差.

#  join()  是同步 加单道了  一个个执行

# 锁的应用场景

#     # 内存里还有   子进程结束 子进程没了   变量  join 加入内存里了