#进程与线程的关系
"""
多进程(主进程,子进程):
优点:能同时利用多个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()

  线程池

  1. 简单线程池

    #!/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()
  2. 高级线程池
    #!/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()
  3. 绝版线程池
    #!/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()

      

Python全栈开发:线程代码实例的更多相关文章

  1. Python全栈开发 线程和进程

    一.线程 线程是程序工作的最小单元,由进程生成,生成的线程间会共享内存空间.Python中创建线程比较简单,导入threading模块,创建线程实例.下面这段代码是一个简单的多线程例子 import ...

  2. python全栈开发 * 线程锁 Thread 模块 其他 * 180730

    一,线程Thread模块1.效率更高(相对于进程) import time from multiprocessing import Process from threading import Thre ...

  3. python全栈开发 * 线程队列 线程池 协程 * 180731

    一.线程队列 队列:1.Queue 先进先出 自带锁 数据安全 from queue import Queue from multiprocessing import Queue (IPC队列)2.L ...

  4. Python全栈开发:递归实例

    #!/usr/bin/env python # -*- coding;utf-8 -*- """ 递归不能无限,python会限制递归深度,递归主要用于费布拉切数列 &q ...

  5. Python全栈开发【模块】

    Python全栈开发[模块] 本节内容: 模块介绍 time random os sys json & picle shelve XML hashlib ConfigParser loggin ...

  6. Python全栈开发【面向对象】

    Python全栈开发[面向对象] 本节内容: 三大编程范式 面向对象设计与面向对象编程 类和对象 静态属性.类方法.静态方法 类组合 继承 多态 封装 三大编程范式 三大编程范式: 1.面向过程编程 ...

  7. Python全栈开发【基础三】

    Python全栈开发[基础三]  本节内容: 函数(全局与局部变量) 递归 内置函数 函数 一.定义和使用 函数最重要的是减少代码的重用性和增强代码可读性 def 函数名(参数): ... 函数体 . ...

  8. python全栈开发中级班全程笔记(第二模块、第四章)(常用模块导入)

    python全栈开发笔记第二模块 第四章 :常用模块(第二部分)     一.os 模块的 详解 1.os.getcwd()    :得到当前工作目录,即当前python解释器所在目录路径 impor ...

  9. 学习笔记之Python全栈开发/人工智能公开课_腾讯课堂

    Python全栈开发/人工智能公开课_腾讯课堂 https://ke.qq.com/course/190378 https://github.com/haoran119/ke.qq.com.pytho ...

  10. Python全栈开发【面向对象进阶】

    Python全栈开发[面向对象进阶] 本节内容: isinstance(obj,cls)和issubclass(sub,super) 反射 __setattr__,__delattr__,__geta ...

随机推荐

  1. NX二次开发-创建圆弧(圆心-半径)UF_CURVE_create_arc_center_radius

    NX9+VS2012 #include <uf.h> #include <uf_curve.h> #include <uf_modl.h> UF_initializ ...

  2. NX二次开发-NXOPEN找相切面方法ScRuleFactory()->CreateRuleFaceTangent

    #include <uf_defs.h> #include <uf_ui_types.h> #include <iostream> #include <NXO ...

  3. hdu多校第九场 1006 (hdu6685) Rikka with Coin 暴力

    题意: 有一些1毛,2毛,5毛,1块的钢镚,还有一些价格不同的商品,现在要求你带一些钢镚,以保证这些商品中任选一件都能正好用这些钢镚付账,问最少带多少钢镚. 题解: 对于最优解,1毛的钢镚最多带1个, ...

  4. 在WinDBG中查看内存的命令

    当我们在调试器中分析问题时, 经常需要查看不同内存块的内容以分析产生的原因, 并且在随后验证所做出的假设是否正确. 由于各个对象的状态都是保存在内存中的, 因此内存的内容也就相当于对象的状态. d命令 ...

  5. 9.3.2 The force and release procedural statements

    Frm: IEEE Std 1364™-2001, IEEE Standard Verilog® Hardware Description Language Another form of proce ...

  6. PAT_A1079#Total Sales of Supply Chain

    Source: PAT A1079 Total Sales of Supply Chain (25 分) Description: A supply chain is a network of ret ...

  7. ECMAScript中所有参数传递的都是值,不可能通过引用传递参数

    今天在看JavaScript高级程序设计(第三版)时,看到了这个问题:ECMAScript中所有参数传递的都是值,不可能通过引用传递参数. 在我的印象中,其他语言比如Java,C++等,传递参数有两种 ...

  8. xwiki系统 知识库 xwiki

    1.下载tomcat tar  -zxvf  apache-tomcat-8.0.14.tar.gz mv apache-tomcat-8.0.14 tomcat-xwiki-8.0 2.下载xwik ...

  9. 【学术篇】luogu1351 [NOIP2014提高组] 联合权值

    一道提高组的题..... 传送门:题目在这里.... 现在都懒得更自己的blog了,怕是太颓废了_ (:з」∠) _ 好久没做题了,手都生了.(好吧其实是做题方面手太生了) 这题我都不想讲了,把代码一 ...

  10. SQLSTATE[HY000]: General error: 1366 Incorrect string value

    在Laravel项目的 storages/logs/Laravel.log看到的错误信息片段: SQLSTATE[HY000]: General error: 1366 Incorrect strin ...