python阻塞函数 python 阻塞函数

python里并发执行协程时部分阻塞超时怎么办

在前面的例子里学习了并发地执行多个协程来下载图片，也许其中一个协程永远下载不了，一直阻塞，这时怎么办呢？

碰到这种需求时不要惊慌，可以使用wait()里的timeout参数来设置等待时间，也就是从这个函数开始运行算起，如果时间到达协程没有执行完成，就可以不再等它们了，直接从wait()函数里返回，返回之后就可以判断那些没有执行成功的，可以把这些协程取消掉。例子如下：

[python] view plain copy

import asyncio

async def phase(i):

print('in phase {}'.format(i))

try:

await asyncio.sleep(0.1 * i)

except asyncio.CancelledError:

print('phase {} canceled'.format(i))

raise

else:

print('done with phase {}'.format(i))

return 'phase {} result'.format(i)

async def main(num_phases):

print('starting main')

phases = [

phase(i)

for i in range(num_phases)

]

print('waiting 0.1 for phases to complete')

completed, pending = await asyncio.wait(phases, timeout=0.1)

print('{} completed and {} pending'.format(

len(completed), len(pending),

))

# Cancel remaining tasks so they do not generate errors

# as we exit without finishing them.

if pending:

print('canceling tasks')

for t in pending:

t.cancel()

print('exiting main')

event_loop = asyncio.get_event_loop()

try:

event_loop.run_until_complete(main(3))

finally:

event_loop.close()

结果输出如下：

starting main

waiting 0.1 for phases to complete

in phase 0

in phase 2

in phase 1

done with phase 0

1 completed and 2 pending

canceling tasks

exiting main

phase 1 canceled

phase 2 canceled

python wait()函数问题

看python阻塞函数了你发的函数python阻塞函数：

def Wait(self):

self._app.MainLoop()

看名字应该是启动python阻塞函数了阻塞循环python阻塞函数，去处理app的请求，这个就是需要一直运行的，因为一旦停止python阻塞函数了，你的app请求就没发处理了。

如果你需要启动后再执行的别的程序，可以使用多进程，把这个启动放在别的进程里去执行。

如果解决了您的问题请采纳！

如果未解决请继续追问

python多进程中队列不空时阻塞，求解为什么

最近接触一个项目，要在多个虚拟机中运行任务，参考别人之前项目的代码，采用了多进程来处理，于是上网查了查python中的多进程

一、先说说Queue（队列对象）

Queue是python中的标准库，可以直接import 引用，之前学习的时候有听过著名的“先吃先拉”与“后吃先吐”，其实就是这里说的队列，队列的构造的时候可以定义它的容量，别吃撑了，吃多了，就会报错,构造的时候不写或者写个小于1的数则表示无限多

import Queue

q = Queue.Queue(10)

向队列中放值(put)

