Python 线程的常规使用之Threading

目录

什么是线程

threading模块  普通创建

自定义线程

守护线程

主线程等待子线程结束

多线程之间共享全局变量

互斥锁

---

什么是线程

线程是操作系统能够进行运算调度的最小单位 ,他被包含在进程当中,是进程中的实际运作单位

线程是CPU调度的最小单位
进程是资源分配和调度的最小单位

 

threading模块  普通创建

def run(n):
    print("task", n)
    time.sleep(1)
    print("3")
    time.sleep(1)
    print("2")
    time.sleep(1)
    print("1")
if __name__ == '__main__':
    t1 = threading.Thread(target=run, args=("t1",))
    t2 = threading.Thread(target=run, args=("t2",))
    t1.start()
    t2.start()


----------------------------
task t1
task t2
3
3
2
2
1
1

 

自定义线程

继承自threading.thread    必须重写run方法

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

    def run(self):
        print("task", self.n)
        time.sleep(1)
        print('2s')
        time.sleep(1)
        print('1s')
        time.sleep(1)
        print('0s')
        time.sleep(1)

if __name__ == "__main__":
    t1 = MyThread("t1")
    t2 = MyThread("t2")
    t1.start()
    t2.start()
------------------------------------------------
task t1
task t2
2s
2s
1s
1s
0s
0s

 

守护线程

使用setDaemon(True)把所有的子线程都变成了主线程的守护线程，因此当主进程结束后，子线程也会随之结束。所以当主线程结束后，整个程序就退出了 .

import threading
import time

def run(n):
    print("task", n)
    time.sleep(1)       
    print('3')
    time.sleep(1)
    print('2')
    time.sleep(1)
    print('1')

if __name__ == '__main__':
    t = threading.Thread(target=run, args=("t1",))
    t.setDaemon(True)   #把子进程设置为守护线程，必须在start()之前设置
    t.start()
    print("end")
   
-------------------------------------
task t1
end

主线程等待子线程结束

使用join方法   可以实现 让子线程全部结束后,主线程在结束 end       

 和setDaemon(False)不一样,setDaemon(False)是主线程跑完在等子线程结束       运行结果(task t1 end 3 2 1 )

import threading
import time

def run(n):
    print("task", n)
    time.sleep(1)       #此时子线程停1s
    print('3')
    time.sleep(1)
    print('2')
    time.sleep(1)
    print('1')

if __name__ == '__main__':
    t = threading.Thread(target=run, args=("t1",))
    t.setDaemon(True)   #把子进程设置为守护线程，必须在start()之前设置
    t.start()
    t.join() # 设置主线程等待子线程结束
    print("end")
---------------------------------
task t1
3
2
1
end

 

多线程之间共享全局变量

 

import threading
import time

g_num = 100

def work1():
    global g_num
    for i in range(3):
        g_num += 1
    print("in work1 g_num is : %d" % g_num)

def work2():
    global g_num
    print("in work2 g_num is : %d" % g_num)

if __name__ == '__main__':
    t1 = threading.Thread(target=work1)
    t1.start()
    time.sleep(1)
    t2 = threading.Thread(target=work2)
    t2.start()


------------------------------------------------
in work1 g_num is : 103
in work2 g_num is : 103

 

互斥锁

当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制

线程同步能够保证多个线程安全访问竞争资源，最简单的同步机制是引入互斥锁。

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

某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。

 

注意：

• 如果这个锁之前是没有上锁的，那么acquire不会堵塞
• 如果在调用acquire对这个锁上锁之前 它已经被 其他线程上了锁，那么此时acquire会堵塞，直到这个锁被解锁为止

下面是对一个全局变量 各加一百万次的结果  可以看到 如果不加锁 数据差异很大

import threading
import time

g_num = 0

def test1(num):
    global g_num
    for i in range(num):
        mutex.acquire()  # 上锁
        g_num += 1
        mutex.release()  # 解锁

    print("---test1---g_num=%d"%g_num)

def test2(num):
    global g_num
    for i in range(num):
        mutex.acquire()  # 上锁
        g_num += 1
        mutex.release()  # 解锁

    print("---test2---g_num=%d"%g_num)

# 创建一个互斥锁
# 默认是未上锁的状态
mutex = threading.Lock()

# 创建2个线程，让他们各自对g_num加1000000次
p1 = threading.Thread(target=test1, args=(1000000,))
p1.start()

p2 = threading.Thread(target=test2, args=(1000000,))
p2.start()

# 等待计算完成
while len(threading.enumerate()) != 1:
    time.sleep(1)

print("2个线程对同一个全局变量操作之后的最终结果是:%s" % g_num)

-------------------------------
不加锁
---test1---g_num=1130088
---test2---g_num=1272340
2个线程对同一个全局变量操作之后的最终结果是:1272340
-------------------------------
加锁
---test1---g_num=1835828
---test2---g_num=2000000
2个线程对同一个全局变量操作之后的最终结果是:2000000