多任务--线程

1.线程的并发实现以及线程数的显示

import time
import threading #线程（并发）

def sing():
    for i in range(5):
        print("sing--%d" % i)
        time.sleep(1)

def dance():
    for i in range(5):
        print("dance---%d" % i)
        time.sleep(1)


def main():#线程一起执行-假的多任务(时间片轮转)
    t1 = threading.Thread(target = sing)
    t2 = threading.Thread(target = dance)
    t1.start()
    t2.start()

    #查看线程数
    while True:
        print(threading.enumerate())
        if len(threading.enumerate())<=1:
            break
        time.sleep(1)


if __name__ == "__main__":
    main()

2.类线程的并发实现

import threading
import time

class MyThread(threading.Thread):
    def run(self):
        self.sing()
        self.dance()

    def sing(self):
        for i in range(5):
            print("sing--%d" % i)
            time.sleep(1)

    def dance(self):
        for i in range(5):
            print("dance---%d" % i)
            time.sleep(1)

if __name__ == '__main__':
    t1 = MyThread()
    t1.start()
    t2 = MyThread()
    t2.start()

3.多个线程之间共享全局变量实现

#多个线程之间共享全局变量
import threading
import time
#定义一个全局变量
num = 100
data = [11, 22] #传递的参数必须是一个可以迭代的容器

def tes1(temp):
    global num
    num += 1
    print("------test1  num = %d----" % num)
    print("传递数据测试 %s" % str(temp))

def tes2():
    global num
    print("------test2  num = %d----" % num)

def main():
    #target指定将来去哪个函数执行代码
    #args指定将来调用函数的时候传递什么数据过去--传递的参数必须是一个可以迭代的容器
    t1 = threading.Thread(target = tes1, args=(data,))
    t2 = threading.Thread(target = tes2)

    t1.start()
    time.sleep(1)
    t2.start()
    time.sleep(1)

    print("----main  num = %d" % num)


if __name__ == '__main__':
    main()

4.多线程执行当同时进行写操作时出现的错误， 并通过互斥锁的方法进行解决

• 出现问题

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

import threading
import time
#定义一个全局变量
num = 100
data = 1000000 #操作的数越大，共享资源产生的问题就越明显--计算的结果还没有进行赋值就不给分配cpu了

def tes1(temp):
    global num
    for i in range(temp):
        num += 1
    print("------test1  num = %d----" % num)

def tes2(temp):
    global num
    for i in range(temp):
        num += 1
    print("------test2  num = %d----" % num)

def main():
    #target指定将来去哪个函数执行代码
    #args指定将来调用函数的时候传递什么数据过去--传递的参数必须是一个可以迭代的容器
    t1 = threading.Thread(target = tes1, args=(data,))
    t2 = threading.Thread(target = tes2, args=(data,))

    t1.start()
    t2.start()

    #进行延时--保证子线程执行完之前主线程一直存在
    time.sleep(5)



    print("----main  num = %d" % num)


if __name__ == '__main__':
    main()

并没有实现加和为2000100

• 利用互斥锁解决

#多线程共享资源的问题解决--原子性(同步-互斥锁)--成为了串行操作

import threading
import time
#定义一个全局变量
num = 100
data = 1000000 #操作的数越大，共享资源产生的问题就越明显--计算的结果还没有进行赋值就不给分配cpu了


"""串行"""
def tes1(temp):
    global num
    #上锁--谁先抢到锁就先执行谁
    mutex.acquire()
    for i in range(temp):
        num += 1
    #解锁
    mutex.release()
    print("------test1  num = %d----" % num)
def tes2(temp):
    global num
    # 上锁谁先抢到锁就先执行谁
    mutex.acquire()
    for i in range(temp):
        num += 1
    # 解锁
    mutex.release()
    print("------test2  num = %d----" % num)
    
"""并行"""
def tes1(temp):
    global num
    for i in range(temp):
        mutex.acquire()
        num += 1
        mutex.release()
    print("------test1  num = %d----" % num)


def tes2(temp):
    global num
    for i in range(temp):
        mutex.acquire()
        num += 1
        mutex.release()
    print("------test2  num = %d----" % num)


#创建互斥锁,默认没有上锁
mutex = threading.Lock()

def main():
    #target指定将来去哪个函数执行代码
    #args指定将来调用函数的时候传递什么数据过去--传递的参数必须是一个可以迭代的容器
    t1 = threading.Thread(target = tes1, args=(data,))
    t2 = threading.Thread(target = tes2, args=(data,))

    t1.start()
    t2.start()

    #进行延时--保证子线程执行完之前主线程一直存在
    time.sleep(2)



    print("----main  num = %d" % num)


if __name__ == '__main__':
    main()