python线程代码_Python全栈开发：线程代码实例

#进程与线程的关系

"""

多进程(主进程，子进程)：

优点：能同时利用多个CPU,进行多个操作，提高效率。

缺点：耗费内存资源(进程要开辟内存空间)，进程不是越多越好，CPU个数 = 进程个数。

注意：进程创建内存空间，线程共享内存空间，进程里有全局解释器锁，进程中一次只应许一个线程被处理。

使用场景：计算密集型适合多进程。

多线程(主线程，子线程)：

优点：共享内存，IO操作时(不用CPU)，创造并发操作(多个操作同时进行)，提高效率。

缺点：抢占资源，请求上下文切换非常耗时(线程处理切换后找到上次处理的地方)，线程不是越多越好，视具体案例而定。

注意：在计算机中，执行任务的最小单元就是线程。

使用场景：IO密集型适合多线程。

"""

"""

队列queue

先进先出，一边放，另一边取

可设置最大个数，get等待，get_nowait不等待

"""

"""

使用线程

1、创建线程

import threading

import time

def f1():

pass

def f2(a1, a2):

time.sleep(10)

pass

t = threading.Thread(target=f1, args=(11,22,33))

t.start() # 线程开始跑，创建的是子线程

2、线程锁

防止出现脏数据，一个线程读取数据并对其加锁，CPU切换线程后其他线程不能读取数据，

3、线程池

Python内部没有提供线程池，需要自定义

"""

import threading

import time

def f1():

pass

def f2(a1, a2):

time.sleep(10)

pass

t1 = threading.Thread(target=f2, args=(11, 22))

t1.setDaemon(True) # 主线程是否等待子线程

t1.start() # 线程开始跑，创建的是子线程

print("第一次等待中")

t1.join(2) # 主线程等待子线程多久，不加参数无限等待

t2 = threading.Thread(target=f2, args=(11, 22))

t2.setDaemon(True)

t2.start() # 线程开始跑，创建的是子线程

print("第二次等待中")

t2.join(2) # 主线程等待子线程的执行的最多等待时间，超过时间，主线程继续执行下一部分

t3 = threading.Thread(target=f2, args=(11, 22))

t3.setDaemon(True) # 主线程执行完(解释器执行代码)，是否等待子线程执行完再关闭，True:不等待：False:等待。默认为False

t3.start() # 线程开始跑，创建的是子线程

线程event

#!/usr/bin/env python

# -*- coding;utf-8 -*-

"""

线程event

"""

import threading

import time

def do(event):

print("线程前半部分")

event.wait() # 阻塞(十字路口)，红灯则等待，绿灯则继续执行

print("线程后半部分")

event_obj = threading.Event()

for i in range(10):

t = threading.Thread(target=do, args=(event_obj,))

t.start()

# 耗时十分钟

# time.sleep(10)

event_obj.clear() # 让灯变红

inp = input("请输入内容：>>>")

if inp == "true":

event_obj.set() # 让灯变绿，线程就都可以继续执行

线程数据共享

#!/usr/bin/env python

# -*- coding;utf-8 -*-

"""

默认情况下线程数据不共享

线程与线程之间数据可以共享

"""

from threading import Thread

li = []

def foo(i):

li.append(i)

print("hello", li)

if __name__ == "__main__":

for i in range(10):

t = Thread(target=foo, args=(i,))

t.start()

线程池

简单线程池

#!/usr/bin/env python

# -*- coding;utf-8 -*-

"""

自定义线程池博客园教程地址

http://www.cnblogs.com/wupeiqi/articles/4839959.html

"""

import queue

import threading

import time

class ThreadPool(object):

def __init__(self, max_num=20):

self.queue = queue.Queue(max_num)

for i in range(max_num):

self.queue.put(threading.Thread)

def get_thread(self):

return self.queue.get()

def add_thread(self):

self.queue.put(threading.Thread)

def func(i, arg):

print(i)

time.sleep(4)

# 在队列中增加线程类

arg.add_thread()

if __name__ == "__main__":

# 在队列中创建线程类

pool = ThreadPool(10)

for i in range(30):

# 获得类

thread = pool.get_thread()

# 对象 = 类()

ret = thread(target=func, args=(i, pool))

ret.start()

高级线程池

#!/usr/bin/env python

# -*- coding;utf-8 -*-

import threading

import time

import queue

import contextlib

StopEvent = object()

class Threadpool(object):

def __init__(self, max_num):

self.max_num = max_num

# 创建任务队列

self.queue = queue.Queue()

self.terminal = False

# 表示真实创建的线程列表

self.generate_list = []

# 表示空闲的线程列表

self.free_list = []

def run(self, func, args, callback=None):

"""

线程池执行一个任务

:param func: 执行任务的函数

:param args: 任务函数的参数(以元组形式存在的任务包，封装了几个参数)

:param callback: 任务执行失败或者成功后执行的回调函数，回调函数有两个参数

:return:

"""

