GIL、进程池与线程池、事件等

思路解析：
1、执行登录，输入用户名cgon，密码123，对用户名egon和密码进行hash校验，并加盐处理，将密文密码发送到服务端，
与服务端事先存好用户名与密文密码进行对比，对比成功后，
在服务端内存中用hash算法生成一个随机字符串比如eadc05b6c5dda1f8772c4f4ca64db110
然后将该字符串发送给用户以及登录成功的提示信息发送给客户端,然后在服务端存放好
    current_users={
        'a3sc05b6c5dda1f8313c4f4ca64db110':{'uid':0,'username':'alex'},
        'e31adfc05b6c5dda1f8772c4f4ca64b0':{'uid':1,'username':'lxx'},
        'eadc05b6c5dda1f8772c4f4ca64db110':{'uid':2,'username':'cgon'},

    }  这个不太合适吧
    反过来存?

用户在收到服务端发来的'eadc05b6c5dda1f8772c4f4ca64db110'以及登录成功的提示信息后，以后的任何操作都会携带该随
机字符串'eadc05b6c5dda1f8772c4f4ca64db110‘，服务端会根据该字符串获取用户信息来进行与该用户匹配的操作

在用户关闭连接后，服务端会从current_users字典中清除用户信息，下次重新登录，会产生新的随机字符串
这样做的好处:
    1、用户的敏感信息全都存放到服务端，更加安全
    2、每次登录都拿到一个新的随机的字符串，不容易被伪造

2、执行注册功能，提交到服务端，然后存放到文件中，如果用户已经存在则提示用户已经注册过，要求重新输入用户信息

3、执行上次下载功能时会携带用户的随机字符串到服务端，如果服务端发现该字符串not in current_users，则要求用户先登录

from multiprocessing import Process,Queue
import time,random,os
def consumer(q):
    while True:
        res=q.get()
        time.sleep(random.randint(1,3))
        print('\033[45m%s 吃 %s\033[0m' %(os.getpid(),res))

def producer(q):
    for i in range(10):
        time.sleep(random.randint(1,3))
        res='包子%s' %i
        q.put(res)
        print('\033[44m%s 生产了 %s\033[0m' %(os.getpid(),res))

if __name__ == '__main__':
    q=Queue()
    #生产者们:即厨师们
    p1=Process(target=producer,args=(q,))

    #消费者们:即吃货们
    c1=Process(target=consumer,args=(q,))

    #开始
    p1.start()
    c1.start()
    print('主进程结束')

ts,re,os
from concurrent.futures import  ThreadPoolExecutor,ProcessPoolExecutor

# respOnse= requests.get("https://www.baidu.com")
# htm = response.content.decode("utf-8")
# print(re.findall("href=.*?com",htm))

def get_data(url):
    print("%s 正在请求%s" % (os.getpid(),url))
    response = requests.get(url)
    print("%s 请求%s成功" % (os.getpid(),url))
    return response

def parser(res):
    htm = res.content.decode("utf-8")
    ls = re.findall("href=.*?com", htm)
    print("解析完成! 共%s个连接" % len(ls))

if __name__ == '__main__':
    urls = ["https://www.baidu.com",
            "https://www.sina.com",
            "https://www.tmall.com",
            "https://www.taobao.com",
            "https://www.jd.com",
            "https://www.python.org",
            "https://www.apple.com"]

    pool = ProcessPoolExecutor(3)
    objs = []
    for i in urls:
        obj = pool.submit(get_data,i)
        # res = obj.result() # 会把任务变成串行
        # parser(res)
        objs.append(obj)


    pool.shutdown() # 请求依然是并发,但是请求的结果不能被立即处理
    for i in objs: # 解析数据时串行的
        parser(i.result())

# 线程池中使用异步回调
def get_data(url):
    print("%s 正在请求%s" % (current_thread().name, url))
    response = requests.get(url)
    print("%s 请求%s成功" % (current_thread().name, url))
    return response


def parser(obj):
    res = obj.result()
    htm = res.content.decode("utf-8")
    ls = re.findall("href=.*?com", htm)
    print("%s解析完成! 共%s个连接" % (current_thread().name,len(ls)))

if __name__ == '__main__':
    urls = ["https://www.baidu.com",
            "https://www.tmall.com",
            "https://www.taobao.com",
            "https://www.jd.com",
            "https://www.python.org",
            "https://www.apple.com"]
    pool = ThreadPoolExecutor(3)

    for i in urls:
        obj = pool.submit(get_data, i)
        # res = obj.result() # 会把任务变成串行
        # parser(res)
        obj.add_done_callback(parser)

