python--threading多线程总结

最新推荐文章于 2024-08-30 15:05:50 发布
最新推荐文章于 2024-08-30 15:05:50 发布
阅读量161 收藏
点赞数
分类专栏： python学习 文章标签： python 多线程

threading用于提供线程相关的操作，线程是应用程序中工作的最小单元。python当前版本的多线程库没有实现优先级、线程组，线程也不能被停止、暂停、恢复、中断。

threading模块提供的类：  
　　Thread, Lock, Rlock, Condition, [Bounded]Semaphore, Event, Timer, local。

threading 模块提供的常用方法： 
　　threading.currentThread(): 返回当前的线程变量。 
　　threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。 
　　threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

threading 模块提供的常量：

　　threading.TIMEOUT_MAX 设置threading全局超时时间。

 

Thread类

 

Thread是线程类，有两种使用方法，直接传入要运行的方法或从Thread继承并覆盖run()：

复制代码 
# coding:utf-8
import threading
import time
#方法一：将要执行的方法作为参数传给Thread的构造方法
def action(arg):
    time.sleep(1)
    print 'the arg is:%s\r' %arg

for i in xrange(4):
    t =threading.Thread(target=action,args=(i,))
    t.start()

print 'main thread end!'

#方法二：从Thread继承，并重写run()
class MyThread(threading.Thread):
    def __init__(self,arg):
        super(MyThread, self).__init__()#注意：一定要显式的调用父类的初始化函数。
        self.arg=arg
    def run(self):#定义每个线程要运行的函数
        time.sleep(1)
        print 'the arg is:%s\r' % self.arg

for i in xrange(4):
    t =MyThread(i)
    t.start()

print 'main thread end!'
复制代码

 

构造方法： 
Thread(group=None, target=None, name=None, args=(), kwargs={}) 

　　group: 线程组，目前还没有实现，库引用中提示必须是None； 
　　target: 要执行的方法； 
　　name: 线程名； 
　　args/kwargs: 要传入方法的参数。

实例方法： 
　　isAlive(): 返回线程是否在运行。正在运行指启动后、终止前。 
　　get/setName(name): 获取/设置线程名。 

　　start():  线程准备就绪，等待CPU调度
　　is/setDaemon(bool): 获取/设置是后台线程（默认前台线程（False））。（在start之前设置）

　　　　如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，主线程和后台线程均停止
       　　如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止
　　start(): 启动线程。 
　　join([timeout]): 阻塞当前上下文环境的线程，直到调用此方法的线程终止或到达指定的timeout（可选参数）。

 

使用例子一(未设置setDeamon)： 

 

复制代码 
# coding:utf-8
import threading
import time

def action(arg):
    time.sleep(1)
    print  'sub thread start!the thread name is:%s\r' % threading.currentThread().getName()
    print 'the arg is:%s\r' %arg
    time.sleep(1)

for i in xrange(4):
    t =threading.Thread(target=action,args=(i,))
    t.start()

print 'main_thread end!'
复制代码

 

复制代码 
main_thread end!
sub thread start!the thread name is:Thread-2
the arg is:1
the arg is:0
sub thread start!the thread name is:Thread-4
the arg is:2
the arg is:3
Process finished with exit code 0
可以看出，创建的4个“前台”线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止
复制代码

验证了serDeamon(False)(默认)前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，主线程停止。

 

使用例子二（setDeamon=True）

复制代码 
# coding:utf-8
import threading
import time

def action(arg):
    time.sleep(1)
    print  'sub thread start!the thread name is:%s\r' % threading.currentThread().getName()
    print 'the arg is:%s\r' %arg
    time.sleep(1)

for i in xrange(4):
    t =threading.Thread(target=action,args=(i,))
    t.setDaemon(True)#设置线程为后台线程
    t.start()

print 'main_thread end!'
复制代码 
main_thread end!

Process finished with exit code 0

可以看出，主线程执行完毕后，后台线程不管是成功与否，主线程均停止

验证了serDeamon(True)后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，主线程均停止。

 

使用例子三（设置join）

复制代码 
#coding:utf-8
import threading
import time

def action(arg):
    time.sleep(1)
    print  'sub thread start!the thread name is:%s    ' % threading.currentThread().getName()
    print 'the arg is:%s   ' %arg
    time.sleep(1)

thread_list = []    #线程存放列表
for i in xrange(4):
    t =threading.Thread(target=action,args=(i,))
    t.setDaemon(True)
    thread_list.append(t)

for t in thread_list:
    t.start()

for t in thread_list:
    t.join()
