day 19 多线程技术

耗时操作

一个进程默认有一个线程，这个线程叫主线程，默认情况下，所有的代码都是在主线程中进行的

import time,datetime


def download(film_name):
    print('开始下载：%s' % film_name, datetime.datetime.now())
    time.sleep(5)  # 程序执行到这个地方，线程会阻塞（停）5秒，在执行后面的代码
    print('%s下载完成' % film_name, datetime.datetime.now())


if __name__ == '__main__':
    # 在主线程中下载两个电影
    download('小黄人大眼萌')
    download('小黄人神偷奶爸')

---

---

多线程

import time, datetime


def download(film_name):
    print('下载%s:' % film_name, threading.current_thread())
    print('开始下载：%s' % film_name, datetime.datetime.now())
    time.sleep(5)  # 程序执行到这个地方，线程会阻塞（停）5秒，在执行后面的代码
    print('%s下载完成' % film_name, datetime.datetime.now())


if __name__ == '__main__':
    # download('小黄人大眼萌')
    # 1.创建线程对象
    """
    a.
    Thread - 线程类
    b.
    Thread(target=函数名，args=参数列表) - 直接创建线程对象,返回线程对象
    函数名 = 需要在当前创建的子线程中执行的函数变量
    参数列表 = 元祖，元祖的元素是调用函数的的时候给函数传的参数
    """
    t1 = threading.Thread(target=download, args=('小黄人大眼萌',))
    t2 = threading.Thread(target=download, args=('小黄人神偷奶爸',))
    #  2.在子线程中执行任务
    """
    在这儿就是调用t1对应的线程中调用download函数，并且传递一个参数'小黄人大眼萌'
    """
    t1.start()
    t2.start()

import requests
import json

url = 'https://www.apiopen.top/satinApi?type=1&page=1'
re1 = requests.get(url)
with open('image/new.json', 'rw') as f:
    f.write(f)
with open('image/new.json', encoding='utf-8') as f:
    content = json.dump(f)


def tupian(url):
    re_data = requests.get(url).content
    with open('image/new.jpg', 'bw') as f:
        f.write(re_data)


datas = content['data']
for key in datas:
    if key == 'profile_image':
        url2 = datas[key]
        t3 = threading.Thread(target=tupian, args=(url2,))
        t3.start()

---

---

线程类的子类

from threading import Thread,current_thread

"""
创建子线程，除了直接创建Thread的对象，还可以创建这个类的子类对象


注意：一个进程中有多个线程，进程会在所有的线程都结束才会结束
      线程中的任务执行完了，线程就结束
"""


# 1.声明一个类继承Thread
class DownloadThread(Thread):
    # 想要给run方法传值通过添加对象属性来传值
    def __init__(self,film_name):
        super().__init__()
        self.film_name = film_name

    # 2.重写run方法
    def run(self):
        # 这个方法中的代码会在子线程中进行
        print(current_thread())
        print('开始下载：%s' % self.film_name)


# 3.创建线程对象
t1 = DownloadThread('小黄人')
# 4.通过线程对象调用start在子线程中执行run方法
t1.start()
# t1.run() # 直接调用run方法会在主线程中执行

---

---

join函数

from threading import Thread
import time,datetime,random
"""
线程对象.join（） - 等待线程对象中的任务完成
"""


class DownloadThread(Thread):

    def __init__(self, flim_name):
        super().__init__()
        self.flim_name = flim_name

    def run(self):
        print('开始下载：%s' % self.flim_name)
        time3 = random.randint(5, 12)
        time.sleep(time3)
        print('%s下载完成,耗时%d' % (self.flim_name, time3))


if __name__ == '__main__':
    t1 = DownloadThread('小黄人大眼萌')
    t2 = DownloadThread('小黄人神偷奶爸')
    time1 = time.time()
    t1.start()
    t2.start()
    # t1和t2都完成了才执行后面的代码
    t1.join()
    t2.join()

    time2 = time.time()
    print(time1)
    print(time2)
    print('总共耗时：', time2-time1)

---

---

数据共享

import time
import threading
"""
注意：当多个线程同时对一个数据进行操作的时候，可能会出现数据混乱
多个线程对一个数据进行操作，一个线程将数据读出来，还没来得及将数据存进去；
另一个线程又去读数据了，这个时候就可能产生数据安全隐患 - 解决方案就是枷锁

Lock - 锁 （创建锁对象）
"""

class Account(object):
    def __init__(self, balance, name):
        self.balance = balance
        self.name = name
        self.lock = threading.Lock()  # 创建锁对象

    def save(self, num):
        self.lock.acquire()
        print('开始存钱')
        old_balance = self.balance
        time.sleep(5)
        self.balance = old_balance + num
        print('存钱成功')
        self.lock.release()

    def draw(self, num):
        self.lock.acquire()
        print('开始取钱')
        old_balance = self.balance
        time.sleep(4)
        self.balance = old_balance - num
        print('取钱成功')
        self.lock.release()


account = Account(1000, '小黄人')

t1 = threading.Thread(target=account.save, args=(1000,))
t2 = threading.Thread(target=account.draw, args=(500,))

t1.start()
t2.start()

t1.join()
t2.join()
print(account.balance)