python并发函数,python 并发

python用例并发怎么解决

python-selenium并发执行测试用例(方法一 各模块每一条并发执行)

总执行代码:

# coding=utf-8

import unittest,os,time

import HTMLTestRunner

import threading

import sys

sys.path.append('C:/Users/Dell/Desktop/CARE/program')#使用编辑器，要指定当前目录，不然无法执行第20行代码

def creatsuite():

casedir = []

list = os.listdir(os.path.dirname(os.getcwd()))#获取当前路径的上一级目录的所有文件夹,这里可以改成绝对路径(要搜索的文件路径)

for xx in list:

if "baidu" in xx:

casedir.append(xx)

suite =[]

for n in casedir:

testunit = unittest.TestSuite()

unittest.defaultTestLoader._top_level_dir = None

#（unittest.defaultTestLoader(): defaultTestLoader()类，通过该类下面的discover()方法可自动更具测试目录start_dir匹配查找测试用例文件（test*.py），

并将查找到的测试用例组装到测试套件，因此可以直接通过run()方法执行discover）

discover = unittest.defaultTestLoader.discover(str(n),pattern='tet_*.py',top_level_dir=None)

for test_suite in discover:

for test_case in test_suite:

testunit.addTests(test_case)

suite.append(testunit)

return suite, casedir

def runcase(suite,casedir):

lastPath = os.path.dirname(os.getcwd())#获取当前路径的上一级

resultDir = lastPath+"\\run\\report\\" #报告存放路径

now = time.strftime("%Y-%m-%d %H.%M.%S",time.localtime())

filename = resultDir + now +" result.html"

fp = file(filename, 'wb')

proclist=[]

s=0

for i in suite:

runner = HTMLTestRunner.HTMLTestRunner(stream=fp,title=str(casedir[s])+u'测试报告',description=u'用例执行情况：')

proc = threading.Thread(target=runner.run,args=(i,))

proclist.append(proc)

s=s+1

for proc in proclist:

proc.start()

for proc in proclist:

proc.join()

fp.close()

if __name__ == "__main__":

runtmp=creatsuite()

runcase(runtmp[0],runtmp[1])

相关问答

Q1: python并发编程-进程池

在利用Python进行系统管理的时候，特别是同时操作多个文件目录，或者远程控制多台主机，并行操作可以节约大量的时间。多进程是实现并发的手段之一，需要注意的问题是：

例如当被操作对象数目不大时，可以直接利用multiprocessing中的Process动态成生多个进程，十几个还好，但如果是上百个，上千个。。。手动的去限制进程数量却又太过繁琐，此时可以发挥进程池的功效。

我们就可以通过维护一个进程池来控制进程数目，比如httpd的进程模式，规定最小进程数和最大进程数..

ps： 对于远程过程调用的高级应用程序而言，应该使用进程池，Pool可以提供指定数量的进程，供用户调用，当有新的请求提交到pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到规定最大值，那么该请求就会等待，直到池中有进程结束，就重用进程池中的进程。

创建进程池的类：如果指定numprocess为3，则进程池会从无到有创建三个进程，然后自始至终使用这三个进程去执行所有任务，不会开启其他进程

参数介绍：

方法介绍：

主要方法：

其他方法（了解部分）

应用：

发现：并发开启多个客户端，服务端同一时间只有3个不同的pid，干掉一个客户端，另外一个客户端才会进来，被3个进程之一处理

回调函数：

需要回调函数的场景：进程池中任何一个任务一旦处理完了，就立即告知主进程：我好了额，你可以处理我的结果了。主进程则调用一个函数去处理该结果，该函数即回调函数

我们可以把耗时间（阻塞）的任务放到进程池中，然后指定回调函数（主进程负责执行），这样主进程在执行回调函数时就省去了I/O的过程，直接拿到的是任务的结果。

如果在主进程中等待进程池中所有任务都执行完毕后，再统一处理结果，则无需回调函数

Q2: Python中的并行和并发是什么

并行和并发

无论是并行还是并发，在用户看来都是'同时'运行的，不管是进程还是线程，都只是一个任务而已，真是干活的是cpu，cpu来做这些任务，而一个cpu同一时刻只能执行一个任务。

并发是伪并行，即看起来是同时运行。单个cpu+多道技术就可以实现并发，（并行也属于并发），简单的可以理解为快速在多个线程来回切换，感觉好像同时在做多个事情。

只有具备多个cpu才能实现并行，单核下，可以利用多道技术，多个核，每个核也都可以利用多道技术（多道技术是针对单核而言的）。  有四个核，六个任务，这样同一时间有四个任务被执行，假设分别被分配给了cpu1，cpu2，cpu3，cpu4，一旦任务1遇到I/O就被迫中断执行，此时任务5就拿到cpu1的时间片去执行，这就是单核下的多道技术 ，而一旦任务1的I/O结束了，操作系统会重新调用它(需知进程的调度、分配给哪个cpu运行，由操作系统说了算)，可能被分配给四个cpu中的任意一个去执行。

相关推荐：《Python视频教程》

多道技术：内存中同时存入多道（多个）程序，cpu从一个进程快速切换到另外一个，使每个进程各自运行几十或几百毫秒，这样，虽然在某一个瞬间，一个cpu只能执行一个任务，但在1秒内，cpu却可以运行多个进程，这就给人产生了并行的错觉，即伪并发，以此来区分多处理器操作系统的真正硬件并行（多个cpu共享同一个物理内存）。

同步执行：一个进程在执行某个任务时，另外一个进程必须等待其执行完毕，才能继续执行。

