02-02-01
不管进程还是线程，主都会等着子结束而结束这是因为子进程/线程在执行的时候，会暂用一些资源，主就要收回这些资源
线程是系统调度的基本单位，进程是系统资源的基本单位
主线程会等待子线程结束才结束
import threading
import time
def sayHello():
print("------")
time.sleep(1)
for i in range(5):
t = threading.Thread(target=sayHello)
t.start()
print("*******")
Result：
------
------
------
------
------
******* #多个线程执行同一个函数，不会互相影响
#####################使用thread子类完成创建多线程###########
import threading
import time
class myThread(threading.Thread):
def run(self):
for i in range(3):
time.sleep(1)
print(self.name+"num"+str(i)) #self.name保存的是当前的线程名字
if __name__ == "__main__":
t = myThread()
t.start() #MyThread没有start方法，为啥可以使用呢，这是threading.Thread中start去调用myThread的run方法
线程的执行顺序：
线程的执行顺序没有固定的，各个线程执行顺序不固定
线程共享全局变量：
线程全局变量是共用的，一个线程的更改其它线程使用也是更改的；而进程是相互独立的，一个进程修改不会对另一个进程产生影响
import time
import threading
g_num = 0
def work1():
global g_num
g_num += 1
print("work1, gum is %d"%g_num)
def work2():
global g_num
print("work2, gum is %d"%g_num)
t1 = threading.Thread(target = work1)
t1.start()
time.sleep(1)
t2 = threading.Thread(target = work2)
t2.start()
result:
work1, gum is 1
work2, gum is 1
列表作为参数传递也可以共享，变量不行需要global
import time
import threading
def work1(g_num):
g_num.append(4)
print("work1, guum is", g_num)
def work2(g_num):
time.sleep(1)
print("work2, guum is", g_num)
g_num = [1,2,3]
t1 = threading.Thread(target = work1, args=(g_num,))
t1.start()
t2 = threading.Thread(target = work2, args=(g_num,))
t2.start()
Result:
work1, guum is [1, 2, 3, 4]
work2, guum is [1, 2, 3, 4]
####互斥锁
当多个线程同时竞争同一个资源的的时候
互斥锁是加的code范围越小越好，加的太多越来越像单任务
比如下面如果在for循环外面加就跟单任务很相似
import threading
g_num = 0
def work1():
global g_num
#这个线程和work2都在抢着对这个锁进行上锁，如果一方的锁上锁成功，那么另一方需要需要一直等待，知道这个锁释放为
for i in range(1000000):
mutex.acquire()
g_num += 1
mutex.release() #解锁
print("work1, guum is %d"%g_num)
def work2():
global g_num
for i in range(1000000):
mutex.acquire()
g_num += 1
mutex.release()
print("work1, guum is %d"%g_num)
#创建一把锁，这个锁默认是没有上锁的
mutex = threading.Lock()
t1 = threading.Thread(target = work1)
t1.start()
#t1.join()
t2 = threading.Thread(target = work2)
t2.start()
#t2.join()
多线程使用非共享变量
创建一个函数，多线程访问一个函数时，每个线程访问这个函数的变量值时独有的
通过线程名来判断
import threading
import time
def work1():
name = threading.current_thread().name #取线程名字比如 Thread-1 Main thread...
print("---thread name---%s"%name)
num = 0
if name == "Thread-1":
num += 1
else:
time.sleep(1)
print("thread name is %s---num is %d"%(name, num))
t1 = threading.Thread(target = work1)
t1.start()
#t1.join()
t2 = threading.Thread(target = work1)
t2.start()
#t2.join()
result:
---thread name---Thread-1
thread name is Thread-1---num is 1
---thread name---Thread-2
thread name is Thread-2---num is 0
死锁以及解决方法
加入超时时间：
注意acquire()这个上锁方法是阻塞的等在条件满足，不满足条件一直会卡在这里，下面就是一个死锁
class MyThread1(Thread):
def run(self):
if mutex1.acquire():
print("----------")
time.sleep(1)
if mutex2.acquire():
print("**********")
mutex2.release()
class MyThread2(Thread):
def run(self):
if mutex2.acquire():
print("###############")
time.sleep(1)
if mutex1.acquire():
print("$$$$$$$$$$")
mutex1.release()
if __name__ == "__main__":
mutex1 = Lock()
mutex2 = Lock()
t1 = MyThread1()
t2 = MyThread2()
t1.start()
t2.start()
result：
----------
###############
mutex.acquire(2)###2s之后还不能上锁的化，就继续往下走
同步的理解与应用
代码按照一定规律去执行, 不然很难保证task1 task2 task3依次输出
按照规定的先后顺序执行
import threading
import time
class Task1(threading.Thread):
def run(self):
while True:
if lock1.acquire():
print("----Task1----")
time.sleep(1)
lock2.release()
class Task2(threading.Thread):
def run(self):
while True:
if lock2.acquire():
print("----Task2----")
time.sleep(1)
lock3.release()
class Task3(threading.Thread):
def run(self):
while True:
if lock3.acquire():
print("----Task3----")
time.sleep(1)
lock1.release()
if __name__ == "__main__":
lock1 = threading.Lock()
lock2 = threading.Lock()
lock2.acquire()
lock3 = threading.Lock()
lock3.acquire()
t1 = Task1()
t2 = Task2()
t3 = Task3()
t1.start()
t2.start()
t3.start()
result:
----Task1----
----Task2----
----Task3----
----Task1----
----Task2----
----Task3----
----Task1----
----Task2----
....
异步： 就是不确定哪一个先执行
