python学习笔记(十八)线程使用

线程使用

线程简介

线程可以认为是轻量级的进程
一个进程至少包含一个线程(主线程)
线程是CPU分配时间(任务调度)的基本单位，调度是操作系统的事
进程之间的数据是独立的，线程之前的数据是共享
一个进程实现多任务，创建多个线程就可以了

线程模块

_thread：低级模块，使用不够方便和灵活，很少使用
threading：高级模块，是对_thread模块的封装，推荐使用
_thread

示例：

import _thread
import time

def loop(num):
    print('子线程开始')
    print('子线程任务:', num)
    print('子线程结束') 
    
if __name__ == '__main__':  
    print('主线程开始')
    # 启动一个子线程
    _thread.start_new_thread(loop, (250,))
    time.sleep(2)
    print('主线程结束')
###threading

基本使用

import threading
import time

def run(file):
    print(file, '开始下载')
    ct = threading.current_thread()
    print(ct.name)
    for i in range(1, 6):
        time.sleep(1)
        print('已下载{}%...'.format(i * 20))
	print(file, '下载完成')   
    
if __name__ == '__main__':
    print('主线程开始')
    # 获取主线程
    mt = threading.main_thread()
    print('主线程：', mt.name)

    # 获取当前线程
    ct = threading.current_thread()
    print('当前线程：', ct.name)

    # 创建子线程
    thr = threading.Thread(target=run, args=('meinv.jpg',), name='图片下载')

    # 查看活跃线程数量
    print('活跃线程数量:', threading.active_count())
    # 查看线程活跃状态
    print('线程是否启动:', thr.is_alive())
    # 启动线程
    thr.start()

    print('活跃线程数量:', threading.active_count())
    print('线程是否启动:', thr.is_alive())

    # 查看线程信息
    print('线程信息:', threading.enumerate())

    # 等待子线程结束
    thr.join()

    print('主线程结束')

数据共享

import threading

# 全局变量：线程之间可以共享
num = 250

def run():
    global num
    num += 10
    print('子线程修改全局变量') 
    
if __name__ == '__main__':
    thr = threading.Thread(target=run)
    thr.start()
    thr.join()
    print('主进程结束', num)    

线程锁

import threading

money = 250

def run(n):
    global money
    for i in range(100000):
        '''
        # 获取锁
        lock.acquire()
      	try:
          	money += n
          	money -= n
      	except Exception as e:
          	print('出现异常:', e)
      	finally:
          	# 释放锁
          	lock.release()
      	'''
		# 简化操作
        with lock:
            money += n
            money -= n   
            
if __name__ == '__main__':
    # 创建线程锁
    lock = threading.Lock()
    while True:
        thr1 = threading.Thread(target=run, args=(5,))
        thr2 = threading.Thread(target=run, args=(10,))
        thr1.start()
        thr2.start()
        thr1.join()
        thr2.join()
        if money != 250:
            break
	print(money)

线程类

from threading import Thread
import time

# 自定义线程类
class EmailThread(Thread):
    def __init__(self, email):
        super().__init__()
        self.email = email

	def run(self):
        print('邮件发送开始')
        print('发送邮件:', self.email)
        for i in range(1, 6):
            print('发送进度:{}%'.format(i * 20))
            time.sleep(1)
            print('邮件发送结束')
            
if __name__ == '__main__':
    print('主线程开始')
    thr = EmailThread('恭喜你中奖了！')
    thr.start()
    thr.join()
    print('主线程结束') 

定时线程：延时线程

import threading
import os

def run():
    os.system('calc')
    
if __name__ == '__main__':
    # 创建定时线程：3秒后开始执行线程任务
    t = threading.Timer(3, run)
    t.start()
    t.join()

信号传递：控制另一线程的执行

import threading
import time

def run(num):
    for i in range(num):
        # 等待条件成立，程序会阻塞
        e.wait()
        print('子线程执行：{}'.format(i+1))
        # 清除条件，再次wait又会阻塞
        e.clear()  
        
if __name__ == '__main__':
    e = threading.Event()
    num = 3
    thr = threading.Thread(target=run, args=(num,))
    thr.start()
    for i in range(num):
        time.sleep(1)
        # 设置条件，wait处将不再阻塞
        e.set()
        print('正常使用')