from random import randint
from threading import Thread
from time import time, sleep


def download(filename):
    print('开始下载%s...' % filename)
    time_to_download = randint(5, 10)
    sleep(time_to_download)
    print('%s下载完成! 耗费了%d秒' % (filename, time_to_download))


def main():
    start = time()
    t1 = Thread(target=download, args=('Python从入门到住院.pdf',))
    t1.start()
    t2 = Thread(target=download, args=('Peking Hot.avi',))
    t2.start()
    t1.join()
    t2.join()
    end = time()
    print('总共耗费了%.3f秒' % (end - start))


if __name__ == '__main__':
    main()

from random import randint
from threading import Thread
from time import time, sleep


class DownloadTask(Thread):

    def __init__(self, filename):
        super().__init__()
        self._filename = filename

    def run(self):
        print('开始下载%s...' % self._filename)
        time_to_download = randint(5, 10)
        sleep(time_to_download)
        print('%s下载完成! 耗费了%d秒' % (self._filename, time_to_download))


def main():
    start = time()
    t1 = DownloadTask('Python从入门到住院.pdf')
    t1.start()
    t2 = DownloadTask('Peking Hot.avi')
    t2.start()
    t1.join()
    t2.join()
    end = time()
    print('总共耗费了%.2f秒.' % (end - start))


if __name__ == '__main__':
    main()

from time import sleep
from threading import Thread


class Account(object):

    def __init__(self):
        self._balance = 0

    def deposit(self, money):
        # 计算存款后的余额
        new_balance = self._balance + money
        # 模拟受理存款业务需要0.01秒的时间
        sleep(0.01)
        # 修改账户余额
        self._balance = new_balance

    @property
    def balance(self):
        return self._balance


class AddMoneyThread(Thread):

    def __init__(self, account, money):
        super().__init__()
        self._account = account
        self._money = money

    def run(self):
        self._account.deposit(self._money)


def main():
    account = Account()
    threads = []
    # 创建100个存款的线程向同一个账户中存钱
    for _ in range(100):
        t = AddMoneyThread(account, 1)
        threads.append(t)
        t.start()
    # 等所有存款的线程都执行完毕
    for t in threads:
        t.join()
    print('账户余额为: ￥%d元' % account.balance)


if __name__ == '__main__':
    main()

import threading
import time

num = 0  #全局变量多个线程可以读写，传递数据
lock =threading.Lock() #创建一个锁

class Mythread(threading.Thread):
    def run(self):
        global num
        with lock:   #with Lock的作用相当于自动获取和释放锁(资源)
            for i in range(1000000): #锁定期间，其他线程不可以干活
                num+=1
        print(num)

mythread=[]
for i  in range(5):
    t=Mythread()
    t.start()
    mythread.append(t)
for t in mythread:
    t.join()
print("game over")

from time import sleep
from threading import Thread, RLock


class Account(object):

    def __init__(self):
        self._balance = 0
        self._lock = RLock()

    def deposit(self, money):
        # 先获取锁才能执行后续的代码
        self._lock.acquire()
        try:
            new_balance = self._balance + money
            sleep(0.01)
            self._balance = new_balance
        finally:
            # 在finally中执行释放锁的操作保证正常异常锁都能释放
            self._lock.release()

    @property
    def balance(self):
        return self._balance


class AddMoneyThread(Thread):

    def __init__(self, account, money):
        super().__init__()
        self._account = account
        self._money = money

    def run(self):
        self._account.deposit(self._money)


def main():
    account = Account()
    threads = []
    for _ in range(100):
        t = AddMoneyThread(account, 1)
        threads.append(t)
        t.start()
    for t in threads:
        t.join()
    print('账户余额为: ￥%d元' % account.balance)


if __name__ == '__main__':
    main()

"""
实现场景：当a同学王火锅里面添加鱼丸加满后（最多5个，加满后通知b去吃掉），通知b同学去吃掉鱼丸（吃到0的时候通知a同学继续添加）
"""
import threading
import time

con = threading.Condition()
num = 0

