# os模块封装了常见的系统调用

import os

print(f"Process {os.getpid()} start...")  # unix/linux/mac系统中

pid = os.fork()

if pid < 0:
    print("fork()调用失败")
if pid == 0:
    print(f"父进程pid: {os.getppid()}, 子进程pid: {os.gerpid()}.")  # 子进程在系统的pid不为0
else:
    print(f"子进程pid: {os.getpid()}, 父进程pid: {pid}")  # 父进程返回子进程的ID

# 运行结果
'''
Process 3362 start...
父进程pid：3362， 子进程pid：3363
子进程pid：3363， 子进程pid：3362
'''

from multiprocessing import Process
import os
import time

# 子进程要执行的代码
def run_proc(name):
    time.sleep(3)
    print(f"子进程{name}运行中，pid={os.getpid()}，父进程的pid={os.getppid()}")

if __name__ == "__main__":
    print(f"父进程是{os.getpid()}.")
    p = Process(target=run_proc, args=('test',))
    print("子进程开始启动.")
    p.start()  # 启动进程
    p.join()  # 阻塞当前进程，直到调用join方法的那个进程执行完，在继续执行当前进程
    print("子进程运行结束")

# 结果
'''
父进程是12324.
子进程开始启动.
子进程test运行中，pid=4472，父进程的pid=12324
子进程运行结束
'''

from multiprocessing import Process
import os
import time

class MyProcess(Process):
    def __init__(self, interval):
        super().__init__()
        self.interval = interval

    def run(self):
        print("子进程")
        start_time = time.time()
        time.sleep(self.interval)
        stop_time = time.time()
        print(f"子进程id: {os.getpid()}, 父进程id：{os.getppid()}, 共执行了{stop_time-start_time: .2f} 秒.")

if __name__ == "__main__":
    print("主进程")
    startTime = time.time()
    p = MyProcess(2)
    p.start()
    p.join()
    stopTime = time.time()
    print(f"子进程结束，花费了{stopTime-startTime: .2f}")

# 结果
'''
主进程
子进程
子进程id: 3008, 父进程id：13084, 共执行了 2.00 秒.
子进程结束，花费了 2.79
'''

from multiprocessing import Pool
import os
import time
import random

# 进程类
def worker(msg):
    start_time = time.time()
    print(f"{msg}开始执行，执行进程id为{os.getpid()}，父进程id为{os.getppid()}")
    time.sleep(random.random()*2)
    stop_time = time.time()
    print(msg, f"执行完毕，耗时{stop_time-start_time: .2f}秒。")

if __name__ == "__main__":
    print("----开始执行----")
    start = time.time()
    pool = Pool(3)
    for i in range(0, 10):
        pool.apply_async(worker, (i,))  # 异步非阻塞
    pool.close()  # 关闭进程池，关闭后不再就收新请求
    pool.join()  # 必须放在close语句后面
    stop = time.time()
    print(f"执行结束，总耗时{stop-start:.2f}")

# 结果
'''
----开始执行----
0开始执行，执行进程id为4640，父进程id为7116
1开始执行，执行进程id为8，父进程id为7116
2开始执行，执行进程id为7728，父进程id为7116
0 执行完毕，耗时 0.09秒。
3开始执行，执行进程id为4640，父进程id为7116
2 执行完毕，耗时 0.10秒。
4开始执行，执行进程id为7728，父进程id为7116
4 执行完毕，耗时 0.04秒。
5开始执行，执行进程id为7728，父进程id为7116
3 执行完毕，耗时 0.20秒。
6开始执行，执行进程id为4640，父进程id为7116
6 执行完毕，耗时 0.12秒。
7开始执行，执行进程id为4640，父进程id为7116
5 执行完毕，耗时 1.38秒。
8开始执行，执行进程id为7728，父进程id为7116
1 执行完毕，耗时 1.95秒。
9开始执行，执行进程id为8，父进程id为7116
8 执行完毕，耗时 0.48秒。
7 执行完毕，耗时 1.81秒。
9 执行完毕，耗时 1.58秒。
执行结束，总耗时4.63
'''

from multiprocessing import Manager, Pool
import os

