python-多线程

一、多线程

1.使用threading模块

• import threading

• t = threading.Thread(target=None, name=None, args=（）…)

  • target：调用函数
  • name：线程命名
  • args：传入target对应函数的参数，

• Thread对象的方法：

  • t.start（）：开启线程
  • t.join（）：等待线程结束才会执行下一个线程

# coding=utf-8
import threading
import time


def saySorry():
    print("亲爱的，我错了，我能吃饭了吗？")
    time.sleep(5)


if __name__ == "__main__":
    for i in range(5):
        # 创建线程对象
        t = threading.Thread(target=saySorry)
        t.start()  # 启动线程，即让线程开始执行
        # t.join()  # 等待该线程执行结束

2.线程的封装

• 调用Tread对象的start方法时会调用他的run方法，自定义一个多线程的类，只要继承threading.Thread类，并且重写run方法即可

import threading
import time

class MyThread(threading.Thread):
    def run(self):
        for i in range(3):
            time.sleep(1)
            msg = "I'm "+self.name+' @ '+str(i)
            print(msg)
def test():
    for i in range(5):
        t = MyThread()
        t.start()
if __name__ == '__main__':
    test()

3.互斥锁

3.1多线程共享全局变量：

• 如果多个线程同时对同一个全局变量操作，会出现资源竞争问题，从而数据结果会不正确

3.2解决：

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

threading模块中定义了Lock类，可以方便的处理锁定：
#创建锁
mutex = threading.Lock()
#锁定
mutex.acquire()
#释放
mutex.release()
注意：
如果这个锁之前是没有上锁的，那么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=1909909
—test2—g_num=2000000
2个线程对同一个全局变量操作之后的最终结果是:2000000

3.3上锁解锁过程

当一个线程调用锁的acquire()方法获得锁时，锁就进入“locked”状态。
每次只有一个线程可以获得锁。如果此时另一个线程试图获得这个锁，该线程就会变为“blocked”状态，称为“阻塞”，直到拥有锁的线程调用锁的release()方法释放锁之后，锁进入“unlocked”状态。
线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁，并使得该线程进入运行（running）状态。

总结

锁的好处：

• 确保了某段关键代码只能由一个线程从头到尾完整地执行

锁的坏处：

• 阻止了多线程并发执行，包含锁的某段代码实际上只能以单线程模式执行，效率就大大地下降了
• 由于可以存在多个锁，不同的线程持有不同的锁，并试图获取对方持有的锁时，可能会造成死锁

4.线程池

import time
#导入线程池模块对应的类
from multiprocessing.dummy import Pool
#实例化一个线程池对象
pool = Pool(processes=None)
#将iteravle中每一个元素传递给func进行处理。
pool.map(func, iterable) # 这里的map自带pool.close() 和 pool.join()方法
#关闭线程池
pool.close()
#等待线程池中所有线程执行结束
pool.join()

import time
# 导入线程池模块对应的类
from multiprocessing.dummy import Pool
# 使用线程池方式执行
start_time = time.time()


def get_page(a):
    print("正在下载 ：", a)
    time.sleep(2)
    print('下载成功：', a)


name_list =['xiaozi','aa','bb','cc']


# 实例化一个线程池对象
pool = Pool(4)
# 将列表中每一个列表元素传递给get_page进行处理。
pool.map(get_page, name_list)
# pool.close()
# pool.join()
end_time = time.time()
print(end_time-start_time)