1

方法一

'''
1.主线程
每个进程默认都会有一个线程，这个线程我们一般叫主线程
默认情况下，所有的代码都是在主线程下执行

2.子线程
一个进程中可以有多个线程。除了主线程以外，其他的线程需要主动的添加。

3.threading内置模块支持多线程。
a.Thread类的对象就是线程对象，需要线程的时候,就创建这个类或者这个类的子类对象
b.threading.current_thread()---->用来获取当前线程对象。
'''
import threading
import datetime
import time
def download(file):
    print(threading.current_thread())
    print('开始下载:%s' % file,datetime.datetime.now())
    time.sleep(5)
    print('下载结束:%s' % file,datetime.datetime.now())

if __name__ == '__main__':
    print('主线程')
    print(threading.current_thread())
    #1.在主线程中下载两个电影
    # download('火影忍者')
    # download('秦时明月')

    #2.在子线程中下载两个电影
    '''
    Thread(target,args)
    target:需要在子线程中调用的函数的函数名
    args:函数的实参(元组)
    '''
    t1 = threading.Thread(target=download, args=('火影忍者',))
    #开始执行t1对应的线程任务
    t1.start()

    t2 = threading.Thread(target=download,args=('秦时明月',))
    t2.start()

    print('===========')

方法二

from threading import Thread
import datetime
import time
'''
面向对象实现多线程
1.声明一个类继承Thread类
2.重写run方法,将需要在子线程中的任务放到run方法中
3.在需要子线程的位置去创建这个类的对象,然后用对象调用start()方法去执行run中的方法。
'''
class DownloadThread(Thread):
    def __init__(self,filename):
        super().__init__()
        self.filename = filename
    def run(self):
        print('开始下载:%s' % self.filename, datetime.datetime.now())
        time.sleep(5)
        print('下载结束:%s' % self.filename, datetime.datetime.now())

if __name__ == '__main__':
    t1 = DownloadThread('沉默的羔羊')
    t1.start()
    print('===================================')

2.jion()方法

'''
如果希望某个线程结束后才执行某个操作就用那个线程调用join()函数。
'''
"""__author__=txf"""
import threading
import time
import datetime

class DownThread(threading.Thread):
    def __init__(self,file):
        super().__init__()
        self.filename = file

    def run(self):
        print('开始下载:%s' % self.filename, datetime.datetime.now())
        time.sleep(5)
        print('下载结束:%s' % self.filename, datetime.datetime.now())



if __name__ == '__main__':
    t1 = DownThread('nnnnnn')
    t2 = DownThread('qqqqqqq')

    start = time.time()
    t1.start()
    t2.start()

    #代表t1执行完，在执行后面的
    t1.join()
    t2.join()

    end = time.time()
    print(end - start)

3.线程间的数据共享

"""
模拟多个人对同一个账号进行操作

同步锁(RLock)和互斥锁(Lock)
"""
import time
from threading import Thread, Lock, RLock


class Account:
    """账号类"""
    def __init__(self, balance):
        # 余额
        self.balance = balance
        # 创建锁对象
        self.lock = Lock()
        self.lock2 = RLock()


    # 存钱的过程：读出原来的余额，确定钱的一系列操作，将原来的余额加上存的数额产生最新的余额再保存
    def save_money(self, amount):
        """存钱"""
        print('开始存钱')
        # 加锁
        self.lock.acquire()
        # 获取原来的余额
        old_amount = self.balance
        # 模拟时间消耗
        time.sleep(5)
        # 修改余额
        self.balance = old_amount + amount
        print('存钱成功!,最新余额是:', self.balance)
        # 解锁
        self.lock.release()

    def get_money(self, amount):
        """取钱"""
        print('开始取钱')
        old_amount = self.balance
        if old_amount < amount:
            print('余额不足!')
            return
        time.sleep(5)
        self.balance = old_amount - amount
        print('取钱成功,最新余额是:',self.balance)

    def show_balance(self):
        print('当前余额为:', self.balance)


if __name__ == '__main__':
    # 创建账号
    account = Account(1000)

    # account.save_money(200)
    # account.save_money(1300)
    # account.get_money(800)
    # account.show_balance()
    """
    当多个线程同时对一个数据进行操作的时候，可能会出现数据混乱的问题
    """
    t1 = Thread(target=account.save_money, args=(200,))
    t2 = Thread(target=account.save_money, args=(1300,))

    t1.start()
    t2.start()