复制代码
复制代码 
sub thread start!the thread name is:Thread-2    
the arg is:1   
sub thread start!the thread name is:Thread-3    
the arg is:2   
sub thread start!the thread name is:Thread-1    
the arg is:0   
sub thread start!the thread name is:Thread-4    
the arg is:3   
main_thread end!

Process finished with exit code 0

设置join之后，主线程等待子线程全部执行完成后或者子线程超时后，主线程才结束
复制代码

验证了 join()阻塞当前上下文环境的线程，直到调用此方法的线程终止或到达指定的timeout，即使设置了setDeamon（True）主线程依然要等待子线程结束。

使用例子四（join不妥当的用法，使多线程编程顺序执行）

复制代码 
#coding:utf-8
import threading
import time

def action(arg):
    time.sleep(1)
    print  'sub thread start!the thread name is:%s    ' % threading.currentThread().getName()
    print 'the arg is:%s   ' %arg
    time.sleep(1)


for i in xrange(4):
    t =threading.Thread(target=action,args=(i,))
    t.setDaemon(True)
    t.start()
    t.join()

print 'main_thread end!'
复制代码
复制代码 
sub thread start!the thread name is:Thread-1    
the arg is:0   
sub thread start!the thread name is:Thread-2    
the arg is:1   
sub thread start!the thread name is:Thread-3    
the arg is:2   
sub thread start!the thread name is:Thread-4    
the arg is:3   
main_thread end!

Process finished with exit code 0
可以看出此时，程序只能顺序执行，每个线程都被上一个线程的join阻塞，使得“多线程”失去了多线程意义。
复制代码

 

 

Lock、Rlock类

 

　　由于线程之间随机调度：某线程可能在执行n条后，CPU接着执行其他线程。为了多个线程同时操作一个内存中的资源时不产生混乱，我们使用锁。

Lock（指令锁）是可用的最低级的同步指令。Lock处于锁定状态时，不被特定的线程拥有。Lock包含两种状态——锁定和非锁定，以及两个基本的方法。

可以认为Lock有一个锁定池，当线程请求锁定时，将线程至于池中，直到获得锁定后出池。池中的线程处于状态图中的同步阻塞状态。

RLock（可重入锁）是一个可以被同一个线程请求多次的同步指令。RLock使用了“拥有的线程”和“递归等级”的概念，处于锁定状态时，RLock被某个线程拥有。拥有RLock的线程可以再次调用acquire()，释放锁时需要调用release()相同次数。

可以认为RLock包含一个锁定池和一个初始值为0的计数器，每次成功调用 acquire()/release()，计数器将+1/-1，为0时锁处于未锁定状态。

简言之：Lock属于全局，Rlock属于线程。

构造方法： 
Lock()，Rlock（）,推荐使用Rlock()

实例方法： 
　　acquire([timeout]): 尝试获得锁定。使线程进入同步阻塞状态。 
　　release(): 释放锁。使用前线程必须已获得锁定，否则将抛出异常。

例子一（未使用锁）：

未使用锁
运行结果

 

例子二（使用锁）:

使用Lock
运行结果

 

Lock对比Rlock

#coding:utf-8
 
import threading
lock = threading.Lock() #Lock对象
lock.acquire()
lock.acquire()  #产生了死锁。
lock.release()
lock.release()
print lock.acquire()
 
 
import threading
rLock = threading.RLock()  #RLock对象
rLock.acquire()
rLock.acquire() #在同一线程内，程序不会堵塞。
rLock.release()
rLock.release()

 

Condition类

 

　　Condition（条件变量）通常与一个锁关联。需要在多个Contidion中共享一个锁时，可以传递一个Lock/RLock实例给构造方法，否则它将自己生成一个RLock实例。

　　可以认为，除了Lock带有的锁定池外，Condition还包含一个等待池，池中的线程处于等待阻塞状态，直到另一个线程调用notify()/notifyAll()通知；得到通知后线程进入锁定池等待锁定。

构造方法： 
Condition([lock/rlock])

实例方法： 
　　acquire([timeout])/release(): 调用关联的锁的相应方法。 
　　wait([timeout]): 调用这个方法将使线程进入Condition的等待池等待通知，并释放锁。使用前线程必须已获得锁定，否则将抛出异常。 
　　notify(): 调用这个方法将从等待池挑选一个线程并通知，收到通知的线程将自动调用acquire()尝试获得锁定（进入锁定池）；其他线程仍然在等待池中。调用这个方法不会释放锁定。使用前线程必须已获得锁定，否则将抛出异常。 
　　notifyAll(): 调用这个方法将通知等待池中所有的线程，这些线程都将进入锁定池尝试获得锁定。调用这个方法不会释放锁定。使用前线程必须已获得锁定，否则将抛出异常。

 

例子一：生产者消费者模型