# 往任务队列里加任务

w = (func, args, callback)

self.queue.put(w)

# 如果空闲线程等于零并且真实创建的线程数小于任务数

if len(self.free_list) == 0 and len(self.generate_list) < self.max_num:

self.generate_thread()

def generate_thread(self):

"""

创建一个线程

:return:

"""

t = threading.Thread(target=self.call)

t.start()

def call(self):

"""

循环去获取任务函数并执行任务函数

:return:

"""

current_thread = threading.current_thread()

self.generate_list.append(current_thread)

# 去任务并执行

event = self.queue.get()

while event != StopEvent:

# 如果是元组任务，解开任务包，执行任务

func, args, callback = event

try:

ret = func(*args)

success = True

except Exception as e:

success = False

ret = e

if callback is not None:

try:

callback(success, ret)

except Exception as e:

pass

with self.work_station(self.free_list, current_thread):

if self.terminal:

event = StopEvent

else:

event = self.queue.get()

else:

self.generate_list.remove(current_thread)

def close(self):

# 中途终止线程

num = len(self.generate_list)

while num:

self.queue.put(StopEvent)

num -= 1

def terminate(self):

# 终止线程(不清空队列),线程一直在等待拿，程序不会退出

"""

终止线程(清空队列)

while self.generate_list:

self.queue.put(StopEvent)

"""

self.terminate = True

max_num = len(self.generate_list)

# self.queue.empty()

while max_num:

max_num = len(self.generate_list)

max_num -= 1

#self.queue.empty()

@contextlib.contextmanager

def work_station(self, station, val):

station.append(val)

try:

yield

finally:

station.remove(val)

def work(i):

# time.sleep(3)

print(i)

pool = Threadpool(10)

for i in range(50):

pool.run(func=work, args=(i,), callback=None)

# pool.terminate()

pool.close()

绝版线程池

#!/usr/bin/env python

# -*- coding;utf-8 -*-

"""

自定义线程池博客园教程地址

http://www.cnblogs.com/wupeiqi/articles/4839959.html

"""

import queue

import threading

import contextlib

import time

StopEvent = object()

class ThreadPool(object):

def __init__(self, max_num, max_task_num = None):

if max_task_num:

self.q = queue.Queue(max_task_num)

else:

self.q = queue.Queue()

self.max_num = max_num

self.cancel = False

self.terminal = False

self.generate_list = []

self.free_list = []

def run(self, func, args, callback=None):

"""

线程池执行一个任务

:param func: 任务函数

:param args: 任务函数所需参数

:param callback: 任务执行失败或成功后执行的回调函数，回调函数有两个参数1、任务函数执行状态；2、任务函数返回值(默认为None，即：不执行回调函数)

:return: 如果线程池已经终止，则返回True否则None

"""

if self.cancel:

return

if len(self.free_list) == 0 and len(self.generate_list) < self.max_num:

self.generate_thread()

w = (func, args, callback,)

self.q.put(w)

def generate_thread(self):

"""

创建一个线程

"""

t = threading.Thread(target=self.call)

t.start()

def call(self):

"""

循环去获取任务函数并执行任务函数

"""

current_thread = threading.currentThread()

self.generate_list.append(current_thread)

event = self.q.get()

while event != StopEvent:

func, arguments, callback = event

try:

result = func(*arguments)

success = True

except Exception as e:

success = False

result = None

if callback is not None:

try:

callback(success, result)

except Exception as e:

pass

with self.worker_state(self.free_list, current_thread):

if self.terminal:

event = StopEvent

else:

event = self.q.get()

else:

self.generate_list.remove(current_thread)

def close(self):

"""

执行完所有的任务后，所有线程停止

"""

self.cancel = True

full_size = len(self.generate_list)

while full_size:

self.q.put(StopEvent)

full_size -= 1

def terminate(self):

"""

无论是否还有任务，终止线程

"""

self.terminal = True

while self.generate_list:

self.q.put(StopEvent)

self.q.queue.clear()

@contextlib.contextmanager

def worker_state(self, state_list, worker_thread):

"""

用于记录线程中正在等待的线程数

"""

state_list.append(worker_thread)

try:

yield

finally:

state_list.remove(worker_thread)

# How to use

pool = ThreadPool(5)

def callback(status, result):

# status, execute action status

# result, execute action return value

pass

def action(i):

print(i)

if __name__ == "__main__":

for i in range(30):

ret = pool.run(action, (i,), callback)

time.sleep(0.01) # 等待的时间xiao'l

print(len(pool.generate_list), len(pool.free_list))

print(len(pool.generate_list), len(pool.free_list))

pool.close() # 子线程结束时,主线程就结束,time.sleep后的内容可能没有结果

# pool.terminate()