一、多线程技术

1，主线程

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

2，子线程

一个进程中可以有多个线程。除了主线程以外,其他的线程需要手动添加

3，threading是python中的一个内置模块，用来支持多线程

• a,Thread类的对象就是线程对象，需要线程的时候，就创建这个类或者这个类的子类对象

• b,threading.currentThread()--->用来获取当前线程对象

导入模块及创建函数
import threading
import datetime
import time

print(threading.currentThread())

# 下载两个电影
def download(file):
    print('开始下载：',datetime.datetime.now())
    # 让线程阻塞10秒
    time.sleep(10)
    print(file+'下载结束',datetime.datetime.now())

# 1,在主线程中下载两个电影

download('终结者2')
download('沉默的羔羊')

# 2,在两个子线程中下载两个电影

            threading.Thread(target，args)
                  target:需要在子线程中调用的函数的函数名
                  args:函数的实参
                  返回值：创建好的线程


t1=threading.Thread(target=download,args=('终结者',))
t2=threading.Thread(target=download,args=('沉默的羔羊',))

# 开始执行t1对应的线程任务
t1.start()

# 想要在子线程中执行任务，必须通过线程对象调用start方法才行
t2.start()

二、面向对象的多线程技术

1，声明一个类继承自Thread类
2，重写run方法，将需要在子线程中执行的任务放到run方法中
3，在需要子线程的位置去创建这个类的对象，然后用对象调用start方法去执行run中的任务

from threading import Thread
import datetime
import time
==================================
class DownloadThread(Thread):
    def __init__(self,files):
        super().__init__()
        self.files=files

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


# ===============================================
print('=========================')
t1=DownloadThread('沉默的羔羊')
t1.start()
print('++++++++++++++++++++++++')

三、join方法的使用

在两个子线程中下载两个电影，在主线程中去统计两个电影下载的总的时间

如果希望某个线程结束后再执行某个操作，就用那个线程对象调用join函数

from threading import Thread
import time
from datetime import datetime
from random import randint
======================================
class DownloadThread(Thread):

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

    def run(self):
        print(self.file + '开始下载', datetime.now())
        time.sleep(randint(5,10))
        print(self.file + '下载结束', datetime.now())


t1=DownloadThread('美丽的人生')
t2=DownloadThread('怦然心动')

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

# 系统t1，t2中的代码都结束后才执行下面的代码
t1.join()
t2.join()

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

四、线程间的数据共享

from threading import Thread,Lock,RLock
import time
from datetime import datetime
from random import randint
=======================================
模拟多个人对同一个账号进行操作

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


    # 存钱的过程：读出原来的余额，确定钱的一系列操作，将原来的余额加上存的数额产生最新的余额再保存
    def save_money(self,amount):
        '''  存钱  '''
        # 获取原来的余额
        # 加锁
        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):
        '''  取钱  '''
        self.lock.acquire()
        # 获取原来的余额
        old_amount = self.balance
        if old_amount<amount:
            print('余额不足')
            return
        # 模拟时间消耗
        time.sleep(5)
        # 修改余额
        self.balance = old_amount - amount
        print('存钱成功，最新余额：',self.balance)
        self.lock.release()

    def show_balance(self):
        print('当前余额为%.2f'%self.balance)



account=Account(10000)
# account.save_money(1000)
# account.show_balance()
# account.get_money(400)
# account.show_balance()

t1=Thread(target=account.save_money,args=(1000,))
t2=Thread(target=account.get_money,args=(500,))

t1.start()
t2.start()