（队列）（线程）（线程使用全局变量，死锁）

#********队列Queue的使用**************************************

# 第一，导入模块
from multiprocessing import Queue
#第二，创建队列
q = Queue(3)#可接一个整数，表示队列的容量，不写的话就表不设上限
print(q.qsize(),q.empty(),q.full())
#第三，往队列里加消息
q.put('obj_1')
q.put('obj_2')
print(q.qsize(),q.empty(),q.full())
q.put('obj_3')
print(q.qsize(),q.empty(),q.full())
# 第四，从队列取出消息 ,先进先出
value = q.get()
print(value)
value = q.get()
print(value)
value = q.get()
print(value)


from multiprocessing import *
# from multiprocessing import Queue
q = Queue(3)
q.put('num1')
q.put('num2')
q.put('num3')
# q.put('num4',block=False)
#put(self, obj, block=True, timeout=None)  默认阻塞，
q.put('num5',timeout=2)
print(q.get())


from multiprocessing import *
from multiprocessing import Queue
q = Queue(2)
q.put('n1')
q.put('n2')
if not q.full():
    q.put('n3')
else:
    value = q.get()
    print(value)
try:
    value = q.get()
    print(value)
except:
    print('看看是不是空了',q.empty())
finally:
    print('记住了吗，理解了吗，会用了吗')
#***********下面是，队列阻塞********************************************

from multiprocessing import *
from multiprocessing import Queue
q = Queue(3)
q.put('要放入队列的')
# put(obj, block=True, timeout=None)  block为True时，放不进队列就会阻塞；block为False时，放不进就不阻塞直接报错。
# q.put_nowait(obj)  相当于put（block=False)

q.get()
#get(self, block=True, timeout=None)  队列空的时候，获取不到，block为True就阻塞，block为False就不阻塞，报错。
# q.get_nowait()  相当于get(block=False)

#***********队列操作案例********************************************

#两个进程，一个往队列写入数据，另一个从队列读出数据
# from multiprocessing import Process
# from multiprocessing import Queue
from multiprocessing import *
import time,random

# 由于进程之间的通信只能通过队列来完成。所以队列中最后一个元素Exit为退出读取进程的标志
msg = ['a_good','b_morning','c_hello','d_world','Exit']
def write(q):
    for value in msg:
        q.put(value)
        print(value,'进入队列')
        time.sleep(random.random())
def read(q):
    print('开始读数据了')
    while True:
        if not q.empty():
            value = q.get()
            if value == 'Exit':
                break
            print(value,'取出队列')