生产者消费者模型
运行结果

例子二：生产者消费者模型

生产者消费者模型

例子三：

生产者消费者模型

 

Event类

 

　　Event（事件）是最简单的线程通信机制之一：一个线程通知事件，其他线程等待事件。Event内置了一个初始为False的标志，当调用set()时设为True，调用clear()时重置为 False。wait()将阻塞线程至等待阻塞状态。

　　Event其实就是一个简化版的 Condition。Event没有锁，无法使线程进入同步阻塞状态。

构造方法： 
Event()

实例方法： 
　　isSet(): 当内置标志为True时返回True。 
　　set(): 将标志设为True，并通知所有处于等待阻塞状态的线程恢复运行状态。 
　　clear(): 将标志设为False。 
　　wait([timeout]): 如果标志为True将立即返回，否则阻塞线程至等待阻塞状态，等待其他线程调用set()。

 

例子一

View Code

 

View Code

 

timer类

 

　　Timer（定时器）是Thread的派生类，用于在指定时间后调用一个方法。

构造方法： 
Timer(interval, function, args=[], kwargs={}) 
　　interval: 指定的时间 
　　function: 要执行的方法 
　　args/kwargs: 方法的参数

实例方法： 
Timer从Thread派生，没有增加实例方法。

例子一：

View Code

线程延迟5秒后执行。

 

local类

 

 

　　local是一个小写字母开头的类，用于管理 thread-local（线程局部的）数据。对于同一个local，线程无法访问其他线程设置的属性；线程设置的属性不会被其他线程设置的同名属性替换。

　　可以把local看成是一个“线程-属性字典”的字典，local封装了从自身使用线程作为 key检索对应的属性字典、再使用属性名作为key检索属性值的细节。

View Code
运行结果

 

参考文章链接：

　　http://www.cnblogs.com/huxi/archive/2010/06/26/1765808.html

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


转自：https://www.cnblogs.com/tkqasn/p/5700281.html

