python中的线程

1、多线程执行

线程是实现多任务的一种手段。
如果创建Thread时执行的函数，运行结束那么意味着这个子线程结束了...
实例对象调用start，生成子线程，让这个子线程开始运行。函数结束，线程结束
子线程执行时，主线程等待，当子线程结束，主线程才结束
默认主线程最后结束，如果不小心主线程结束了，所有子线程都结束

import time
import threading

def sing():
    '''唱歌 1s一次'''
    for i in range(5):
        print("chang ge")
        time.sleep(1)

def dance():
    '''跳舞 1s一次'''
    for i in range(10):
        print("tiao wu")
        time.sleep(1)

def main():
    #创建了个t1指向,产生实例对象
    t1 = threading.Thread(target=sing) 
    #创建了个t2执行
    t2 = threading.Thread(target=dance) #target赋值函数名，函数的名字就是个变量名 写成dance()叫调用函数 写dance相当于告诉函数在哪

    #生成子线程t1
    t1.start() 
    #生成子线程t2
    t2.start()

    #查看线程数
    while True:
        print(threading.enumerate())
        #当只剩主线程时结束循环
        if len(threading.enumerate()) <= 1:
            break
        time.sleep(1)

if __name__ == "__main__":#主线程
    main()

单核CPU同一时间只做一件事

多核CPU同一时间做多件事

CPU 1s能执行好几百万次，软件之间来回转，达到“一起”运行。
只要程序间切换得足够快，看起来就是一起运行。也就是时间片轮转（是操作系统的调度办法）。

python中的线程就是假的一起运行，由时间片轮转实现

并行：真的多任务（CPU核数>=任务数）

并发：假的多任务（任务数>CPU核数）

一个程序运行起来之后，一定有一个执行代码的东西，这个东西就称之为线程

线程的运行没有先后顺序，所以程序中适当sleep

2、继承下的多线程

import threading
import time

class MyThread(threading.Thread):
    def __init__(self,name):
        threading.Thread.__init__(self)
        self.name = name

    #run必须有，run方法写什么，线程执行什么。
    def run(self):
        self.test1()
        self.test2()

    def test1(self):
        for i in range(5):
            time.sleep(1)
            msg = "I'm " + self.name + " @ " +str(i)
            print(msg)

    def test2(self):
        for i in range(5):
            time.sleep(1)
            msg = "I'm " + self.name + " & " + str(i)
            print(msg)

if __name__ == "__main__":
    t1 = MyThread("t1")
    t2 = MyThread("t2")
    t1.start()#启动线程，调用run方法
    t2.start()

3、多个线程之间共享全局变量

全局变量中是否加global，要看是否对全局变量的指向进行修改。如果修改了指向，即让全局变量指向了一个新的地方，必须使用global。如果修改了指向空间的数据，不用必须加global。

import threading
import time
#全局变量，只要修改的东西不改变地址指向就可以不加global,改变了地址指向就要加global
num = 100

def test1():
    global num
    num += 1
    print("test1 %d"%num)

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

def main():
    t1 = threading.Thread(target=test1)
    t2 = threading.Thread(target=test2)
    t2.start()
    time.sleep(1)
    t1.start()
    time.sleep(1)

    print("main %d"%num)

if __name__ == '__main__':
    main()

import threading
import time
#多个线程之间共享全局变量带参数
nums = [11,22]

def test1(temp):
    temp.append(33)
    print("test1 %s"%str(temp))

def test2(temp):
    temp.append(55)
    print("test2 %s" % str(temp))


def main():
    t1 = threading.Thread(target=test1,args=(nums,))
    t2 = threading.Thread(target=test2,args=(nums,))
    t2.start()
    time.sleep(1)
    t1.start()
    time.sleep(1)

    print("main %s" % str(nums))

if __name__ == '__main__':
    main()

共享数据，多线程配合使用。
共享全局变量之间产生资源竞争。解决方法：线程做事要么不做，要么做全。这个方法体现原子性
同步：协同一起做事，有约定好的规则。

4、互斥锁

当多个线程几乎同时修改某一共享资源时，需进行同步控制。
上锁的代码越少越好

import threading
import time

num = 0

def test1(n):
    global num
    for i in range(n):
        # 上锁，如果之前没有被上锁，那么此时上锁
        # 如果之前上了锁，那么堵塞在这，直到这个锁被解开
        mutex.acquire()
        num += 1   #解析成：获取值，获取值+1，结果存储
        #解锁
        mutex.release()
    print("test1 %d"%num)

def test2(n):
    global num
    for i in range(n):
        mutex.acquire()
        num += 1
        mutex.release()
    print("test2 %d"%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(5)
    print("main %d"%num)

if __name__ == '__main__':
    main()

线程间共享多个资源时，如果两个及以上线程分别占用一部分资源并且同时等待对方资源时，就会造成死锁。多个锁，多个资源。

5、死锁

避免死锁：
1、添加超时时间等
2、银行家算法