#!/use/bin/python
# -*- conding:utf-8 -*-

# 并发编程？
#     一个程序可以在同一时间做很多事情
#     解决程序中的IO操作影响程序效率的问题
#
# 并发编程为什么重要
#
# 操作系统
#         并发这件事

# 输入输出  ：大部分时间逗不会占用cpu，且会降低你程序的效率
# 如input/print  文件读数据，取数据
# 网络操作：  从网络上获取数据 爬虫  发送请求 写读  从网络上获取数据

# 单进程 -->多道系统-->分时进程  实时系统（分时：就是时间片轮转算法）
#

# 进程：运行中的程序
# 什么是程序：如微信，qq pycharm
# 操作系统  只负责管理调度进程
# 进程是操作系统中资源分配的最小单位
# 每一个运行中的程序都需要有自己的内存,资源
# 都分配给进程，记录执行的状态，管理自己的内存资源

# 在python中，每一个运行中的程序 都是一个进程
# 一个进程，就能做一件事
# 如果有多个进程  就可以做多件事儿
# 如果用pyth来开启一个进程

# import  os
# import  time
# print(os.getpid())
# time.sleep(1000)


# Process 进程
# multi  多远的

# import  os
# import  time
# from multiprocessing import Process
# def func(num):
#     print(num,os.getpid())
#     time.sleep(0.5)
#     print(num, os.getpid())
#     time.sleep(0.5)
#     print(num, os.getpid())
#     time.sleep(0.5)
#     print(num, os.getpid())
#
# if __name__ == '__main__':
#     print(os.getpid())
#     p = Process(target = func,args=(10,))  #创造一个进程
#     p.start()  #开启进程
#     print(os.getpid())
#     time.sleep(1)
#     print(os.getpid(),1)
#     time.sleep(1)
#     print(os.getpid(), 2)

# 同步：先洗衣服再做饭
# 异步：有了洗衣机，洗衣机洗衣服，然后你做饭
# 异步可以有效的提高执行效率，进程与进程之间都是异步的


    # 几个概念
    # 子进程
    # 住进程
    # 父进程
    #
    # 关于print的顺序

from multiprocessing import Process
import time


#什么手机进程：在程序运行中，计算机最小的资源分配单位
# 程序呗执行会产生一个主进程，同时主进程也叫父进程
# 在python中可以用代码启动一个子进程
# 父子进程之间的数据是异步的，各自执行自己的
# global()全局的   local局部的
# 主进程什么时候结束:主进程会等待子进程结束后在结束
# n = 100
# def func():
#     global n
#     n = 0
#     print('-------')
# # func()
# # print(n)
#
#     # func()
# if __name__ == '__main__':
#         Process(target=func).start()
#         time.sleep(1)
#         print(n)
#
#
# join:阻塞
# def func(n):
#     time.sleep(1)
#     print('_'*n)
#
# if __name__ == '__main__':
#     p = Process(target=func,args=(1,))
#     p.start()
#     print('子进程开始了')
#     p.join()
# 开启多个子进程
# def func(n):
#     time.sleep(1)  #只要在等待就会陷入阻塞状态
#     print('_'*n)
# if __name__ == '__main__':
#     l = []
#     for i in range (10):
#         p = Process(target=func,args=(i,))
#         p.start()
#         p.join()
    #     l.append(p)
    # for p in l:p.join()
    # # Process(target=func,args=(2,)).start()
    # Process(target=func,args=(3,)).start()
    # Process(target=func,args=(4,)).start()
#     print('十条信息已经发送完了')

#时间片的轮转

# 守护进程
# 守护进程也是一个子进程
# 当主进程的代码执行完毕之后自动结束的子进程就叫做子进程

# import time
# def deamon_func():
#     while True:
#         print('我还或者')
#         time.sleep(0.5)
#
# def wahaha():
#     for i in range(10):
#         time.sleep(1)
#         print(i * '#')
#
# if __name__ == '__main__':
#     Process(target=wahaha).start()
#     p = Process(target=deamon_func)
#     p.daemon = True
#     p.start()
#     for i in range(3):
#         print(i*'*')
#         time.sleep(1)

# 开启一个子进程  start
# 子进程和住进程是异步
# 如果在主进程中等待子进程结束之后再执行某段代码：join
# 如果有多个子进程 不能在start一个进程之后里面join，要吧所有的进程放到列表中，都start之后再逐一join
# 守护进程 ——当主进程的代码执行完毕之后自动结束的进程叫守护进程

# multiprocess

# 进程通信  队列能保证数据安全，管道数据不安全

# 加锁
# import  os
# import time
# import  random
# from multiprocessing import Process,Lock
#
#
# def work(n,lock):
#     lock.acquire()
#     print('%s: %s is running' %(n,os.getpid()))
#     time.sleep(random.random())
#     print('%s: %s is down' % (n, os.getpid()))
#     lock.release()
#
# if __name__ =='__main__':
#     lock = Lock()
#     for i in range(3):
#         p = Process(target=work,args=(i,lock))
#         p.start()
#         # p.join()

# 牺牲了效率保证了数据安全

# 信号量  就是厕所蹲坑，轮顿
# from multiprocessing import Semaphore
# sem = Semaphore(4)
# sem.acquire()
# print(1)
# sem.acquire()
# print(2)
# sem.acquire()
# print(3)
#以上为同步的  串行



# even事件
# 事件内部内置了一个标志
# wait  方法 如果这个标志是True，那wait == pass
# wait  方法 如果这个标志是False，那wait 就会陷入阻塞，一直阻塞到标志从False到True

# 一个事件在创建之处 内部的标志是False
# False  -->True set()
# True -->False clear()

# 红绿灯模型


# 队列
from multiprocessing import  Queue,Process

def func(q,num):
    try:
        t = q.get_nowait()
        print('%s抢到票了'%num)
    except:pass

if __name__ == '__main__':
    q = Queue()
    q.put(1)
    for i in range(10):
        Process(target=func,args=(q,i)).start()
    # print(q.get())

    # 管道 + 锁 == 队列
    # 管道也是一个可以实现进程之间通信的模型
    # 但是管道没有锁，数据不安全
    #消息中间件
    # memcache
    # rabitmq
    # kafka
    # redis