# -*- coding: utf-8 -*-
# __author__ = "maple"
# 1.整理进程部分的重点，线程部分重点
'''
进程重点：操作系统 ：多道、遇到io会切换，分时、时间片到了会切换
        ：进程的特点：数据隔离、开销大、能利用多核、进程之间共享数据的安全：lock
        ：生产者消费者模型：一个产生数据并处理数据的过程解耦。
                         ：让生产数据的过程和处理数据的过程达到一个工作效率上的平衡
                         ：中间的容器，在多进程中我们使用队列或者可被join队列，做的控制数据的量，
                           当数据过剩的时候，队列的大小会控制着生产着的行为
                           当数据严重不足时，队列会控制消费着的行为
                           并且我们还可以通过定期检查队列中的元素的个数来调节生产者消费者的个数
线程重点：线程的特点：开销小、数据共享、是进程的一部分、本身可以利用多核。
       ：守护线程：等待所有非守护子线程结束而结束
                ：非守护线程不结束，主线程也不结束
                ：非守护线程结束、主线程结束、主进程结束、守护线程也结束
       threading： 模块的函数：
                ：current_thread 在哪个线程中被调用，就返回当前线程的对象
                ：enumerate 返回当前活着的线程的对象类别
                ：active_count  返回当前活着的线程的个数
'''



# 2.多线程实现一个并发的socket server
'''
import socket
from threading import Thread

def func(con):
   while True:
       msg = con.recv(1024).decode("utf-8")
       print(msg)
       con.send(msg.upper().encode("utf-8"))

sk = socket.socket()
sk.bind(("127.0.0.1",9000))
sk.listen()
while True:
    con,_ = sk.accept()
    Thread(target=func,args=(con,)).start()

'''
# 3.使用多线程 实现一个请求网页 并且把网页写到文件中
#     # 生产者消费者模型来完成

'''
import re
from urllib.request import urlopen
from multiprocessing import Pool

def get_page(url,pattern):
    response=urlopen(url).read().decode('utf-8')
    return pattern,response

def parse_page(info):
    pattern,page_content=info
    res=re.findall(pattern,page_content)
    for item in res:
        dic={
            'index':item[0].strip(),
            'title':item[1].strip(),
            'actor':item[2].strip(),
            'time':item[3].strip(),
        }
        print(dic)
if __name__ == '__main__':
    regex = r'<dd>.*?<.*?class="board-index.*?>(\d+)</i>.*?title="(.*?)".*?class="movie-item-info".*?<p class="star">(.*?)</p>.*?<p class="releasetime">(.*?)</p>'
    pattern1=re.compile(regex,re.S)

    url_dic={
        'http://maoyan.com/board/7':pattern1,
    }

    p=Pool()
    res_l=[]
    for url,pattern in url_dic.items():
        res=p.apply_async(get_page,args=(url,pattern),callback=parse_page)
        res_l.append(res)

    for i in res_l:
        i.get()
'''
# 4.整理默写的内容
# 5.ftp第五个需求 分配家目录的需求
# 6.使用线程池，随意访问n个网址，并把网页内容记录在文件中
'''
import os
import requests
from concurrent.futures import ThreadPoolExecutor
def get_page(url):
    ret = requests.get(url)
    return  {"url":url,"text":ret.text}

def parserpage(res):
    res = ret.result()
    # print('<进程%s> parse %s' %(os.getpid(),res['url']))
    # parse_res='url:<%s> size:[%s]\n' %(res['url'],len(res['text']))
    # with open('db.txt','a') as f:
    #     f.write(parse_res)

tp = ThreadPoolExecutor(5)
url_lst = ["http://www.baidu.com",
           "http://www.cnblogs.com",
           "http://www.douban.com"
]

for url in url_lst:
    ret = tp.submit(get_page,url)
    ret.add_done_callback(parserpage)

'''


# 7.请简述什么是死锁现象？如何产生？如何解决
'''
死锁现象：指两个或两个以上进程或线程再执行过程中，因争夺资源而相互等待的现象
       ：若无外力作用，它们都将无法推行下去。
如何产生：1、两把锁或两把以上，多把锁交替使用
如何解决：递归锁：将多把锁变成一把锁。快速解决问题、效率差。
       ：互斥锁：优化代码逻辑。效率相对好、解决问题的效率低。
       
'''


# 8.请说说你知道的并发编程中的哪些锁？各有什么特点？
'''
GIL:全局解释器锁：在python中由于特殊的垃圾回收机制，cpython解释器不能并行，只能并发。
递归锁：在一个线程中连续多次acquire不会会死锁
互斥锁：在一个线程中连续多次acquire会死锁
'''
# 9.cpython解释器下的线程是否数据安全？
'''
即便是线程，即便有GIL也会出现数据不安全的问题
操作的是全局变量
这些操作：+= 、-=、*=、/=  先计算在赋值容易出现数据不安全，包括lst[0] += 1   dic["key"] -= 1。
'''
# 10.尝试：在多进程中开启多线程。在进程池中开启线程池
'''
多进程中开启多线程
'''
'''
import os
from multiprocessing import Process
from threading import Thread
def pfunc():
    print("start:",os.getpid())
    for i in range(3):
        Thread(target=tfunc).start()


def tfunc():
    print("end:",os.getpid())

if __name__ == '__main__':
    for i in range(2):
        Process(target=pfunc).start()
'''



'''
进程池中开启进程池
'''
'''
import os
from concurrent.futures import ProcessPoolExecutor
from concurrent.futures import ThreadPoolExecutor

def pp():
    print("start:",os.getpid())
    t = ThreadPoolExecutor(2)
    t.submit(tp)


def tp():
    print("end:",os.getpid())
if __name__ == '__main__':
    p = ProcessPoolExecutor(2)
    p.submit(pp)
'''