if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=read,args=(q,))
    p2 = Process(target=write,args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    print('所有读写结束')


# from multiprocessing import Process
# from multiprocessing import Queue
from multiprocessing import *
import time,random

def write(q):
    for value in ['a_good','b_morning','c_hello','d_world','Exit']:
        q.put(value)
        print(value,'现在放入的是')
        time.sleep(1)
def read(q):
    print('开始读数据了')
    while True:
        if not q.empty():
            value=q.get()
            print(value,'取出')
            if value=='Exit':
                break
if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=write,args=(q,))
    p2 = Process(target=read,args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    print('所有读写结束')


from multiprocessing import *
import time,random
def read(q):
    while True:
        if not q.empty():
            value=q.get()
            if value=='Exit':
                break
            print(value,'取出')
def write(q):
    for value in ['a_good','b_morning','c_hello','d_world','Exit']:
        time.sleep(random.random())
        q.put(value)
        print(value,'放入')
if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=read,args=(q,))
    p2 = Process(target=write,args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    print('结束')
#*******************************************************

# 操作系统会为每一个进程分配独立的内存空间
# 进程的缺点：因为占用独立的资源，所以对系统开销比较大
#         一般情况下，我们可以使用多线程来完成多任务的开发。
#         一个进程中，包含了多个线程，线程对系统开销要小很多
#**************下面，多线程*****************************************

from threading import Thread
from urllib import request

def downloader(url):
    file_name = url.split('/')[-1]
    response = request.urlopen(url)
    content = response.read()
    with open (file_name,'wb') as fp:
        fp.write(content)
    print('子线程完成')
if __name__ == '__main__':
    #主进程下面有一个主线程
    url_list = ['https://img.zcool.cn/community/01b82f5bac3a7aa801213deadb1922.jpg@1280w_1l_2o_100sh.jpg',
                'https://img.zcool.cn/community/01ccf65bac3a7ea8012099c8d65a89.jpg@1280w_1l_2o_100sh.jpg']
    thread_list = []
    # 创建线程
    for url in url_list:
        t = Thread(target=downloader,args=(url,))
        t.start()
        thread_list.append(t)
    for t in thread_list:
        t.join()


from multiprocessing import *
from threading import Thread
from urllib import request
def downloader(url):
    file_name = url.split('/')[-1]
    response = request.urlopen(url)
    content = response.read()
    with open(file_name,'wb') as fp:
        fp.write(content)
if __name__ == '__main__':
    url_list = ['https://img.zcool.cn/community/01b82f5bac3a7aa801213deadb1922.jpg@1280w_1l_2o_100sh.jpg',
                'https://img.zcool.cn/community/01ccf65bac3a7ea8012099c8d65a89.jpg@1280w_1l_2o_100sh.jpg']
    thread_list = []
    for url in url_list:
        t = Thread(target=downloader,args=(url,))
        thread_list.append(t)
        t.start()
    for t in thread_list:
        t.join()
#**********查看线程数量，threading.enumerate()返回一个列表，列表中是当前存活的所有线程*********************************************

# import threading
from threading import Thread
import threading
import time
def sing():
    for i in range(3):
        print('唱第%d首歌'%i)
        time.sleep(1)
def dance():
    for i in range(3):
        print('跳第%d之舞'%i)
        time.sleep(1)
is_repeat = -1
if __name__ == '__main__':
    t1 = Thread(target=sing)
    t2 = Thread(target=dance)
    t1.start()
    t2.start()
    while True:

        count = len(threading.enumerate())
        if is_repeat == count:
            pass
        else:
            is_repeat = count
            print(count,'是当前线程数量')
            if count<=1:
                break
    #至少有一个主线程
#*************实现线程的第二种方法，声明一个类继承Thread ******************************************

from threading import Thread
from urllib import request
class MyThread(Thread):
    def __init__(self,url):
        Thread.__init__(self)
        self.url = url
    def run(self):
        print('比如把downloader那个函数放在这')
        file_name = self.url.split('/')[-1]
        response = request.urlopen(self.url)
        content = response.read()
        with open(file_name,'wb') as fp:
            fp.write(content)
if __name__ == '__main__':
    url = 'https://img.zcool.cn/community/01b82f5bac3a7aa801213deadb1922.jpg@1280w_1l_2o_100sh.jpg'
    t = MyThread(url)
    t.start()
#***********线程共享全局变量。进程独享内层空间，没有横跨两个进程的全局变量********************************************

from threading import Thread
from multiprocessing import Process
g_num = 0
def work1():
    global g_num
    for i in range(3):
        g_num+=1
        print('在1里面全局变量现在是',g_num)
def work2():
    global g_num
    for i in range(3):
        g_num+=1
        print('在2里面全局变量现在是',g_num)
if __name__ == '__main__':

    # 多进程之间内存独立，不能够共享全局变量。如果通信的话，要使用Queue
    # p1 = Process(target=work1)
    # p2 = Process(target=work2)
    # p1.start()
    # p2.start()

    # 由于多线程可以共享全局变量，所以g_num加6
    t1 = Thread(target=work1)
    t2 = Thread(target=work2)
    t1.start()
    t2.start()
#**********线程共享全局变量时，造成的数据混乱，不安全。用锁解决*********************************************

from threading import Thread
from threading import Lock

g_num = 0
def work1():
    global g_num
    for i in range(10000000):
        mutex.acquire()
        g_num += 1
        mutex.release()

def work2():
    global g_num
    for i in range(10000000):
        mutex.acquire()
        g_num += 1
        mutex.release()
mutex = Lock()
if __name__ == '__main__':
    t1 = Thread(target=work1)
    t2 = Thread(target=work2)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print(g_num)
#**************对死锁的理解*****************************************
# 当多个锁存在时，不同的线程持有不同的锁，并试图获取对方的锁时，可能造成死锁。
# 比如两个线程，两个全局变量，某个时刻，两个线程各自锁住一个全局变量，造成都无法调取对方锁住的变量
#夫妻炒菜，一个拿着锅不放，一个拿着铲不放，都不能炒菜了。