q.put(‘yang')

q.put(4)

q.put([‘yan','xing'])

在队列中取值get()

默认的队列是先进先出的

q.get()

‘yang'

q.get()

4

q.get()

[‘yan', ‘xing']

当一个队列为空的时候如果再用get取则会堵塞，所以取队列的时候一般是用到

get_nowait()方法，这种方法在向一个空队列取值的时候会抛一个Empty异常

所以更常用的方法是先判断一个队列是否为空，如果不为空则取值

队列中常用的方法

Queue.qsize() 返回队列的大小

Queue.empty() 如果队列为空，返回True,反之False

Queue.full() 如果队列满了，返回True,反之False

Queue.get([block[, timeout]]) 获取队列，timeout等待时间

Queue.get_nowait() 相当Queue.get(False)

非阻塞 Queue.put(item) 写入队列，timeout等待时间

Queue.put_nowait(item) 相当Queue.put(item, False)

二、multiprocessing中使用子进程概念

from multiprocessing import Process

可以通过Process来构造一个子进程

p = Process(target=fun,args=(args))

再通过p.start()来启动子进程

再通过p.join()方法来使得子进程运行结束后再执行父进程

from multiprocessing import Process

import os

# 子进程要执行的代码

def run_proc(name):

print 'Run child process %s (%s)...' % (name, os.getpid())

if __name__=='__main__':

print 'Parent process %s.' % os.getpid()

p = Process(target=run_proc, args=('test',))

print 'Process will start.'

p.start()

p.join()

print 'Process end.'

三、在multiprocessing中使用pool

如果需要多个子进程时可以考虑使用进程池(pool)来管理

from multiprocessing import Pool

from multiprocessing import Pool

import os, time

def long_time_task(name):

print 'Run task %s (%s)...' % (name, os.getpid())

start = time.time()

time.sleep(3)

end = time.time()

print 'Task %s runs %0.2f seconds.' % (name, (end - start))

if __name__=='__main__':

print 'Parent process %s.' % os.getpid()

p = Pool()

for i in range(5):

p.apply_async(long_time_task, args=(i,))

print 'Waiting for all subprocesses done...'

p.close()

p.join()

print 'All subprocesses done.'

pool创建子进程的方法与Process不同，是通过

p.apply_async(func,args=(args))实现，一个池子里能同时运行的任务是取决你电脑的cpu数量，如我的电脑现在是有4个cpu，那会子进程task0,task1,task2,task3可以同时启动，task4则在之前的一个某个进程结束后才开始

上面的程序运行后的结果其实是按照上图中1，2，3分开进行的，先打印1，3秒后打印2，再3秒后打印3

代码中的p.close()是关掉进程池子，是不再向里面添加进程了，对Pool对象调用join()方法会等待所有子进程执行完毕，调用join()之前必须先调用close()，调用close()之后就不能继续添加新的Process了。

当时也可以是实例pool的时候给它定义一个进程的多少

如果上面的代码中p=Pool(5)那么所有的子进程就可以同时进行

三、多个子进程间的通信

多个子进程间的通信就要采用第一步中说到的Queue，比如有以下的需求，一个子进程向队列中写数据，另外一个进程从队列中取数据，

#coding:gbk

from multiprocessing import Process, Queue

import os, time, random

# 写数据进程执行的代码:

def write(q):

for value in ['A', 'B', 'C']:

print 'Put %s to queue...' % value

q.put(value)

time.sleep(random.random())

# 读数据进程执行的代码:

def read(q):

while True:

if not q.empty():

value = q.get(True)

print 'Get %s from queue.' % value

time.sleep(random.random())

else:

break

if __name__=='__main__':

# 父进程创建Queue，并传给各个子进程：

q = Queue()

pw = Process(target=write, args=(q,))

pr = Process(target=read, args=(q,))

# 启动子进程pw，写入:

pw.start()

# 等待pw结束:

pw.join()

# 启动子进程pr，读取:

pr.start()

pr.join()

# pr进程里是死循环，无法等待其结束，只能强行终止:

print

print '所有数据都写入并且读完'

四、关于上面代码的几个有趣的问题

if __name__=='__main__':

# 父进程创建Queue，并传给各个子进程：

q = Queue()

p = Pool()

pw = p.apply_async(write,args=(q,))

pr = p.apply_async(read,args=(q,))

p.close()

p.join()

print

print '所有数据都写入并且读完'

如果main函数写成上面的样本，本来我想要的是将会得到一个队列，将其作为参数传入进程池子里的每个子进程，但是却得到

RuntimeError: Queue objects should only be shared between processes through inheritance

的错误，查了下，大意是队列对象不能在父进程与子进程间通信，这个如果想要使用进程池中使用队列则要使用multiprocess的Manager类

if __name__=='__main__':

manager = multiprocessing.Manager()

# 父进程创建Queue，并传给各个子进程：

q = manager.Queue()

p = Pool()

pw = p.apply_async(write,args=(q,))

time.sleep(0.5)

pr = p.apply_async(read,args=(q,))

p.close()

p.join()

print

print '所有数据都写入并且读完'

这样这个队列对象就可以在父进程与子进程间通信，不用池则不需要Manager，以后再扩展multiprocess中的Manager类吧

关于锁的应用，在不同程序间如果有同时对同一个队列操作的时候，为了避免错误，可以在某个函数操作队列的时候给它加把锁，这样在同一个时间内则只能有一个子进程对队列进行操作，锁也要在manager对象中的锁

#coding:gbk

from multiprocessing import Process,Queue,Pool

import multiprocessing

import os, time, random

# 写数据进程执行的代码:

def write(q,lock):

lock.acquire() #加上锁

for value in ['A', 'B', 'C']:

print 'Put %s to queue...' % value

q.put(value)

lock.release() #释放锁

# 读数据进程执行的代码:

def read(q):

while True:

if not q.empty():

value = q.get(False)

print 'Get %s from queue.' % value

time.sleep(random.random())

else:

break

if __name__=='__main__':

manager = multiprocessing.Manager()

# 父进程创建Queue，并传给各个子进程：

q = manager.Queue()

lock = manager.Lock() #初始化一把锁

p = Pool()

pw = p.apply_async(write,args=(q,lock))

pr = p.apply_async(read,args=(q,))

p.close()

p.join()

print

print '所有数据都写入并且读完'

python - 日志记录模块(logging)的二次封装

上篇文章 对logging做了基本介绍，我们可以使用logging来做日志的简单记录。但实际项目应用时，我们一般会根据自身需要对其做二次封装(loggingV2)，然后在其他python文件中, 先import申明后直接调用。

废话不多说，下面给几个二次封装的简单示例：

示例一：

loggingV2.py - 封装

logMain.py - 应用

示例二：

    对上述示例进行 模块化封装 ，如下log.py

则任何声明了log模块的python文件都可以调用logging日志系统，如下logMain.py

示例三：

    对上述示例进行 定制化封装 ，如下myLog.py

    需求：

    1）同时实现终端显示与日志文件保存

    2）日志文件名除日期外，增加显示时间，精确到秒

    3）日志输出级别可配置

    4）日志保存路径与文件名可配置

    5）日志跨天(或者小时/分钟)，另生成新文件保存

改写logMain.py，如下：

示例四：

    对上述示例进行 异步线程封装 ，如下myThreadLog.py

    需求：

        1）独立线程处理日志，不影响主程序性能

        2）使用队列异步处理日志记录

 继续改写logMain.py，如下：

    注意 - 线程相关操作函数(如下)：

        1.threading.Thread() — 创建线程并初始化线程，可以为线程传递参数

        2.threading.enumerate() — 返回一个包含正在运行的线程的list

        3.threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果

        4.Thread.start() — 启动线程

        5.Thread.join() — 阻塞函数，一直等到线程结束

        6.Thread.isAlive() — 返回线程活动状态

        7.Thread.setName() — 设置线程名

        8.Thread.getName() — 获取线程名

        9.Thread.setDaemon() — 设置为后台线程，这里默认是False，设置为True之后则主线程不会再等待子线程结束才结束，而是主线程结束意味程序退出，子线程也立即结束，注意调用时必须设置在start()之前；

        10.除了以上常用函数，线程还经常与互斥锁Lock/事件Event/信号量Condition/队列Queue等函数配合使用

python多线程实现为阻塞语句计时

os.system默认阻塞当前程序执行，在cmd命令前加入start可不阻塞当前程序执行。

例如：

import os

os.system(r"start E:\TX\qq.exe")

或者

os.system('start python test.py ')

python中,多线程的延时在哪加

多线程的延时一般在线程函数内部进行调用python阻塞函数，使用time模块中的sleep()函数实现：

```

import time

import threading

def my_thread_func():

print("Thread started")

time.sleep(1) # 延时1秒

print("Thread ended")

my_thread = threading.Thread(target=my_thread_func)

my_thread.start()

```

在上面的代码中python阻塞函数，线程函数`my_thread_func()`内部使用了`time.sleep(1)`来实现延时1秒。注意，这里的延时函数是阻塞函数，会让当前线程暂停执行一段时间。如果你想在不阻塞线程的情况下实现延时，可以使用`threading.Timer()`函数。

python阻塞函数的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于python 阻塞函数、python阻塞函数的信息别忘了在本站进行查找喔。