xuxunxiong954
关注
专栏目录
python多线程技术（Threading）
smalltorch的博客
04-21 2303
多线程技术可以帮助我们加速python的工作效率。看本文前建议先看python传参这篇文章，有一点小小的知识点需要知道才好理解lock功能哪里的维护共享内存的安全性。没想到这么一个简单的功能写了这么多，看样子貌似写的很详细。
python多线程threading
热门推荐
Rachel Zhang的专栏
10-29 2万+
本文通过 4个example 介绍python中多线程package —— threading的常用用法， 包括调用多线程， 同步队列类Queue， Ctrl+c结束多线程。
python中多线程threading
wugou2014的博客
02-12 310
python中多线程threading
python 多线程 threading
tigerking1017的博客
09-04 2700
(python提供了两个模块来实现多线程thread 和threading ，thread 有一些缺点，在threading 得到了弥补，为了不浪费你和时间，所以我们直接学习threading 就可以了。) # 单线程 我想做听音乐和看电影两件事儿，那么一定要先排一下顺序。 from time import ctime, sleep def music():     for
Python-threading:线程
12-21
多线程之间的执行顺序是无序的 一个进程的多个线程间共享数据,和上下文运行环境 线程随着时间线轮转 多线程 启动多线程后本体程序作为主线程存在 每个子线程都是独立的个体 相互跟其他子线程平行 主线程可以先运行...
Python-python3tumblr多线程爬虫
08-12
总结，这个项目涵盖了Python Web爬虫的基本要素，包括网络请求、HTML解析、多线程、文件下载和异常处理。通过实践这个项目，开发者可以深入理解Web爬虫的工作原理，并学习如何在实际场景中应用这些知识。
Python-HTTP大文件多线程下载工具支持断点续传
08-10
总结来说，"Python-HTTP大文件多线程下载工具支持断点续传"是一个结合了HTTP通信、多线程编程和文件操作的实例，对于提升Python网络编程能力，尤其是处理大文件下载问题，具有很高的学习价值。通过深入研究和实践，...
Python-多进程与多线程.pdf
07-23
### Python多进程与多线程知识点详解 #### 一、多进程 ##### 1. Process模块介绍 在Python中，`multiprocessing`模块提供了一个与`threading`模块类似的`Process`类，用于实现多进程编程。`Process`类的对象代表...
Python-python实现的多线程爬虫
08-12
- **线程同步**：为了避免多线程间的竞态条件，Python提供了锁（`threading.Lock`）、信号量（`threading.Semaphore`）等同步机制。 2. **多线程爬虫实现** - **URL管理**：首先，我们需要一个URL队列（如`queue....
python threading多线程
joker_xiansen的博客
09-11 948
1、进程和线程 进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位。举个例子来说，打开任务管理器，面板中会显示多个正在执行的程序，这些程序之间是独立执行的，互不影响，这就是进程。 在当代面向线程设计的计算机结构中，进程是线程的容器，线程是进程中的最小执行单位，进程的执行依赖线程，并且一个进程中至少存在一个线程。 那么怎样理解多线程呢？其中有两个重要的概念：串行和并行。提到这个概念，第一时间容易想到物理中的电阻串联和并联，其实有相似之处。将程序要
python使用threading多线程
最新发布
小蜗Leon的博客
08-30 860
多进程更适合 CPU 密集型任务和需要大量并行计算的任务。多线程更适合 I/O 密集型任务和需要在多个任务之间快速切换的任务。多进程和多线程各有优势和局限性。多进程适用于需要大量并行计算的任务，特别是在多核处理器上。多线程适用于需要快速切换任务和 I/O 密集型任务。在选择使用多进程还是多线程时，需要考虑任务的特点、系统的硬件配置以及编程语言的特性。在多线程编程中，正确管理线程间的变量是非常重要的。使用锁、原子操作和线程安全的数据结构可以帮助你避免竞态条件，并确保数据的一致性。
Python并发编程：多线程（threading模块）
互联网架构小马的博客
08-27 989
多线程是一种并发编程方式，它允许在一个进程内同时运行多个线程，从而提高程序的运行效率。线程是轻量级的进程，拥有自己的栈空间，但共享同一个进程的内存空间。本文详细介绍了Python的threading模块，包括线程的创建、线程同步、线程池的使用，并通过多个示例展示了如何在实际项目中应用这些技术。通过学习这些内容，您应该能够熟练掌握Python中的多线程编程，提高编写并发程序的能力。多线程编程可以显著提高程序的并发性能，但也带来了新的挑战和问题。
Python多线程threading用法
weixin_33978016的博客
08-01 111
Python里面经常会用到多线程，即所有的方法在同一时间开始运行，而不是按顺序一个一个运行。所用到的模块为threading，下面详解threading用法。我们写三个方法，one、two、three并正常运行。这里只截图了one（）方法，two、three与one内容一样。按下面图中的运行方式，三个函数是分别在不同时间运行的。我们用threading使三个方法在同一时...
Python——多线程Threading
qq_42814064的博客
05-05 232
在学习了莫烦python教程之后做的关于多线程的笔记 什么是多线程 实现程序的并行运行，例如你的计算机有多个核，在运行程序的时候可以让它分布在多个核中运行加快运行速度 添加线程 首先需要在python中引入模块：import threading 1. 查看当前有几个线程： import threading def main(): print(threading.active_count(...
python模块 — 多线程模块 threading
个人博客
10-15 2040
学习python多线程之前先思考两个问题： 1、为什么要使用多线程？ 2、python多线程运行机制？ GIL-全局解释器锁 文章目录： 1、线程类 threading 2、线程对象 threading.Thead() 3、线程锁对象 4、条件对象 threading.Condition() 5、信号量对象 threading.Semaphore() 6、事件对象 threading.Event 7、Timer计时器对象 threading.Timer 1、线程类 ...
python-多线程并发threading
weixin_41715954的博客
06-11 325
多任务可以由多进程完成，也可以由一个进程内的多线程完成。 线程是应用程序运行的最小单元。 Python的标准库提供了两个模块：thread和threading，threading是对thread的封装。我们只需要使用threading这个模块 导入模块 import threading 启动线程： #运行主代码时，默认启动一个主线程 #运行任务代码时，启动子线程 1、主线程和子线程之间的执行...
Python的多线程 threading
lau_jw的博客
10-11 162
def test(): while True: ... def test1(): while True: ... import threading threading.Thread(target= test).start() threading.Thread(target=test1).start()
Python多线程中的threading
路虽远，行则必至！
08-16 797
前言：在前面的博文里，我介绍了实现Python多任务的一种方式——多进程，那么本博文将介绍另一种方式——多线程。 文章目录一、使用threading模块1.1 使用threading模块1.1.1 单线程执行1.1.2 多线程执行1.2 主线程会等待所有的子线程结束后才结束 一、使用threading模块 Python的thread模块是比较底层的模块，Python的threading模块是对thread做了一些包装的，可以更加方便的被使用。 1.1 使用threading模块 1.1.1 单线程执行 im
gopython 多线程问题_python--threading多线程
06-07
好的，关于 Python 中的多线程问题，可以使用 `threading` 模块来实现。`threading` 模块提供了 `Thread` 类，可以用于创建线程。可以通过以下步骤来使用 `threading` 模块实现多线程： 1. 导入 `threading` 模块。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值