⑴ python多线程
有很多的场景中的事情是同时进行的,比如开车的时候,手和脚共同来驾驶汽车,再比如唱歌跳舞也是同时进行的
结果:
• _thread
• threading(推荐使用)
结果:
threading.enumerate() 可查看当前正在运行的线程
结果:
结果:
结果:
结果: 出现资源竞争导致计算结果不正确
(1)当多个线程几乎同时修改某一个共享数据的时候,需要进行同步控制
(2)线程同步能够保证多个线程安全访问资源,最简单的同步机制是引入互斥锁
(3)互斥锁为资源引入一个状态: 锁定/非锁定
(4)某个线程要更爱共享数据时,先将其锁定,此时资源的状态为"锁定", 其他线程不能更改;直到该线程释放资源,将资源状态变为"非锁定"
(5)互斥锁保证了每次只有一个线程进行写入操作,从而保证了多线程情况下数据的正确性
结果: 计算正确
结果:卡住了
在线程间共享多个资源的时候,如果两个线程分别战友一部分资源且同时等待对方资源,就会造成死锁
(1)程序设计时避免(银行家算法)
(2)添加超时时间
⑵ python的with关键字
with表达式其实是try-finally的简写形式。但是又不是全相同。
其中的context是一个表达式，返回的是一个对象，var用来保存context表达式返回的对象，可以有单个或者多个返回值。
表达式open('1.txt')返回是一个_io.TextIOWrapper 类型的变量用f接受到。在with语句块中就可以使用这个变量操作文件。执行with这个结构之后。f会自动关闭。相当于自带了一个finally。
但是with本身并没有异常捕获的功能，但是如果发生了运行时异常，它照样可以关闭文件释放资源。
这个例子可以看出with没有捕获异常的功能。
这个例子可以看出with发生了异常也会关闭程序。
自定义类必须包含上述几个方法才能正确使用with关键字。
下面我们故意加一个NameError
即使程序发生了错误，python解释器终止了我们的程序，但是我们的类 还是顺利关闭了。
1、文件操作。2、进程线程之间互斥对象。3、支持上下文其他对象
⑶ 在Python中重新启动一个线程问题，怎么解决
给出一个简单的线程互斥的例子，例子中同时启动两个线程，a线程获取锁，获取后b线程处于等待状态，只有a线程释放锁，才能进入b线程。代码如下：
importthreading
importtime
defhello(name):
print(name+'started')
lock.acquire(True)
time.sleep(50)
print(name+'running')
lock.release()
print(name+'exit')
lock=threading.Lock()
a=threading.Thread(target=hello,args='a')
b=threading.Thread(target=hello,args='b')
a.start()
b.start()
⑷ 深入解析Python中的线程同步方法
深入解析Python中的线程同步方法
同步访问共享资源
在使用线程的时候，一个很重要的问题是要避免多个线程对同一变量或其它资源的访问冲突。一旦你稍不留神，重叠访问、在多个线程中修改（共享资源）等这些操作会导致各种各样的问题；更严重的是，这些问题一般只会在比较极端（比如高并发、生产服务器、甚至在性能更好的硬件设备上）的情况下才会出现。
比如有这样一个情况：需要追踪对一事件处理的次数
counter = 0
def process_item(item):
global counter
... do something with item ...
counter += 1
如果你在多个线程中同时调用这个函数，你会发现counter的值不是那么准确。在大多数情况下它是对的，但有时它会比实际的少几个。
出现这种情况的原因是，计数增加操作实际上分三步执行:
解释器获取counter的当前值计算新值将计算的新值回写counter变量
考虑一下这种情况：在当前线程获取到counter值后，另一个线程抢占到了CPU，然后同样也获取到了counter值，并进一步将counter值重新计算并完成回写；之后时间片重新轮到当前线程（这里仅作标识区分，并非实际当前），此时当前线程获取到counter值还是原来的，完成后续两步操作后counter的值实际只加上1。
另一种常见情况是访问不完整或不一致状态。这类情况主要发生在一个线程正在初始化或更新数据时，另一个进程却尝试读取正在更改的数据。
原子操作
实现对共享变量或其它资源的同步访问最简单的方法是依靠解释器的原子操作。原子操作是在一步完成执行的操作，在这一步中其它线程无法获得该共享资源。
通常情况下，这种同步方法只对那些只由单个核心数据类型组成的共享资源有效，譬如，字符串变量、数字、列表或者字典等。下面是几个线程安全的操作：
读或者替换一个实例属性读或者替换一个全局变量从列表中获取一项元素原位修改一个列表（例如：使用append增加一个列表项）从字典中获取一项元素原位修改一个字典（例如：增加一个字典项、调用clear方法）
注意，上面提到过，对一个变量或者属性进行读操作，然后修改它，最终将其回写不是线程安全的。因为另外一个线程会在这个线程读完却没有修改或回写完成之前更改这个共享变量/属性。
锁
锁是Python的threading模块提供的最基本的同步机制。在任一时刻，一个锁对象可能被一个线程获取，或者不被任何线程获取。如果一个线程尝试去获取一个已经被另一个线程获取到的锁对象，那么这个想要获取锁对象的线程只能暂时终止执行直到锁对象被另一个线程释放掉。
锁通常被用来实现对共享资源的同步访问。为每一个共享资源创建一个Lock对象，当你需要访问该资源时，调用acquire方法来获取锁对象（如果其它线程已经获得了该锁，则当前线程需等待其被释放），待资源访问完后，再调用release方法释放锁：
lock = Lock()
lock.acquire() #: will block if lock is already held
... access shared resource
lock.release()
注意，即使在访问共享资源的过程中出错了也应该释放锁，可以用try-finally来达到这一目的：
lock.acquire()
try:
... access shared resource
finally:
lock.release() #: release lock, no matter what
在Python 2.5及以后的版本中，你可以使用with语句。在使用锁的时候，with语句会在进入语句块之前自动的获取到该锁对象，然后在语句块执行完成后自动释放掉锁：
from __future__ import with_statement #: 2.5 only
with lock:
... access shared resource
acquire方法带一个可选的等待标识，它可用于设定当有其它线程占有锁时是否阻塞。如果你将其值设为False，那么acquire方法将不再阻塞，只是如果该锁被占有时它会返回False:
if not lock.acquire(False):
... 锁资源失败
else:
try:
... access shared resource
finally:
lock.release()
你可以使用locked方法来检查一个锁对象是否已被获取，注意不能用该方法来判断调用acquire方法时是否会阻塞，因为在locked方法调用完成到下一条语句（比如acquire）执行之间该锁有可能被其它线程占有。
if not lock.locked():
#: 其它线程可能在下一条语句执行之前占有了该锁
lock.acquire() #: 可能会阻塞
简单锁的缺点
标准的锁对象并不关心当前是哪个线程占有了该锁；如果该锁已经被占有了，那么任何其它尝试获取该锁的线程都会被阻塞，即使是占有锁的这个线程。考虑一下下面这个例子：
lock = threading.Lock()
def get_first_part():
lock.acquire()
try:
... 从共享对象中获取第一部分数据
finally:
lock.release()
return data
def get_second_part():
lock.acquire()
try:
... 从共享对象中获取第二部分数据
finally:
lock.release()
return data
示例中，我们有一个共享资源，有两个分别取这个共享资源第一部分和第二部分的函数。两个访问函数都使用了锁来确保在获取数据时没有其它线程修改对应的共享数据。
现在，如果我们想添加第三个函数来获取两个部分的数据，我们将会陷入泥潭。一个简单的方法是依次调用这两个函数，然后返回结合的结果：
def get_both_parts():
first = get_first_part()
seconde = get_second_part()
return first, second
这里的问题是，如有某个线程在两个函数调用之间修改了共享资源，那么我们最终会得到不一致的数据。最明显的解决方法是在这个函数中也使用lock:
def get_both_parts():
lock.acquire()
try:
first = get_first_part()
seconde = get_second_part()
finally:
lock.release()
return first, second
然而，这是不可行的。里面的两个访问函数将会阻塞，因为外层语句已经占有了该锁。为了解决这个问题，你可以通过使用标记在访问函数中让外层语句释放锁，但这样容易失去控制并导致出错。幸运的是，threading模块包含了一个更加实用的锁实现：re-entrant锁。
Re-Entrant Locks (RLock)
RLock类是简单锁的另一个版本，它的特点在于，同一个锁对象只有在被其它的线程占有时尝试获取才会发生阻塞；而简单锁在同一个线程中同时只能被占有一次。如果当前线程已经占有了某个RLock锁对象，那么当前线程仍能再次获取到该RLock锁对象。
lock = threading.Lock()
lock.acquire()
lock.acquire() #: 这里将会阻塞
lock = threading.RLock()
lock.acquire()
lock.acquire() #: 这里不会发生阻塞
RLock的主要作用是解决嵌套访问共享资源的问题，就像前面描述的示例。要想解决前面示例中的问题，我们只需要将Lock换为RLock对象，这样嵌套调用也会OK.
lock = threading.RLock()
def get_first_part():
... see above
def get_second_part():
... see above
def get_both_parts():
... see above
这样既可以单独访问两部分数据也可以一次访问两部分数据而不会被锁阻塞或者获得不一致的数据。
注意RLock会追踪递归层级，因此记得在acquire后进行release操作。
Semaphores
信号量是一个更高级的锁机制。信号量内部有一个计数器而不像锁对象内部有锁标识，而且只有当占用信号量的线程数超过信号量时线程才阻塞。这允许了多个线程可以同时访问相同的代码区。
semaphore = threading.BoundedSemaphore()
semaphore.acquire() #: counter减小
... 访问共享资源
semaphore.release() #: counter增大
当信号量被获取的时候，计数器减小；当信号量被释放的时候，计数器增大。当获取信号量的时候，如果计数器值为0，则该进程将阻塞。当某一信号量被释放，counter值增加为1时，被阻塞的线程（如果有的话）中会有一个得以继续运行。
信号量通常被用来限制对容量有限的资源的访问，比如一个网络连接或者数据库服务器。在这类场景中，只需要将计数器初始化为最大值，信号量的实现将为你完成剩下的事情。
max_connections = 10
semaphore = threading.BoundedSemaphore(max_connections)
如果你不传任何初始化参数，计数器的值会被初始化为1.
Python的threading模块提供了两种信号量实现。Semaphore类提供了一个无限大小的信号量，你可以调用release任意次来增大计数器的值。为了避免错误出现，最好使用BoundedSemaphore类，这样当你调用release的次数大于acquire次数时程序会出错提醒。
线程同步
锁可以用在线程间的同步上。threading模块包含了一些用于线程间同步的类。
Events
一个事件是一个简单的同步对象，事件表示为一个内部标识(internal flag)，线程等待这个标识被其它线程设定，或者自己设定、清除这个标识。
event = threading.Event()
#: 一个客户端线程等待flag被设定
event.wait()
#: 服务端线程设置或者清除flag
event.set()
event.clear()
一旦标识被设定，wait方法就不做任何处理（不会阻塞），当标识被清除时，wait将被阻塞直至其被重新设定。任意数量的线程可能会等待同一个事件。
Conditions
条件是事件对象的高级版本。条件表现为程序中的某种状态改变，线程可以等待给定条件或者条件发生的信号。
下面是一个简单的生产者/消费者实例。首先你需要创建一个条件对象：
#: 表示一个资源的附属项
condition = threading.Condition()
生产者线程在通知消费者线程有新生成资源之前需要获得条件：
#: 生产者线程
... 生产资源项
condition.acquire()
... 将资源项添加到资源中
condition.notify() #: 发出有可用资源的信号
condition.release()
消费者必须获取条件（以及相关联的锁），然后尝试从资源中获取资源项：
#: 消费者线程
condition.acquire()
while True:
...从资源中获取资源项
if item:
break
condition.wait() #: 休眠，直至有新的资源
condition.release()
... 处理资源
wait方法释放了锁，然后将当前线程阻塞，直到有其它线程调用了同一条件对象的notify或者notifyAll方法，然后又重新拿到锁。如果同时有多个线程在等待，那么notify方法只会唤醒其中的一个线程，而notifyAll则会唤醒全部线程。
为了避免在wait方法处阻塞，你可以传入一个超时参数，一个以秒为单位的浮点数。如果设置了超时参数，wait将会在指定时间返回，即使notify没被调用。一旦使用了超时，你必须检查资源来确定发生了什么。
注意，条件对象关联着一个锁，你必须在访问条件之前获取这个锁；同样的，你必须在完成对条件的访问时释放这个锁。在生产代码中，你应该使用try-finally或者with.
可以通过将锁对象作为条件构造函数的参数来让条件关联一个已经存在的锁，这可以实现多个条件公用一个资源：
lock = threading.RLock()
condition_1 = threading.Condition(lock)
condition_2 = threading.Condition(lock)
互斥锁同步
我们先来看一个例子：
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import time, threading
# 假定这是你的银行存款:
balance = 0
muxlock = threading.Lock()
def change_it(n):
# 先存后取，结果应该为0:
global balance
balance = balance + n
balance = balance - n
def run_thread(n):
# 循环次数一旦多起来，最后的数字就变成非0
for i in range(100000):
change_it(n)
t1 = threading.Thread(target=run_thread, args=(5,))
t2 = threading.Thread(target=run_thread, args=(8,))
t3 = threading.Thread(target=run_thread, args=(9,))
t1.start()
t2.start()
t3.start()
t1.join()
t2.join()
t3.join()
print balance
结果 :
[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
61
[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
24
上面的例子引出了多线程编程的最常见问题：数据共享。当多个线程都修改某一个共享数据的时候，需要进行同步控制。
线程同步能够保证多个线程安全访问竞争资源，最简单的同步机制是引入互斥锁。互斥锁为资源引入一个状态：锁定/非锁定。某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。
threading模块中定义了Lock类，可以方便的处理锁定：
#创建锁mutex = threading.Lock()
#锁定mutex.acquire([timeout])
#释放mutex.release()
其中，锁定方法acquire可以有一个超时时间的可选参数timeout。如果设定了timeout，则在超时后通过返回值可以判断是否得到了锁，从而可以进行一些其他的处理。
使用互斥锁实现上面的例子的代码如下：
balance = 0
muxlock = threading.Lock()
def change_it(n):
# 获取锁，确保只有一个线程操作这个数
muxlock.acquire()
global balance
balance = balance + n
balance = balance - n
# 释放锁，给其他被阻塞的线程继续操作
muxlock.release()
def run_thread(n):
for i in range(10000):
change_it(n)
加锁后的结果，就能确保数据正确：
[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
0
⑸ python有了GIL，为什么还有线程锁
在python的原始解释器CPython中存在着GIL（Global Interpreter Lock，全局解释器锁），因此在解释执行python代码时，会产生互斥锁来限制线程对共享资源的访问，直到解释器遇到I/O操作或者操作次数达到一定数目时才会释放GIL。
所以，虽然CPython的线程库直接封装了系统的原生线程，但CPython整体作为一个进程，同一时间只会有一个获得GIL的线程在跑，其他线程则处于等待状态。这就造成了即使在多核CPU中，多线程也只是做着分时切换而已。
不过muiltprocessing的出现，已经可以让多进程的python代码编写简化到了类似多线程的程度了。
⑹ Python多线程总结
在实际处理数据时，因系统内存有限，我们不可能一次把所有数据都导出进行操作，所以需要批量导出依次操作。为了加快运行，我们会采用多线程的方法进行数据处理， 以下为我总结的多线程批量处理数据的模板：
主要分为三大部分：
共分4部分对多线程的内容进行总结。
先为大家介绍线程的相关概念:
在飞车程序中，如果没有多线程，我们就不能一边听歌一边玩飞车，听歌与玩 游戏 不能并行；在使用多线程后，我们就可以在玩 游戏 的同时听背景音乐。在这个例子中启动飞车程序就是一个进程，玩 游戏 和听音乐是两个线程。
Python 提供了 threading 模块来实现多线程:
因为新建线程系统需要分配资源、终止线程系统需要回收资源，所以如果可以重用线程，则可以减去新建/终止的开销以提升性能。同时，使用线程池的语法比自己新建线程执行线程更加简洁。
Python 为我们提供了 ThreadPoolExecutor 来实现线程池，此线程池默认子线程守护。它的适应场景为突发性大量请求或需要大量线程完成任务，但实际任务处理时间较短。
其中 max_workers 为线程池中的线程个数，常用的遍历方法有 map 和 submit+as_completed 。根据业务场景的不同，若我们需要输出结果按遍历顺序返回，我们就用 map 方法，若想谁先完成就返回谁，我们就用 submit+as_complete 方法。
我们把一个时间段内只允许一个线程使用的资源称为临界资源，对临界资源的访问，必须互斥的进行。互斥，也称间接制约关系。线程互斥指当一个线程访问某临界资源时，另一个想要访问该临界资源的线程必须等待。当前访问临界资源的线程访问结束，释放该资源之后，另一个线程才能去访问临界资源。锁的功能就是实现线程互斥。
我把线程互斥比作厕所包间上大号的过程，因为包间里只有一个坑，所以只允许一个人进行大号。当第一个人要上厕所时，会将门上上锁，这时如果第二个人也想大号，那就必须等第一个人上完，将锁解开后才能进行，在这期间第二个人就只能在门外等着。这个过程与代码中使用锁的原理如出一辙，这里的坑就是临界资源。 Python 的 threading 模块引入了锁。 threading 模块提供了 Lock 类，它有如下方法加锁和释放锁：
我们会发现这个程序只会打印“第一道锁”，而且程序既没有终止，也没有继续运行。这是因为 Lock 锁在同一线程内第一次加锁之后还没有释放时，就进行了第二次 acquire 请求，导致无法执行 release ，所以锁永远无法释放，这就是死锁。如果我们使用 RLock 就能正常运行，不会发生死锁的状态。
在主线程中定义 Lock 锁，然后上锁，再创建一个子 线程t 运行 main 函数释放锁，结果正常输出，说明主线程上的锁，可由子线程解锁。
如果把上面的锁改为 RLock 则报错。在实际中设计程序时，我们会将每个功能分别封装成一个函数，每个函数中都可能会有临界区域，所以就需要用到 RLock 。
一句话总结就是 Lock 不能套娃， RLock 可以套娃； Lock 可以由其他线程中的锁进行操作， RLock 只能由本线程进行操作。
⑺ python线程怎么销毁
【Python】线程的创建、执行、互斥、同步、销毁
还是《【Java】利用synchronized(this)完成线程的临界区》（点击打开链接）、《【Linux】线程互斥》（点击打开链接）、《【C++】Windows线程的创建、执行、互斥、同步、销毁》（点击打开链接）中的设置多个线程对一个ticket进行自减操作，用来说明Python中多线程的运用，涉及的创建、执行、互斥、同步、销毁问题。
运行结果如下，还是差不多，运行三次，每次的运行结果，每个线程最终的得票结果是不同的，但是4个线程最终“得票”的总和为 ticket 最初设置的值为100000，证明这4个线程成功实现了互斥。
虽然每次运行结果是不同，但是可以看得出每次运行结果大抵上是平均的。貌似Python对线程作系统资源的处理，比Java要好。
然而，Python总要实现多线程，代码并不像想象中简单，具体如下：
[python] view plain print?在CODE上查看代码片派生到我的代码片
# -*-coding:utf-8-*-
import threading;
mutex_lock = threading.RLock(); # 互斥锁的声明
ticket = 100000; # 总票数
# 用于统计各个线程的得票数
ticket_for_thread1 = 0;
ticket_for_thread2 = 0;
ticket_for_thread3 = 0;
ticket_for_thread4 = 0;
class myThread(threading.Thread): # 线程处理函数
def __init__(self, name):
threading.Thread.__init__(self); # 线程类必须的初始化
self.thread_name = name; # 将传递过来的name构造到类中的name
def run(self):
# 声明在类中使用全局变量
global mutex_lock;
global ticket;
global ticket_for_thread1;
global ticket_for_thread2;
global ticket_for_thread3;
global ticket_for_thread4;
while 1:
mutex_lock.acquire(); # 临界区开始，互斥的开始
# 仅能有一个线程↓↓↓↓↓↓↓↓↓↓↓↓
if ticket > 0:
ticket -= 1;
# 统计哪到线程拿到票
print "%s抢到了票！票还剩余：%d。" % (self.thread_name, ticket);
if self.thread_name == "线程1":
ticket_for_thread1 += 1;
elif self.thread_name == "线程2":
ticket_for_thread2 += 1;
elif self.thread_name == "线程3":
ticket_for_thread3 += 1;
elif self.thread_name == "线程4":
ticket_for_thread4 += 1;
else:
break;
# 仅能有一个线程↑↑↑↑↑↑↑↑↑↑↑↑
mutex_lock.release(); # 临界区结束，互斥的结束
mutex_lock.release(); # python在线程死亡的时候，不会清理已存在在线程函数的互斥锁，必须程序猿自己主动清理
print "%s被销毁了！" % (self.thread_name);
# 初始化线程
thread1 = myThread("线程1");
thread2 = myThread("线程2");
thread3 = myThread("线程3");
thread4 = myThread("线程4");
# 开启线程
thread1.start();
thread2.start();
thread3.start();
thread4.start();
# 等到线程1、2、3、4结束才进行以下的代码（同步）
thread1.join();
thread2.join();
thread3.join();
thread4.join();
print "票都抢光了，大家都散了吧！";
print "=========得票统计=========";
print "线程1：%d张" % (ticket_for_thread1);
print "线程2：%d张" % (ticket_for_thread2);
print "线程3：%d张" % (ticket_for_thread3);
print "线程4：%d张" % (ticket_for_thread4);
1、从上面的代码可以看出，在Python2.7中要使用线程必须使用threading而不是古老的thread模块。
如果你像网上部分遗留依旧的文章一样，在Python2.7中使用thread来实现线程，至少在Eclipse的Pydev中会报错：sys.excepthook is missing，lost sys.stderr如下图所示：
所以必须使用现时Python建议使用的threading。
2、与其它编程语言类似，声明一个互斥锁，与一系列的得票数。之后，与Java同样地，Python实现线程的函数，是要重写一个类。而类中使用全局变量，则与同为脚本语言的php一样《【php】global的使用与php的全局变量》（点击打开链接），要用global才能使用这个全局变量，而不是C/C++可以直接使用。
3、需要注意的，Python需要在线程跑完class myThread(threading.Thread)这个类的def run(self)方法之前，必须自己手动清理互斥锁，它不会像其它编程语言那样，说线程跑完def run(self)方法，会自然而然地清理该线程被创建的互斥锁。如果没有最后一句手动清理互斥锁，则会造成死锁。
4、最后与其它编程语言一样了，利用线程的join方法可以等待这个线程跑完def run(self)方法中的所有代码，才执行之后的代码，实现同步。否则主函数中的代码，相当于与父线程。主函数开启的线程，相当于其子线程，互不影响的。