python中的线程 python中的线程

1、多线程执行

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

import time import threadingdef 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 timeclass 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 = 100def 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 timenum = 0def 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()