2 Python高级

二. 多任务

 单核cpu完成多个程序运行，时间片轮转。

线程

Thread创建线程，完成多任务：

import threading
import time
#线程（Thread）是操作系统能够进行运算调度的最小单位。
# 它被包含在进程之中，是进程中的实际运作单位。
# 一个线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每个线程并行执行不同的任务。
#threading 模块提供了一个 Thread 类来代表一个线程对象
def sayhello():
    print("----hello----")
    time.sleep(1)
def  main():
    for i in range(5):
        t = threading.Thread(target=sayhello)
        t.start()#启动线程 即让线程开始执行

if __name__ == '__main__':
    main()

def test1():
    for i in range(5):
        print("----test1--- %s"  % i)
        time.sleep(1)
#如果创建Thread时执行的函数运行结束那么意味着 这个子线程结束
def test2():
    for i in range(10):
        print('----test2--- %s' % i)
        time.sleep(1)
def  main():
    t1 = threading.Thread(target=test1)
    t2 = threading.Thread(target=test2)

    t1.start()
    t2.start()
    while True:
        lenth = len(threading.enumerate())#查看当时有多少个线程在工作
        print(lenth)
        if lenth <= 1:
            break
        time.sleep(1)
#主线程只有等子线程结束后才结束
if __name__ == '__main__':
    main()

调用Thread仅仅是创建了一个对象，创建线程是从start开始。

通过使用threading模块能完成多任务的程序开发，为了让每个线程的封装性更完美，可以使用threading模块时，定义一个新的子类class，只要继承threading.Thread就可以，重写run方法。

class MyThread(threading.Thread):
    def run(self):
        for i in range(3):
            time.sleep(1)
            msg = "I'm" + self.name + str(i)#name属性中保存的是当前线程的名字
            print(msg)
if __name__ == '__main__':
    t = MyThread()
    t.start()#start自己调用run方法

多线程共享全局变量

在一个函数中对全局变量进行修改时，是否需要使用global？要看是否对全局变量的指向进行了修改。如果要让全局变量指向新的地址，必须用global。

g_num = 100
def test1():
    global g_num
    g_num+=100
    print("--test1 %d" % g_num)

def test2():
    print("test2 %d" % g_num)

def main():
    t1 = threading.Thread(target=test1)
    t2 = threading.Thread(target=test2)

    t1.start()
    time.sleep(1)
    t2.start()
    time.sleep(1)
    print("--in main g_num %s"% g_num)

if __name__ == '__main__':
    main()

g_num = [11,22]
def test1(temp):
    temp.append(33)
    print("--test1 %s" % str(temp))

def test2(temp):
    print("--test12 %s" % str(temp))

def main():
    #target指定将来这个线程去哪个函数执行代码
    #args指定将来调用函数的时候 传递什么数据过去 args传的是元组
    t1 = threading.Thread(target=test1,args=(g_num,))
    t2 = threading.Thread(target=test2,args=(g_num,))

    t1.start()
    time.sleep(1)
    t2.start()
    time.sleep(1)
    print("--in main g_num %s"% g_num)

if __name__ == '__main__':
    main()

共享全局变量的问题---资源竞争

比如多个线程对同一个全局变量进行相加操作，会导致一个线程还未做完加法操作还未完成最后一步，另一个线程就工作了，导致两次的结果是一样的。

同步，就是协同步调，按先后次序进行。

当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制。线程同步能够保证线程安全访问竞争资源，最简单的同步机制是引入互斥锁。

互斥锁为资源引入一个状态：锁定/非锁定

某个线程要更改共享数据时，先将其锁定，此时资源状态为锁定，其他线程不能更改，知道该线程释放资源，资源变为非锁定，其他线程才能锁定，互斥锁保证了每次只有一个线程进行写入操作。

 互斥锁解决资源竞争： 1.方法 只有当一个线程结束后 另一个线程才工作

g_num = 0
def test1(num):
    global g_num
    #上锁 如果之前没有上锁 那么此时 上锁成功
    #如果上锁之前 已经被上锁了那么此时会堵塞在这里 知道这个锁被解开为止
    mutex.acquire()
    for i in range(num):
        g_num+=1
    #解锁
    mutex.release()
    print("--test1 %d" % g_num)

def test2(num):
    global g_num
    mutex.acquire()
    for i in range(num):
        g_num+=1
    mutex.release()
    print("test2 %d" % g_num)
#创建互斥锁 默认没有上锁
mutex = threading.Lock()
def main():
    t1 = threading.Thread(target=test1,args=(1000000,))
    t2 = threading.Thread(target=test2,args=(1000000,))

    t1.start()
    t2.start()
    time.sleep(2)
    print("--in main g_num %s"% g_num)

if __name__ == '__main__':
    main()

2方法 两个线程无规律的工作

g_num = 0
def test1(num):
    global g_num

    for i in range(num):
        # 上锁 如果之前没有上锁 那么此时 上锁成功
        # 如果上锁之前 已经被上锁了那么此时会堵塞在这里 知道这个锁被解开为止
        mutex.acquire()
        g_num+=1#相当于加锁只加了这一句代码
        #解锁
        mutex.release()
    print("--test1 %d" % g_num)

def test2(num):
    global g_num

    for i in range(num):
        mutex.acquire()
        g_num+=1
        mutex.release()
    print("test2 %d" % g_num)
#创建互斥锁 默认没有上锁
mutex = threading.Lock()
def main():
    t1 = threading.Thread(target=test1,args=(1000000,))
    t2 = threading.Thread(target=test2,args=(1000000,))
    t1.start()
    t2.start()
    time.sleep(2)
    print("--in main g_num %s"% g_num)

if __name__ == '__main__':
    main()

死锁

在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。比如一个线程对A上锁 运行过程中又要对B上锁  而另一个线程对B上锁，运行过程中又要对A上锁，但是A B都还未解锁，就造成了死锁。

避免死锁：添加超时时间（如果上不了锁 就不上了）；逻辑上避免

多线程UDP聊天器

def recv(udp_socket):#接收数据
    while True:
        recv_mes = udp_socket.recvfrom()
        print(recv_mes)
def send(udp_socket,dest_ip,dest_port):#发送数据
    while True:
        send_data = input("输入发送内容： ")
        udp_socket.sendto(send_data.encode('utf-8'),(dest_ip,dest_port))
def main():
    '''完成udp聊天器的整体控制'''
    udp_socket = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
    #绑定本地信息
    udp_socket.bind('',8080)
    dest_ip = input('输入接收方IP： ')
    dest_port = int(input("输入接收方端口： "))
    #创建两个线程 完成两个函数的功能
    t1 = threading.Thread(target=recv, args=(udp_socket, dest_ip, dest_port))
    t2 = threading.Thread(target=send, args=(udp_socket, dest_ip, dest_port))
    t1.start()
    t2.start()
    
if __name__ == '__main__':
    main()