from threading import *
import time
from datetime import datetime
导入模块

1.创建自己的线程类
1)声明一个类继承Thread
2)实现run方法,这个方法中的任务就是需要在子线程中执行的任务
注意: 一个进程中如果有多个线程，程序会在所有的线程都结束的时候才结束;
发生异常崩溃其实奔溃的是线程

class DownloadThread(Thread):
    def __init__(self, film_name):
        super().__init__()
        self.film_name = film_name

    def run(self):
        # print(current_thread())
        # print('在子线程中执行的代码')
        print('开始下载: %s' % self.film_name, datetime.now())
        print([1, 2][3])
        time.sleep(6)
        print('结束下载: %s' % self.film_name, datetime.now())

3)用子类直接创建线程对象

t1 = DownloadThread('复联4')
t2 = DownloadThread('长江7号')

4)通过start去执行子线程中的任务

t1.start()
t2.start()

t1.run() # 不能直接调用run方法,因为这样调用不会在子线程中执行任务

1.join

如果希望某个任务是在某个线程结束后才执行，那就将这个任务的带放在对应线程对象调用join方法的后面

import time
from threading import Thread, Lock

锁的使用:

1.问题
当多个线程同时对一个数据进行读写操作，可能会出现一个线程刚把数据读出来还没来得及写进去，另外一个线程进行读操作的数据安全问题。
(多个人上一个厕所，一个人进去了还没出来，另外一个人又进去的问题)
2.解决 - 加锁
1）保证每个数据对应一个锁对象
2）操作数据前加锁，数据操作完成后释放锁

class Account:
    def __init__(self, name, tel, balance=50):
        self.name = name
        self.tel = tel
        self.balance = balance
        # 关联一个锁对象
        self.lock = Lock()

    def save_money(self, money):
        print('开始存钱')
        # 加锁
        self.lock.acquire()
        value = self.balance
        time.sleep(4)
        self.balance = value+money
        print('存钱成功: %.2f' % self.balance)
        # 释放锁
        self.lock.release()

    def draw_money(self, money):
        print('开始取钱')
        # 加锁
        self.lock.acquire()
        value = self.balance
        time.sleep(5)
        if value < money:
            print('取钱失败！余额不足')
            return
        self.balance = value - money
        print('取钱成功:%.2f' % self.balance)
        # 释放锁
        self.lock.release()


acount = Account('余婷', '15300022703', 10000)

# 一个线程去存钱
t1 = Thread(target=acount.save_money, args=(1000,))
# 一个线程去取钱
t2 = Thread(target=acount.draw_money, args=(500,))