day 19 - 多线程

1.多线程

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

import time,datetime
def dowmload(film_name):
    print("开始下载%s"%film_name,datetime.datetime.now())
    time.sleep(5) #程序执行到这个地方，线程会阻塞5秒，再执行后面的代码
    print("%s下载结束" %film_name,datetime.datetime.now())
dowmload("小黄人")
dowmload("地心游记")

2.threading模块

python中提供了threading模块，来支持多线程
默认创建的线程叫主线程，其他的线程叫子线程，如果希望代码在子线程中执行
必须手动创建线程对象

3. Thread - 线程类(直接创建)

Thread（target = 函数名，args = 参数列表），直接创建线程对象，返回线程对象
函数名 = 需要在当前创建的子线程中执行的函数变量
参数列表 = 元组，元素

import time,datetime,threading
def dowmload(film_name):
    print("开始下载%s"%film_name,datetime.datetime.now())
    # time.sleep(5) #程序执行到这个地方，线程会阻塞5秒，再执行后面的代码
    print("%s下载结束" %film_name,datetime.datetime.now())
    print("%s下载" %film_name, threading.current_thread())

if __name__ == "__main__":
    dowmload("小黄人")
    # 1.创建线程对象
    t1= threading.Thread(target=dowmload,args=("一本道",))
    t2 = threading.Thread(target=dowmload, args=("色戒",))
    t3 = threading.Thread(target=dowmload, args=("武藤兰",))
    t4 = threading.Thread(target=dowmload, args=("早乙女",))
    # 2.在子线程中执行任务
    t1.start()
    t2.start()
    t3.start()
    t4.start()

4.创建多线程(用类创建)

创建子线程，除了直接创建Thread的对象，还可以创建这个类的子对象
注意：一个进程中有多个线程，进程会在所有的线程都结束才会结束
线程中的任务执行完了，线程就结束了、
步骤：
1.声明一个类继承Thread
2.重写run方法
3.想要给run方法传值通过调用对象属性来传值

4. 创建线程对象
   5.通过线程对象调用strat去子线程中执行run方法
   t1.run() # 直接调用run方法会在主线程中执行，

class DownloadThread(Thread):
    def __init__(self,film_name):
        super().__init__()
        self.file_name = film_name
    def run(self):
        print("开始下载%s"%self.file_name,current_thread())
t1 = DownloadThread("小黄人")
t1.start()

5.线程对象。join() - 等待线程对象中任务执行完成

from threading import Thread
import time,datetime,random
class Download(Thread):
    def __init__(self,name):
        super().__init__()
        self.name = name
    def run(self):
        print("开始下载%s"%self.name)
        a = random.randint(5,12)
        time.sleep(a)
        print("%s下载结束"%self.name)
if __name__ == "__main__":
    t1 = Download("野结衣")
    t2 = Download("金手指")
    time1 = time.time()
    t1.start()
    t2.start()
    # t1和t2都执行完城后才执行后面的代码啊
    t1.join()
    t2.join()
    time2 = time.time()
    print("总共时间",time2-time1)

6.数据共享安全问题及解决方案

多个线程对一个数据进行操作，一个线程将数据读出来，还没有来得及存进去，另一个线程又去读了，这个时候就可能存在安全隐患

解决问题的方式：加锁
Thread - 线程类（创建子线程）
Lock - 锁（创建锁对象）
举例：支付宝存钱和银行卡取钱，为了避免数据混乱的情况，用加锁的方式进行操作

import time,threading
class Account(object):
    """
    注意：当多个线程同时对一个数据进行操作时，可能会出现数据混乱
    """
    def __init__(self,balance,name):
        self.balance = balance
        self.name = name
        self.lock = threading.Lock()
    def save(self,num):
        #加锁
        print("存钱ing")
        self.lock.acquire()
        old_balance = self.balance
        time.sleep(5)
        self.balance = old_balance + num
        print("存钱成功")
        self.lock.release()
    def draw(self,num):
        print("取钱ing")
        self.lock.acquire()
        old_balance = self.balance
        time.sleep(5)
        self.balance = old_balance - num
        print("取钱成功")
        self.lock.release()
account1 = Account(1000,"lorry")
#支付宝存钱
t1 = threading.Thread(target=account1.save,args=(1000,))
t2 = threading.Thread(target=account1.draw,args=(500,))
t1.start();t2.start()
t1.join();t2.join()
print(account1.balance)

举例：服务器客户端多线程（多人）的聊天

#服务器多线程处理：
import socket
from threading import Thread
server = socket.socket()
server.bind(("10.7.187.128",9091))
server.listen(1024)
class Listen(Thread):
    def __init__(self,conversation,addr):
        super().__init__()
        self.conversation = conversation
        self.addr = addr
    def run(self):
        while True:
            message = self.conversation.recv(1024).decode("utf-8")
            print(self.addr, ":" + message, sep="")
while True:
    conversation,addr = server.accept()
    L1 = Listen(conversation,addr)
    L1.start()

#客户端多线程处理：
import socket
client = socket.socket()
client.connect(("10.7.187.128",9091))
while True:
    message = input("自己：")
    client.send(message.encode("utf-8"))