# 生产者
class Producer(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        with con:
            # 锁定线程
            global num
            while True:
                print("开始添加！！！")
                num += 1
                print("火锅里面鱼丸个数：%s" % str(num))
                time.sleep(1)
                if num >= 5:
                    print("火锅里面里面鱼丸数量已经到达5个，无法添加了！")
                    # 唤醒等待的线程
                    con.notify()  # 唤醒小伙伴开吃啦
                    # 等待通知
                    con.wait()


# 消费者
class Consumers(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        with con:
            global num
            while True:
                print("开始吃啦！！！")
                num -= 1
                print("火锅里面剩余鱼丸数量：%s" % str(num))
                time.sleep(2)
                if num <= 0:
                    print("锅底没货了，赶紧加鱼丸吧！")
                    con.notify()  # 唤醒其它线程
                    # 等待通知
                    con.wait()


p = Producer()
c = Consumers()
p.start()
c.start()

import time
import logging
from threading import Event, Thread

log_format = "%(asctime)s-%(levelname)s-%(module)s-%(funcName)s-%(threadName)s%(message)s"
logging.basicConfig(format=log_format, level=logging.INFO)


def boss(event: Event):
    logging.info("我是老板正在等待中....")
    event.wait()
    logging.info("完成的不错！")


def worker(event: Event, count: int = 10):
    logging.info("我正在工作中....")
    cups = []
    while True:
        logging.info("制作中....")
        time.sleep(0.5)
        cups.append("u")
        if len(cups) >= count:
            event.set()
            break

    logging.info("我制作的杯子.cups={}".format(cups))


event = Event()

w = Thread(target=worker, args=(event,))
b = Thread(target=boss, args=(event,))
b.start()
w.start()

#!/usr/bin/env python3 
# coding:utf-8 
# author:ZuoJie
# date:2019/5/15 9:32

import time
import threading
import logging
from threading import Barrier

log_format = "%(asctime)s-15s\t [%(threadName)s,%(thread)8d] %(message)s"
logging.basicConfig(level=logging.INFO, format=log_format)


def worker(barrier: threading.Barrier):
    logging.info("等待{}线程".format(barrier.n_waiting))
    try:
        barrier_id = barrier.wait()
        logging.info("下一个是barrier{}".format(barrier_id))
    except threading.BrokenBarrierError:
        logging.info("损毁的Barrier")


barrier = Barrier(3)

for _ in range(100):
    threading.Thread(target=worker, args=(barrier,)).start()

#!/usr/bin/env python3 
# coding:utf-8 
# author:ZuoJie
# date:2019/5/15 10:26
import time
import threading
import logging
from threading import Semaphore

log_format = "%(asctime)s-15s\t [%(threadName)s,%(thread)8d] %(message)s"
logging.basicConfig(level=logging.INFO, format=log_format)

sem = Semaphore(3)


class MyThread(threading.Thread):
    def run(self):
        logging.info("{} 等待中的信号量".format(self.name))
        sem.acquire()
        logging.info("被锁定的信号量{}".format(self.name))
        time.sleep(5)
        logging.info("{} 解除锁定信号量".format(self.name))
        sem.release()


for i in range(10):
    t = MyThread(name="Thread-{}".format(i + 1))
    t.start()

def worker():
    while True:
        item = q.get()
        if item is None:
            break
        do_work(item)
        q.task_done()

q = queue.Queue()
threads = []
for i in range(num_worker_threads):
    t = threading.Thread(target=worker)
    t.start()
    threads.append(t)

for item in source():
    q.put(item)

# block until all tasks are done
q.join()

# stop workers
for i in range(num_worker_threads):
    q.put(None)
for t in threads:
    t.join()

import threading

def func():
    print('hello timer!')

timer = threading.Timer(5, func)
timer.start()

from random import randint
from time import time, sleep


def download_task(filename):
    print('开始下载%s...' % filename)
    time_to_download = randint(5, 10)
    sleep(time_to_download)
    print('%s下载完成! 耗费了%d秒' % (filename, time_to_download))


def main():
    start = time()
    download_task('Python从入门到住院.pdf')
    download_task('Peking Hot.avi')
    end = time()
    print('总共耗费了%.2f秒.' % (end - start))


if __name__ == '__main__':
    main()

开始下载Python从入门到住院.pdf...
Python从入门到住院.pdf下载完成! 耗费了6秒
开始下载Peking Hot.avi...
Peking Hot.avi下载完成! 耗费了7秒
总共耗费了13.01秒.

from multiprocessing import Process
from os import getpid
from random import randint
from time import time, sleep


def download_task(filename):
    print('启动下载进程，进程号[%d].' % getpid())
    print('开始下载%s...' % filename)
    time_to_download = randint(5, 10)
    sleep(time_to_download)
    print('%s下载完成! 耗费了%d秒' % (filename, time_to_download))


def main():
    start = time()
    p1 = Process(target=download_task, args=('Python从入门到住院.pdf', ))
    p1.start()
    p2 = Process(target=download_task, args=('Peking Hot.avi', ))
    p2.start()
    p1.join()
    p2.join()
    end = time()
    print('总共耗费了%.2f秒.' % (end - start))


if __name__ == '__main__':
    main()

启动下载进程，进程号[1530].
开始下载Python从入门到住院.pdf...
启动下载进程，进程号[1531].
开始下载Peking Hot.avi...
Peking Hot.avi下载完成! 耗费了7秒
Python从入门到住院.pdf下载完成! 耗费了10秒
总共耗费了10.01秒.

from multiprocessing import Process
from time import sleep

counter = 0


def sub_task(string):
    global counter
    while counter < 10:
        print(string, end='', flush=True)
        counter += 1
        sleep(0.01)


def main():
    Process(target=sub_task, args=('Ping', )).start()
    Process(target=sub_task, args=('Pong', )).start()


if __name__ == '__main__':
    main()

#!/usr/bin/env python3 
# coding:utf-8 
# author:ZuoJie
# date:2019/5/16 9:48

import time
import logging
import multiprocessing
from functools import wraps

log_format = "%(asctime)-15s\t %(message)s"
logging.basicConfig(level=logging.INFO, format=log_format)


def run_time(func):
    @wraps(func)
    def func_fun_time(*args, **kwargs):
        start = time.time()
        func(*args, **kwargs)
        logging.info("运行了{}s".format(time.time() - start))

    return func_fun_time


@run_time
def calc(q: multiprocessing.Queue, n: int):
    num = 0
    for _ in range(n):
        num += 1
    q.put(num)


if __name__ == '__main__':
    start = time.time()
    lis = []
    q = multiprocessing.Queue()
    for i in range(2):
        multiprocessing.Process(target=calc, args=(q, 50000000)).start()
    for i in range(2):
        lis.append(q.get())
    print(sum(lis))
    print(time.time() - start)

#!/usr/bin/env python3 
# coding:utf-8 
# author:ZuoJie
# date:2019/5/16 9:48

import time
import logging
import multiprocessing
from functools import wraps

log_format = "%(asctime)-15s\t %(message)s"
logging.basicConfig(level=logging.INFO, format=log_format)


def run_time(func):
    @wraps(func)
    def func_fun_time(*args, **kwargs):
        start = time.time()
        func(*args, **kwargs)
        logging.info("运行了{}s".format(time.time() - start))

    return func_fun_time


@run_time
def calc(n: int):
    num = 0
    for _ in range(n):
        num += 1


if __name__ == '__main__':
    start = time.time()
    pool = multiprocessing.Pool(4)
    for i in range(4):
        pool.apply_async(func=calc, args=(25000000,))
    pool.close()
    pool.join()
    print(time.time() - start)

from concurrent import futures

futures.ThreadPoolExecutor()  # 异步调用线程池
futures.ProcessPoolExecutor()  # 异步调用进程池

#!/usr/bin/env python3 
# coding:utf-8 
# author:ZuoJie
# date:2019/5/16 11:53
import time
import threading
import logging
from concurrent import futures

log_format = "%(asctime)-15s\t %(threadName)s-%(thread)s-%(message)s"
logging.basicConfig(level=logging.INFO, format=log_format)


# futures.ThreadPoolExecutor()  # 异步调用线程池
# futures.ProcessPoolExecutor()  # 异步调用进程池
# f = futures.Future()

def worker(n):
    logging.info("working-{}".format(n))
    time.sleep(5)
    logging.info("end work-{}".format(n))


if __name__ == '__main__':
    # tpe = futures.ThreadPoolExecutor(3)
    tpe = futures.ProcessPoolExecutor(3)
    fs = []

    for i in range(3):
        f = tpe.submit(worker, i)
        fs.append(f)

    for i in range(3, 6):
        f = tpe.submit(worker, i)
        fs.append(f)

    while True:
        time.sleep(2)
        logging.info(threading.enumerate())

        flag = True

        for f in fs:
            flag = flag and f.done()
        if flag:
            tpe.shutdown()
            logging.info(threading.enumerate())
            break

with futures.ProcessPoolExecutor(3) as tpe:
    pass

import time
import tkinter
import tkinter.messagebox


def download():
    # 模拟下载任务需要花费10秒钟时间
    time.sleep(10)
    tkinter.messagebox.showinfo('提示', '下载完成!')


def show_about():
    tkinter.messagebox.showinfo('关于', '作者: 老吴(v1.0)')


def main():
    top = tkinter.Tk()
    top.title('单线程')
    top.geometry('200x150')
    top.wm_attributes('-topmost', True)

    panel = tkinter.Frame(top)
    button1 = tkinter.Button(panel, text='下载', command=download)
    button1.pack(side='left')
    button2 = tkinter.Button(panel, text='关于', command=show_about)
    button2.pack(side='right')
    panel.pack(side='bottom')

    tkinter.mainloop()


if __name__ == '__main__':
    main()

import time
import tkinter
import tkinter.messagebox
from threading import Thread


def main():

    class DownloadTaskHandler(Thread):

        def run(self):
            time.sleep(10)
            tkinter.messagebox.showinfo('提示', '下载完成!')
            # 启用下载按钮
            button1.config(state=tkinter.NORMAL)

    def download():
        # 禁用下载按钮
        button1.config(state=tkinter.DISABLED)
        # 通过daemon参数将线程设置为守护线程(主程序退出就不再保留执行)
        # 在线程中处理耗时间的下载任务
        DownloadTaskHandler(daemon=True).start()

    def show_about():
        tkinter.messagebox.showinfo('关于', '作者: 老吴(v1.0)')

    top = tkinter.Tk()
    top.title('单线程')
    top.geometry('200x150')
    top.wm_attributes('-topmost', 1)

    panel = tkinter.Frame(top)
    button1 = tkinter.Button(panel, text='下载', command=download)
    button1.pack(side='left')
    button2 = tkinter.Button(panel, text='关于', command=show_about)
    button2.pack(side='right')
    panel.pack(side='bottom')

    tkinter.mainloop()


if __name__ == '__main__':
    main()

from time import time


def main():
    total = 0
    number_list = [x for x in range(1, 100000001)]
    start = time()
    for number in number_list:
        total += number
    print(total)
    end = time()
    print('Execution time: %.3fs' % (end - start))


if __name__ == '__main__':
    main()

from multiprocessing import Process, Queue
from random import randint
from time import time


def task_handler(curr_list, result_queue):
    total = 0
    for number in curr_list:
        total += number
    result_queue.put(total)


def main():
    processes = []
    number_list = [x for x in range(1, 100000001)]
    result_queue = Queue()
    index = 0
    # 启动8个进程将数据切片后进行运算
    for _ in range(8):
        p = Process(target=task_handler,
                    args=(number_list[index:index + 12500000], result_queue))
        index += 12500000
        processes.append(p)
        p.start()
    # 开始记录所有进程执行完成花费的时间
    start = time()
    for p in processes:
        p.join()
    # 合并执行结果
    total = 0
    while not result_queue.empty():
        total += result_queue.get()
    print(total)
    end = time()
    print('Execution time: ', (end - start), 's', sep='')


if __name__ == '__main__':
    main()