异步执行：一个进程在执行某个任务时，另外一个进程无需等待其执行完毕，就可以继续执行，当有消息返回时，系统会通知后者进行处理，这样可以提高执行效率。

举个例子，打电话时就是同步通信，发短息时就是异步通信。

相关推荐：

Python如何实现线程间同步

Q3: 如何在Python中编写并发程序

多进程/多线程+Queue

一般来说,在Python中编写并发程序的经验是:计算密集型任务使用多进程,IO密集型任务使用多进程或者多线程.另外,因为涉及到资源共享,所以需要同步锁等一系列麻烦的步骤,代码编写不直观.另外一种好的思路是利用多进程/多线程+Queue的方法,可以避免加锁这样麻烦低效的方式.

现在在Python2中利用Queue+多进程的方法来处理一个IO密集型任务.

假设现在需要下载多个网页内容并进行解析,单进程的方式效率很低,所以使用多进程/多线程势在必行.

我们可以先初始化一个tasks队列,里面将要存储的是一系列dest_url,同时开启4个进程向tasks中取任务然后执行,处理结果存储在一个results队列中,最后对results中的结果进行解析.最后关闭两个队列.

下面是一些主要的逻辑代码.

# -*- coding:utf-8 -*-

#IO密集型任务

#多个进程同时下载多个网页

#利用Queue+多进程

#由于是IO密集型,所以同样可以利用threading模块

import multiprocessing

def main():

tasks = multiprocessing.JoinableQueue()

results = multiprocessing.Queue()

cpu_count = multiprocessing.cpu_count() #进程数目==CPU核数目

create_process(tasks, results, cpu_count) #主进程马上创建一系列进程,但是由于阻塞队列tasks开始为空,副进程全部被阻塞

add_tasks(tasks) #开始往tasks中添加任务

parse(tasks, results) #最后主进程等待其他线程处理完成结果

def create_process(tasks, results, cpu_count):

for _ in range(cpu_count):

p = multiprocessing.Process(target=_worker, args=(tasks, results)) #根据_worker创建对应的进程

p.daemon = True #让所有进程可以随主进程结束而结束

p.start() #启动

def _worker(tasks, results):

while True: #因为前面所有线程都设置了daemon=True,故不会无限循环

try:

task = tasks.get() #如果tasks中没有任务,则阻塞

result = _download(task)

results.put(result) #some exceptions do not handled

finally:

tasks.task_done()

def add_tasks(tasks):

for url in get_urls(): #get_urls() return a urls_list

tasks.put(url)

def parse(tasks, results):

try:

tasks.join()

except KeyboardInterrupt as err:

print "Tasks has been stopped!"

print err

while not results.empty():

_parse(results)

if __name__ == '__main__':

main()

利用Python3中的concurrent.futures包

在Python3中可以利用concurrent.futures包,编写更加简单易用的多线程/多进程代码.其使用感觉和Java的concurrent框架很相似(借鉴?)

比如下面的简单代码示例

def handler():

futures = set()

with concurrent.futures.ProcessPoolExecutor(max_workers=cpu_count) as executor:

for task in get_task(tasks):

future = executor.submit(task)

futures.add(future)

def wait_for(futures):

try:

for future in concurrent.futures.as_completed(futures):

err = futures.exception()

if not err:

result = future.result()

else:

raise err

except KeyboardInterrupt as e:

for future in futures:

future.cancel()

print "Task has been canceled!"

print e

return result

总结

要是一些大型Python项目也这般编写,那么效率也太低了.在Python中有许多已有的框架使用,使用它们起来更加高效.

但是自己的一些"小打小闹"的程序这样来编写还是不错的.:)

Q4: Python 多线程并发控制问题

python线程有两种,类或者函数

后者很简单,就跟pthread一样用啊。

不要打印就好了，或者你自己维护一个print加个自旋锁

第三个从但是开始就没看懂

既然要加print那一定要加锁了，否则是没办法

既然你想搞一个控制线程，那就由它来打印咯

Q5: python高并发怎么解决

某个时间段内，数据涌来，这就是并发。如果数据量很大，就是高并发

高并发的解决方法：

1、队列、缓冲区

假设只有一个窗口，陆续涌入食堂的人，排队打菜是比较好的方式

所以，排队（队列）是一种天然解决并发的办法

排队就是把人排成 队列，先进先出，解决了资源使用的问题

排成的队列，其实就是一个缓冲地带，就是 缓冲区

假设女生优先，每次都从这个队伍中优先选出女生出来先打饭，这就是 优先队列

例如queue模块的类Queue、LifoQueue、PriorityQueue（小顶堆实现）

2、争抢

只开一个窗口，有可能没有秩序，也就是谁挤进去就给谁打饭

挤到窗口的人占据窗口，直到打到饭菜离开

其他人继续争抢，会有一个人占据着窗口，可以视为锁定窗口，窗口就不能为其他人提供服务了。

这是一种锁机制

谁抢到资源就上锁，排他性的锁，其他人只能等候

争抢也是一种高并发解决方案，但是，这样可能不好，因为有可能有人很长时间抢不到

3、预处理

如果排长队的原因，是由于每个人打菜等候时间长，因为要吃的菜没有，需要现做，没打着饭不走开，锁定着窗口

食堂可以提前统计大多数人最爱吃的菜品，将最爱吃的80%的热门菜，提前做好，保证供应，20%的冷门菜，现做

这样大多数人，就算锁定窗口，也很快打到饭菜走了，快速释放窗口

一种提前加载用户需要的数据的思路，预处理 思想，缓存常用

更多Python知识，请关注：Python自学网！！