# queue，实现多进程间的数据传递，其实是个消息队列
def write(q):
    print(f"--开始执行写进程 {os.getpid()}--")
    for value in ['A', 'B', 'C']:
        print(f"把 {value} 放入队列")
        q.put(value)

def read(q):
    print(f"--开始执行读进程 {os.getpid()}--")
    for i in range(q.qsize()):
        print(f"从队列读取 {q.get(True)}")

if __name__ == "__main__":
    print(f"--开始执行主进程 {os.getpid()}--")
    q = Manager().Queue()
    p = Pool()
    p.apply(write, args=(q,))  # apply 阻塞，上个进程结束才会执行下一个进程
    p.apply(read, args=(q,))
    p.close()  # 关闭pool 不再接收请求
    p.join()  # 主进程阻塞，等待子进程运行结束，必须在close以后
    print("--主进程结束--")

# 结果
'''
--开始执行主进程 6012--
--开始执行写进程 11524--
把 A 放入队列
把 B 放入队列
把 C 放入队列
--开始执行读进程 11524--
从队列读取 A
从队列读取 B
从队列读取 C
--主进程结束--
'''

import subprocess

print('$ nslookup')
p = subprocess.Popen(['nslookup'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
output, err = p.communicate(b'set q=mx\npython.org\nexit\n')
print(output.decode("gbk"))
print('exit code:', p.returncode)

# 结果
'''
$ nslookup
默认服务器:  dnspai-public-dns.dnspai.com
Address:  101.226.4.6

> > 服务器:  dnspai-public-dns.dnspai.com
Address:  101.226.4.6

python.org	MX preference = 50, mail exchanger = mail.python.org
> 
exit code: 0
'''

import time
import threading

# 新线程执行
def loop(num):
    print(f"线程{threading.current_thread().name}正在运行...")
    n = 0
    while n < num:
        n += 1
        print(f"线程{threading.current_thread().name} >>> {n}")
        time.sleep(1)
    print(f"线程{threading.current_thread().name}结束")

print(f"线程{threading.current_thread().name}正在运行...")
t = threading.Thread(target=loop, name='LoopThread', args=(5,))  # 通过传参的方式调用局部变量
t.start()
t.join()
print(f"线程{threading.current_thread().name}运行结束.")

# 结果
'''
线程MainThread正在运行...
线程LoopThread正在运行...
线程LoopThread >>> 1
线程LoopThread >>> 2
线程LoopThread >>> 3
线程LoopThread >>> 4
线程LoopThread >>> 5
线程LoopThread结束.
线程MainThread运行结束.
'''

# 给线程加锁，实现线程按顺序执行
from threading import Thread, Lock
import time


class Task1(Thread):
    def run(self):
        while True:
            if lock1.acquire():  # 获取锁对象
                print("--Task1--")
                time.sleep(1)
                lock2.release()  # 释放锁


class Task2(Thread):
    def run(self):
        while True:
            if lock2.acquire():
                print("--Task2--")
                time.sleep(1)
                lock3.release()


class Task3(Thread):
    def run(self):
        while True:
            if lock3.acquire():
                print("--Task3--")
                time.sleep(1)
                lock1.release()


lock1 = Lock()
lock2 = Lock()
lock2.acquire()
lock3 = Lock()
lock3.acquire()

t1 = Task1()
t2 = Task2()
t3 = Task3()
t1.start()
t2.start()
t3.start()

# 结果
'''
--Task1--
--Task2--
--Task3--
--Task1--
--Task2--
--Task3--
    .
    .
    .
'''

# 利用生成器实现协程
# 来源：https://juejin.im/post/5d888151f265da03dd3db0f5
def consumer():
    r = ''
    while True:
        n = yield r
        if not n:
            return
        print(f"[CONSUMER] Consuming {n} ...")
        r = '200 OK'

def producer(c):
    # 启动生成器
    c.send(None)
    n = 0
    while n < 5:
        n += 1
        print(f'[PRODUCER] Producing {n} ...')
        r = c.send(n)
        print(f'[PRODUCER] Consumer return: {r}')
    c.close()


if __name__ == "__main__":
    c = consumer()
    producer(c)

# 结果
'''
[PRODUCER] Producing 1 ...
[CONSUMER] Consuming 1 ...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 2 ...
[CONSUMER] Consuming 2 ...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 3 ...
[CONSUMER] Consuming 3 ...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 4 ...
[CONSUMER] Consuming 4 ...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 5 ...
[CONSUMER] Consuming 5 ...
[PRODUCER] Consumer return: 200 OK
'''

import asyncio

@asyncio.coroutine
def test(i):
    print("test_1", i)
    r = yield from asyncio.sleep(1)
    print('test_2', i)

if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    tasks = [test(i) for i in range(3)]
    loop.run_until_complete(asyncio.wait(tasks))
    loop.close()

# 结果
'''
test_1 2
test_1 1
test_1 0
test_2 2
test_2 1
test_2 0
'''

import asyncio

async def test(i):
    print('test_1', i)
    await asyncio.sleep(1)
    print('test_2', i)

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    tasks = [test(i) for i in range(3)]
    loop.run_until_complete(asyncio.wait(tasks))
    loop.close()

# 结果
'''
test_1 2
test_1 1
test_1 0
test_2 2
test_2 1
test_2 0
'''

import gevent

def test(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        # gevent.sleep(1)  # 把3个greenlet依次运行改为交替运行

if __name__ == '__main__':
    g1 = gevent.spawn(test, 3)
    g2 = gevent.spawn(test, 3)
    g3 = gevent.spawn(test, 3)

    g1.join()
    g2.join()
    g3.join()

# 结果
'''
<Greenlet at 0x1ee82d8c268: test(3)> 0
<Greenlet at 0x1ee82d8c268: test(3)> 1
<Greenlet at 0x1ee82d8c268: test(3)> 2
<Greenlet at 0x1ee82d8c378: test(3)> 0
<Greenlet at 0x1ee82d8c378: test(3)> 1
<Greenlet at 0x1ee82d8c378: test(3)> 2
<Greenlet at 0x1ee82d8c488: test(3)> 0
<Greenlet at 0x1ee82d8c488: test(3)> 1
<Greenlet at 0x1ee82d8c488: test(3)> 2
'''

from gevent import monkey; monkey.patch_all()
from urllib import request
import gevent

def test(url):
    print(f"Get: {url}")
    response = request.urlopen(url)
    content = response.read().decode("utf-8")
    print(f"{len(content)} bytes received from {url}.")

if __name__ == "__main__":
    gevent.joinall([
        gevent.spawn(test, 'http://httpbin.org/ip'),
        gevent.spawn(test, 'http://httpbin.org/uuid'),
        gevent.spawn(test, 'http://httpbin.org/user-agent')
    ])

# 结果，3个网络操作是并发操作的，而且结束的顺序不同，但只有一个线程
'''
Get: http://httpbin.org/ip
Get: http://httpbin.org/uuid
Get: http://httpbin.org/user-agent
46 bytes received from http://httpbin.org/ip.
53 bytes received from http://httpbin.org/uuid.
40 bytes received from http://httpbin.org/user-agent.
'''

# 进程中消息队列读写数据
from multiprocessing import Process, Queue
import os
import time
import random

# 写数据
def write(q):
    print(f"写进程：{os.getpid()}")
    for i in 'ABC':
        print(f'正在往消息队列写入{i}')
        q.put(i)
        time.sleep(random.random())

# 读数据
def reader(q):
    while True:
        if not q.empty():
            i = q.get()
            print(f"从消息队列中读出{i}")
            time.sleep(random.random())
        else:
            break

if __name__ == "__main__":
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    pw.start()  # 启动子进程pw，写入
    pr.start()  # 启动子进程pr，读取
    pw.join()  # 等待pw结束
    pr.terminate()  # pr进程里是死循环，无法等待期结束，只能强行终止

# 结果
'''
写进程：3808
正在往消息队列写入A
从消息队列中读出A
正在往消息队列写入B
从消息队列中读出B
正在往消息队列写入C
'''

# 使用Pipe管道实现2个进程之间通信
import multiprocessing

def processFun(conn, name):
    print(multiprocessing.current_process().pid, "进程发送数据：", name)
    conn.send(name)

if __name__ == '__main__':
    # 创建管道
    conn1, conn2 = multiprocessing.Pipe()
    # 创建子进程
    p = multiprocessing.Process(target=processFun, args=(conn1, "http://www.baidu.com"))
    # 启动子进程
    p.start()
    p.join()

    print(multiprocessing.current_process().pid, "接收数据：")
    print(conn2.recv())

# 结果
'''
5760 进程发送数据： http://www.baidu.com
7760 接收数据：
http://www.baidu.com
'''

from multiprocessing import Process
import mmap
import contextlib
import time

def write():
    with contextlib.closing(mmap.mmap(-1, 1024, tagname='cnblogs', access=mmap.ACCESS_WRITE)) as mem:
        for share_data in ("Hello", "Alpha_Panda"):
            mem.seek(0)
            print('Write data:== %s == to share memory!' % share_data)
            mem.write(str.encode(share_data))
            mem.flush()
            time.sleep(0.5)

def read():
    while True:
        invalid_byte, empty_byte = str.encode('\x00'), str.encode('')
        with contextlib.closing(mmap.mmap(-1, 1024, tagname='cnblogs', access=mmap.ACCESS_READ)) as mem:
            share_data = mem.read(1024).replace(invalid_byte, empty_byte)
            if not share_data:
                # 当共享内存没有有效数据时结束read
                break
            print("Get data:== %s == from share memory!" % share_data.decode())
        time.sleep(0.5)

if __name__ == '__main__':
    pr = Process(target=read, args=())
    pw = Process(target=write, args=())
    pw.start()
    pr.start()
    pw.join()
    pr.join()

# 结果
'''
Write data:== Hello == to share memory!
Get data:== Hello == from share memory!
Write data:== Alpha_Panda == to share memory!
Get data:== Alpha_Panda == from share memory!
'''

# 实现方法：
"""
from multiprocessing import Semaphore

sem = Semaphore(num)
功能 ： 创建信号量对象
参数 ： 信号量的初始值
返回值 ： 信号量对象

sem.acquire()  将信号量减1 当信号量为0时阻塞
sem.release()  将信号量加1
sem.get_value() 获取信号量数量
"""

from multiprocessing import Process, Semaphore
import os
import time

# 创建信号量
sem = Semaphore(3)  # 3表示服务程序最多允许三个进程同时执行事件

def foo():
    print(f"进程 {os.getpid()} 想执行事件")
    # 获取信号量
    sem.acquire()  # 减少信号量
    print(f"进程 {os.getpid()} 开始执行操作")
    start = time.time()
    time.sleep(3)
    end = time.time()
    print(f"睡眠了{end - start: .4f}秒")
    print(f"进程 {os.getpid()} 操作执行完毕")
    sem.release()  # 增加信号量

if __name__ == "__main__":
    p = Process(target=foo, args='')
    p.start()
    p.join()

# 结果
'''
进程 4856 想执行事件
进程 4856 开始执行操作
睡眠了 3.0010秒
进程 4856 操作执行完毕
'''

# 服务端
import socket

# 1、创建服务端的socket对象
sk = socket.socket()

# 2、绑定一个ip和端口
sk.bind(("127.0.0.1", 8888))

# 3、服务器端一直监听是否有客户端进行连接
sk.listen(5)

while True:
    # 4、如果有客户端进行连接、则接受客户端的连接
    conn, addr = sk.accept() # 返回客户端socket通信对象和客户端的ip

    # 5、客户端与服务端进行通信
    rev_data = conn.recv(1024)
    print('服务端收到客户端发来的消息:%s' % (rev_data.decode('GB2312')))

    # 6、服务端给客户端回消息
    conn.send(b"HTTP/1.1 200 OK \r\n\r\n")  # http协议
    show_str = "<h1> 这短短的一生，我们最终都会失去，你不妨大胆一些。爱一个人，攀一座山，追一个梦,加油 !!!</h1>"
    conn.send(show_str.encode('GB2312'))

    # 7、关闭socket对象
    conn.close()

# 客户端
import socket

# 1、创建socket通信对象
clientSocket = socket.socket()

# 2、使用正确的ip和端口去链接服务器
clientSocket.connect(("127.0.0.1", 8888))

# 3、客户端与服务器进行通信
# 给socket服务器发送信息
send_data = "你拼命赚钱的样子虽然有些狼狈。但是自己靠自己的样子真的很美！加油"
clientSocket.send(send_data.encode("GB2312"))

# 接收服务器的响应（服务器回复的消息）
recvData = clientSocket.recv(1024).decode("GB2312")
print("客户端收到服务器恢复的消息：%s" % (recvData))

# 4、关闭socket对象
clientSocket.close()

"""
#创建锁
mutex = threading.Lock()
#锁定
mutex.acquire([timeout])
#释放
mutex.release()
"""
import threading

money = 0

def order(n):
    global money
    money = money + n
    money = money - n

class MyThread(threading.Thread):
    def __init__(self, thread_name):
        threading.Thread.__init__(self, name='线程' + thread_name)
        self.thread_name = int(thread_name)

    def run(self):
        for i in range(1000000):
            lock.acquire()  # 加锁
            order(self.thread_name)
            lock.release()  # 释放

if __name__ == '__main__':
    lock = threading.Lock()
    t1 = MyThread('1')
    t2 = MyThread('10')
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print(money)

# 结果
'''
0
'''

import threading
import time

num = 0
mutex = threading.RLock()

class MyThread(threading.Thread):
    def run(self):
        global num
        time.sleep(1)

        if mutex.acquire():
            num = num + 1
            msg = self.name + 'set num to' + str(num)
            print(msg)
            mutex.acquire()
            mutex.release()
            mutex.release()

if __name__ == '__main__':
    for i in range(5):
        t = MyThread()
        t.start()

# 结果
'''
Thread-1set num to1
Thread-4set num to2
Thread-3set num to3
Thread-2set num to4
Thread-5set num to5
'''

from threading import Semaphore, Thread
import time

# 创建信号量
sema = Semaphore(3)  # 限制同时访问资源的数量为3


def foo(tid):
    with sema:
        print(f"{tid} acquire sema")
        time.sleep(1)
    print(f"{tid} release sema")


threads = []

for i in range(5):
    t = Thread(target=foo, args=(i,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

# 结果
'''
0 acquire sema
1 acquire sema
2 acquire sema
1 release sema3 acquire sema
0 release sema

4 acquire sema
2 release sema
3 release sema
4 release sema

'''

import threading
import time


def test_a():
    condition.acquire()
    print("李白：中路团一波，推塔")
    condition.wait()
    print("李白：好的")
    condition.notify()
    condition.release()


def test_b():
    time.sleep(2)
    condition.acquire()
    print("武则天：等我大冷却")
    condition.notify()
    condition.wait()
    print("武则天：我的大好了，干干干")


if __name__ == '__main__':
    condition = threading.Condition()
    ta = threading.Thread(target=test_a)
    tb = threading.Thread(target=test_b)
    ta.start()
    tb.start()
    ta.join()
    tb.join()

# 结果
'''
李白：中路团一波，推塔
武则天：等我大冷却
李白：好的
武则天：我的大好了，干干干
'''

"""
event.wait(): 阻塞线程，知道flag值变为True
event.set(): 设置flag值为True
event.clear(): 修改flag值为False
event.isSet()：仅当flag值为True时返回
"""
# 主线程启动子线程后sleep两秒，子线程因为event.wait()被阻塞，当主线程醒来后执行event.set()，子线程才继续运行，两者输出时间差2s

import threading
import time
import datetime

class thread(threading.Thread):
    def __init__(self, thread_name):
        threading.Thread.__init__(self, name='线程' + thread_name)
        self.thread_name = int(thread_name)

    def run(self):
        event.wait()
        print(f"子线程运行时间: {datetime.datetime.now()}")

if __name__ == '__main__':
    event = threading.Event()
    t1 = thread('0')
    t1.start()  # 启动子线程
    print(f"主线程运行时间：{datetime.datetime.now()}")
    time.sleep(2)
    event.set()  # flag设置为True
    t1.join()

# 结果
'''
主线程运行时间：2020-06-15 21:44:54.221804
子线程运行时间: 2020-06-15 21:44:56.222719
'''

# 假设需要爬取博客网站的所有文章详情，先要通过文章列表页爬取所有文章的url，再根据文章的url，爬取文章的具体内容
import threading
from queue import Queue
import time

# 爬取文章详情页
def get_detail_html(detail_url_list, id):
    while True:
        url = detail_url_list.get()
        time.sleep(2)  # 延时2s，模拟网络请求
        print("thread {id}: get {url} detail finished ".format(id=id,url=url))

# 爬取文章列表页
def get_detail_url(queue):
    for i in range(100):
        time.sleep(1) # 延时1s，模拟比爬取文章详情要快
        queue.put("http://projectedu.com/{id}".format(id=i))
        print("get detail url {id} end".format(id=i))

if __name__ == "__main__":
    detail_url_queue = Queue(maxsize=1000)
    # 先创造两个线程
    thread = threading.Thread(target=get_detail_url, args=(detail_url_queue,))
    html_thread= []
    for i in range(3):
        thread2 = threading.Thread(target=get_detail_html, args=(detail_url_queue,i))
        html_thread.append(thread2)
    start_time = time.time()
    # 启动两个线程
    thread.start()
    for i in range(3):
        html_thread[i].start()
    # 等待所有线程结束
    thread.join()
    for i in range(3):
        html_thread[i].join()

    print("last time: {} s".format(time.time()-start_time))

# 结果
'''
get detail url 0 end
get detail url 1 end
thread 0: get http://projectedu.com/0 detail finished 
get detail url 2 end
thread 1: get http://projectedu.com/1 detail finished 
get detail url 3 end
thread 2: get http://projectedu.com/2 detail finished 
get detail url 4 end
thread 0: get http://projectedu.com/3 detail finished 
get detail url 5 end
thread 1: get http://projectedu.com/4 detail finished 
get detail url 6 end
thread 2: get http://projectedu.com/5 detail finished 
get detail url 7 end
'''

import os
import time
from multiprocessing import Process

class MyProcess(Process):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        print(f"进程为{os.getpid()}，父进程为{os.getppid()}")
        print(f"我的名字是{self.name}")

if __name__ == "__main__":
    p1 = MyProcess("张三")
    p2 = MyProcess("李四")
    p2.daemon = True  # 默认为False，必须在start()之前上设置
    p1.start()
    p2.start()
    time.sleep(2)
    print("主进程结束")

# 结果
'''
进程为436，父进程为11972
我的名字是张三
进程为12140，父进程为11972
我的名字是李四
主进程结束
'''

from multiprocessing import Pool
import time

def run(fn):  # fn函数参数是数据列表的一个元素
    time.sleep(1)
    print(fn * fn)

if __name__ == "__main__":
    s = [1, 2, 3, 4, 5, 6]
    print("执行顺序：")
    start = time.time()
    for fn in s:
        run(fn)
    end = time.time()
    print(f"顺序执行时间：{end-start:.2f}")
    print("创建多个进程：")
    pool = Pool(10)  # 创建拥有10个进程数量的进程池
    pool.map(run, s)
    pool.close()  # 关闭进程池，不在接收新的进程
    pool.join()  # 主进程阻塞等待子进程退出
    t = time.time()
    print(f"并行执行时间：{t-end:.2f}")

# 结果
'''
执行顺序：
1
4
9
16
25
36
顺序执行时间：6.00
创建多个进程：
1
9
16
25
4
36
并行执行时间：3.31
'''

#  线程不是守护线程
import time
import threading


def fun():
    print("start fun")
    time.sleep(2)
    print("end fun")

def main():
    print("main thread")
    t1 = threading.Thread(target=fun,args=())
    t1.setDaemon(False)  # 非守护线程
    t1.start()
    time.sleep(1)
    print("main thread end")

if __name__ == '__main__':
    main()

# 结果，主程序在等待子线程结束才退出
'''
main thread
start fun
main thread end
end fun
'''

# 线程是守护线程
import time
import threading


def fun():
    print("start fun")
    time.sleep(2)
    print("end fun")

def main():
    print("main thread")
    t1 = threading.Thread(target=fun,args=())
    t1.setDaemon(True)  # 守护线程
    t1.start()
    time.sleep(1)
    print("main thread end")

if __name__ == '__main__':
    main()

# 结果，程序在主程序结束后，直接退出。没有等待子线程运行完
'''
main thread
start fun
main thread end
'''

# 多线程情况下
import time
import threading


def fun():
    print("start fun")
    time.sleep(2)
    print("end fun")

def foo():
    print("start foo")
    time.sleep(1)
    print("end foo")

if __name__ == '__main__':
    print("main thread")
    t1 = threading.Thread(target=fun,args=())
    t2 = threading.Thread(target=foo,args=())
    t1.setDaemon(True)  # 守护线程
    t1.start()
    t2.start()
    time.sleep(1)
    print("main thread end")

# 结果，程序在主程序结束后，等待非守护线程的foo执行完，才退出。而没有等待守护线程func运行完
'''
main thread
start fun
start foo
main thread end
end foo
'''

from concurrent.futures import ThreadPoolExecutor
import threading
import time

# 定义一个线程任务函数
def func(x, y):
    print(f"{threading.current_thread().name} is running, x={x}, y={y}.")
    # time.sleep(2)
    return x * y

def get_result(future):
    """
    如果程序不希望直接调用 result() 方法阻塞线程，则可通过 Future 的 add_done_callback() 方法来添加回调函数，该回调函数形如 fn(future)。当线程任务完成后，程序会自动触发该回调函数，并将对应的 Future 对象作为参数传给该回调函数
    """
    print(future.result())

def process():
    # 创建一个包含2个子线程的线程池，且线程名为以“thread_”开头
    pool = ThreadPoolExecutor(max_workers=2, thread_name_prefix="thread_")
    # 向线程池提交一个task
    for i in range(5):
        future = pool.submit(func, i, i+1)
        print(future.done())
        future.add_done_callback(get_result)
    pool.shutdown(wait=True)
    print('process finished')

if __name__ == "__main__":
    process()

# 结果
'''
thread__0 is running, x=0, y=1.
False
0
thread__0 is running, x=1, y=2.
True
2
False
thread__0 is running, x=2, y=3.
6
False
thread__1 is running, x=3, y=4.
12
False
thread__0 is running, x=4, y=5.
20
process finished
'''

"""
使用 with 语句来管理线程池，这样即可避免手动关闭线程池，通过Exectuor里的map()方法，为 iterables 的每个元素启动一个线程，以并发方式来执行 action 函数，并收集线程任务的返回值
"""
from concurrent.futures import ThreadPoolExecutor
import threading
import time

# 定义一个准备作为线程任务的函数
def action(max):
    my_sum = 0
    for i in range(max):
        print(threading.current_thread().name + '  ' + str(i))
        my_sum += i
    return my_sum
# 创建一个包含4条线程的线程池
with ThreadPoolExecutor(max_workers=4) as pool:
    # 使用线程执行map计算
    # 后面元组有3个元素，因此程序启动3条线程来执行action函数
    results = pool.map(action, (3, 5, 7))
    print('--------------')
    for r in results:
        print(r)

# 结果
'''
ThreadPoolExecutor-0_0  0
ThreadPoolExecutor-0_0  1
ThreadPoolExecutor-0_0  2
ThreadPoolExecutor-0_0  0
ThreadPoolExecutor-0_0  1
ThreadPoolExecutor-0_0  2
ThreadPoolExecutor-0_0  3
ThreadPoolExecutor-0_0  4
ThreadPoolExecutor-0_0  0
ThreadPoolExecutor-0_0  1
ThreadPoolExecutor-0_0  2
ThreadPoolExecutor-0_0  3
ThreadPoolExecutor-0_0  4
ThreadPoolExecutor-0_0  5
ThreadPoolExecutor-0_0  6
--------------

3
10
21
'''