import requests, re, os
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
from threading import current_thread


# respOnse= requests.get("https://www.baidu.com")
# htm = response.content.decode("utf-8")
# print(re.findall("href=.*?com",htm))

# def get_data(url):
#     print("%s 正在请求%s" % (os.getpid(), url))
#     respOnse= requests.get(url)
#     print("%s 请求%s成功" % (os.getpid(), url))
#     return response
#
#
# def parser(obj):
#
#     res = obj.result()
#     htm = res.content.decode("utf-8")
#     ls = re.findall("href=.*?com", htm)
#     print("%s解析完成! 共%s个连接" % (os.getpid(),len(ls)))
#
# if __name__ == '__main__':
#     urls = ["https://www.baidu.com",
#             "https://www.sina.com",
#             "https://www.tmall.com",
#             "https://www.taobao.com",
#             "https://www.jd.com",
#             "https://www.python.org",
#             "https://www.apple.com"]
#     pool = ProcessPoolExecutor(3)
#
#     for i in urls:
#         obj = pool.submit(get_data, i)
#         # res = obj.result() # 会把任务变成串行
#         # parser(res)
#         obj.add_done_callback(parser)

from queue import Queue,LifoQueue,PriorityQueue
q = Queue(2)
q.put("a")
q.put("b",timeout=1)

print(q.get())  # a
# print(q.get(timeout=2))  # b

from queue import Queue,LifoQueue,PriorityQueue
pq = PriorityQueue()
pq.put((2,"b"))  
pq.put((3,"c")) 
pq.put((1,"a")) 

print(pq.get())  # (1, 'a')
print(pq.get())  # (2, 'b')
print(pq.get())  # (3, 'c')

pq.put((["b"],"csdlkjfksdjkfds"))
pq.put((["a"],"bdslkfjdsfjd"))
pq.put((["c"],"asd;kjfksdjfkdsf"))

print(pq.get())  # (['a'], 'bdslkfjdsfjd')
print(pq.get())  # (['b'], 'csdlkjfksdjkfds')
print(pq.get())  # (['c'], 'asd;kjfksdjfkdsf')

import threading, time


class Boss(threading.Thread):
    def run(self):
        print("BOSS：今晚大家都要加班到22:00。")
        print(event.isSet())
        event.set()
        time.sleep(5)
        print("BOSS：<22:00>可以下班了。")
        print(event.isSet())
        event.set()


class Worker(threading.Thread):
    def run(self):
        event.wait()
        print("Worker：哎……命苦啊！")
        time.sleep(1)
        event.clear()
        event.wait()
        print("Worker：OhYeah!")


if __name__ == "__main__":
    event = threading.Event()
    threads = []
    for i in range(5):
        threads.append(Worker())
    threads.append(Boss())
    for t in threads:
        t.start()
    for t in threads:
        t.join()

import time
from threading import Thread, Event

e = Event()


def start():
    print("began start!")
    time.sleep(2)
    print("server start!")
    e.set()


def conn():
    while True:
        print("try connect...")
        e.wait(timeout=1)  # 在这里阻塞  等1s  之后还没有isSet() 就退出
        if e.isSet():
            print("connect successful!")
            break
        else:
            print("connect filed!")


Thread(target=start).start()
Thread(target=conn).start()

import time
from threading import Thread
from threading import Event

# 使用变量类完成多线程协作
is_boot = False
def start():
    global is_boot
    print("正在启动服务器......")
    time.sleep(5)
    print("服务器启动成功!")
    is_boot = True

def connect():
    while True:
        if is_boot:
            print("连接服务器成功!")
            break
        else:
            print("连接服务器失败!")
        time.sleep(0.5)


Thread(target=start).start()
Thread(target=connect).start()

import time
from threading import Thread
from threading import Event

# 创建一个事件
e = Event() #默认False
def start():

    print("正在启动服务器......")
    time.sleep(5)
    print("服务器启动成功!")
    e.set() # 就是把事件的值设置为True

def connect():
    # 重试3次
    for i in range(3):
        print("等待服务器启动....")
        e.wait(1) # 会阻塞 直到对方把事件设置为True
        if e.isSet():
            print("连接成功!")
            break
        else:
            print("连接失败")
    else: #如果3次都没成功 就打印这个消息
        print("服务器没有启动")

Thread(target=start).start()
Thread(target=connect).start()