精华内容
下载资源
问答
  • python多线程并行处理

    2020-03-31 10:44:38
    pool.map(convert, fn_list) #convert是要调用的函数,fn_list是要传入函数的参数,多线程的参数用列表组织。 pool.close() pool.join() 2.向函数中传入多个参数的方式: 将多个参数组成元祖,同时...

    1.

    使用多进程的方式:

    cores = 2
    pool = multiprocessing.Pool(processes=cores)
    pool.map(convert, fn_list) #convert是要调用的函数,fn_list是要传入函数的参数,多线程的参数用列表组织。

    pool.close()
    pool.join()

    2.向函数中传入多个参数的方式:

    将多个参数组成元祖,同时要执行的函数再分别获取元祖中的元素

    def autoProcessOneImage(threeParams):
        annoPngName,annoShapeName,outPath=threeParams 
    
    for _ in shpAll:
        paramList.append((annoPath,shpPath,outPath))
    pool.map(autoProcessOneImage,paramList)

    3.获取返回值:返回值是各个进程组成的列表

    res = pool.map(job1,data_list)

     

    3.同时在多个运行节点启动多个程序,且每个程序用multiprocess运行多个进程时

    多进程如何防止数据冲突:

    (1)简单的方式,但仍会有少量冲突的情况:random.shuffle+文件是否已经被处理的判断

    random.shuffle(paramList)

    pool.map(autoProcessOneImage,paramList)

    def autoProcessOneImage(threeParams):

        if os.path.isfile(outToShow) and os.path.isfile(outToAnno):

              return 0

    (2)根据要启动的运行节点个数,将paramList分为几组,每个程序执行一部分数据。

     

    (3)加锁:还在研究中

     

    展开全文
  • 多核CPU上python多线程并行的一个假象 python-cn(华蟒用户组,CPyUG 邮件列表)上: 关于 python 多线程是否能用到多核的问题 相关讨论 本机环境: 2核CPU, linux 2.6, python 2.6.2  在python上开启多个...

    多核CPU上python多线程并行的一个假象

    python-cn(华蟒用户组,CPyUG 邮件列表)上: 关于 python 多线程是否能用到多核的问题 相关讨论
    本机环境: 2核CPU, linux 2.6, python 2.6.2


      在python上开启多个线程,由于GIL的存在,每个单独线程都会在竞争到GIL后才
    运行,这样就干预OS内部的进程(线程)调度,结果在多核CPU上:
      python的多线程实际是串行执行的,并不会同一时间多个线程分布在多个CPU上运行。

      但是这里有个有趣的现象: python开启两个死循环的线程,在我的2核机器上会有如下
    CPU使用情况,每个CPU都维持在50%左右的使用率(见下图).


    难道python的多线程可以在多核上并行?
      当然不是,在GIL存在的python上,多线程应该是不可能并行的。
      这里其实有个小细节隐藏在linux的进程调度系统内,当python多线程切换时候,linux
    调度子系统会兼顾多核的负载情况,linux会把多个线程平均分布在多核上跑,这样不
    会导致单个核负载过盛。但是这个并不会让python多线程在多核上并行。
    大致CPU使用应该这样:
      cpu0: .. pythread0 _________ pythread0 _________ ..
      cpu1: .. _________ pythread1 _________ pythread1 ..
      ('___'表示cpu空闲,这样统计下来每个核使用情况在50%左右)

      如果python多线程真能在多核上并行,那么这里每个CPU使用率都应该接近100%.

    原文链接:http://blog.csdn.net/chobit_s/article/details/7083369

    展开全文
  • python多线程并行爬取

    2018-11-28 15:43:46
    print u'单线程耗时:' + str(time2-time1) pool = ThreadPool(4) time3 = time.time() results = pool.map(getsource, urls) pool.close() pool.join() time4 = time.time() print u'并行耗时:' + str...

    #-*-coding:utf8-*-

    from multiprocessing.dummy import Pool as ThreadPool
    import requests
    import time

    def getsource(url):
        html = requests.get(url)

    urls = []

    for i in range(1,21):
        newpage = 'http://tieba.baidu.com/p/3522395718?pn=' + str(i)
        urls.append(newpage)

    time1 = time.time()
    for i in urls:
        print i
        getsource(i)
    time2 = time.time()
    print u'单线程耗时:' + str(time2-time1)

    pool = ThreadPool(4)
    time3 = time.time()
    results = pool.map(getsource, urls)
    pool.close()
    pool.join()
    time4 = time.time()
    print u'并行耗时:' + str(time4-time3)

    展开全文
  • python多线程并行实现随机森林

    千次阅读 2015-06-24 16:32:33
    程序针对特征值取值范围为[-1, 1]来实现,数据预处理后即可使用。 import math import operator import threading import random ...def loadDataSet(filename, boundry): num = len(open(filename).readline()....

    程序针对特征值取值范围为[-1, 1]来实现,数据预处理后即可使用。


    import math
    import operator
    import threading
    import random
    
    def loadDataSet(filename, boundry):
        num = len(open(filename).readline().split(','))-1
        dataMat = []; testMat = []
        fr = open(filename)
        ii = 0
        for line in fr.readlines():
            lineArr = []
            curLine = line.strip().split(',')
            for i in range(num):
                lineArr.append(float(curLine[i+1]))
            if ii >= boundry[0] and ii <= boundry[1]:
                testMat.append(lineArr)
            else:
                dataMat.append(lineArr)
            ii += 1
        return dataMat, testMat
    
    def calcShannonEnt(dataSet):
        numEntries = len(dataSet)
        labelCounts = {}
        for featVec in dataSet:
            currentLabel = featVec[-1]
            if currentLabel not in labelCounts.keys(): labelCounts[currentLabel] = 0
            labelCounts[currentLabel] += 1
        shannonEnt = 0.0
        for key in labelCounts:
            prob = float(labelCounts[key])/numEntries
            shannonEnt -= prob*math.log(prob, 2)
        return shannonEnt
        
    def binSplitDataSet(dataSet, feature, value):
        mat0 = [ele for ele in dataSet if ele[feature] > value]
        mat1 = [ele for ele in dataSet if ele[feature] <= value]
        return mat0, mat1
        
    def chooseBestFeatureToSplit(dataSet):
        Features = [i for i in range(len(dataSet[0]))]
        selectedFeatures = random.sample(Features, int(math.sqrt(len(Features))))
        baseEntropy = calcShannonEnt(dataSet)
        bestInfoGain = 0.0; bestFeature = None; threshold = None
        Vals = [-0.9, -0.5, 0, 0.5, 0.9]
        for i in selectedFeatures:
            for value in Vals:
                m0, m1 = binSplitDataSet(dataSet, i, value)
                prob1 = len(m0)/float(len(dataSet))
                prob2 = len(m1)/float(len(dataSet))
                newEntropy = prob1*calcShannonEnt(m0)+prob2*calcShannonEnt(m1)
                infoGain = baseEntropy-newEntropy
                if (infoGain > bestInfoGain):
                    bestInfoGain = infoGain
                    bestFeature = i
                    threshold = value
        return bestFeature, threshold
    
    def majorityCnt(classList):
        classCount = {}
        for vote in classList:
            if vote not in classCount.keys(): classCount[vote] = 0
            classCount[vote] += 1
        sortedClassCount = sorted(classCount.iteritems(), key = operator.itemgetter(1), reverse = True)
        return sortedClassCount[0][0]
    
    def createTree(dataSet):
        classList = [example[-1] for example in dataSet]
        if classList.count(classList[0]) == len(classList):
            return classList[0]
        bestFeat, threshold = chooseBestFeatureToSplit(dataSet)
        #if bestFeat == None:    return majorityCnt(classList)
        rSet, lSet = binSplitDataSet(dataSet, bestFeat, threshold)
        myTree = {(bestFeat, threshold):{}}
        myTree[(bestFeat, threshold)][0] = createTree(lSet)
        myTree[(bestFeat, threshold)][1] = createTree(rSet)
        return myTree
    
    def classify(tree, testVec):
        classLabel = None
        firstStr = tree.keys()[0]
        secondDict = tree[firstStr]
        key = testVec[firstStr[0]]
        nextL = None
        if key > firstStr[1]:
            nextL = secondDict[1]
        else:
            nextL = secondDict[0]
        if isinstance(nextL, dict):
            classLabel = classify(nextL, testVec)
        else:
            classLabel = nextL
        return classLabel
    
    def storeTree(inputTree, filename):
        import pickle
        fw = open(filename, 'w')
        pickle.dump(inputTree, fw)
        fw.close()
        
    def grabTree(filename):
        import pickle
        fr = open(filename)
        return pickle.load(fr)
    
    def bootstrap(dataSet):
        dataR = []
        for i in range(len(dataSet)):
            rindex = random.randint(0, len(dataSet)-1)
            dataR.append(dataSet[rindex])
        return dataR
    
    def learning(dataSet, times, trees):
        for i in range(times):
            dataTemp = bootstrap(dataSet)
            trees.append(createTree(dataTemp))
    
    def classify_RF(trees, testVecs):
        count = 0
        for testVec in testVecs:
            classes = []
            for tree in trees:
                classes.append(classify(tree, testVec))
            if majorityCnt(classes) == testVec[-1]:
                count += 1
        print count
    
    if __name__ == '__main__':
    
        trainData, testData = loadDataSet('train_temp.csv', (0, 1000))
    
        trees, trees1, trees2, trees3 = [], [], [], []
        learning(trainData, 10, trees)
        t1 = threading.Thread(target = learning, args = (trainData, 10, trees1))
        t2 = threading.Thread(target = learning, args = (trainData, 10, trees2))
        t3 = threading.Thread(target = learning, args = (trainData, 10, trees3))
        t1.setDaemon(True); t1.start()
        t2.setDaemon(True); t2.start()
        t3.setDaemon(True); t3.start()
    
        t1.join()
        t2.join()
        t3.join()
    
        trees.extend(trees1)
        trees.extend(trees2)
        trees.extend(trees3)
    
        offset = len(testData)/4
        classify_RF(trees, testData[:offset])
        t1 = threading.Thread(target = classify_RF, args = (trees, testData[offset:2*offset]))
        t2 = threading.Thread(target = classify_RF, args = (trees, testData[2*offset:3*offset]))
        t3 = threading.Thread(target = classify_RF, args = (trees, testData[3*offset:]))
        t1.setDaemon(True); t1.start()
        t2.setDaemon(True); t2.start()
        t3.setDaemon(True); t3.start()
    
        t1.join()
        t2.join()
        t3.join()
    


    展开全文
  • 这两个操作没有依赖关系,就是不插入也可以返回查询结果,为什么选择并行,是因为插入操作耗时,如果是串行计算会影响查询返回时间。 实现demo如下,使用Python3实现: # -*- coding: utf-8 -*- ""&...
  • 参考:http://www.cnblogs.com/skying555/p/6527189.html 转载于:https://www.cnblogs.com/gcb-1991/p/6956815.html
  • python多线程实际是串行执行的,并不会同一时间多个线程分布在多个CPU上运行。但是这里有个有趣的现象: python开启两个死循环的线程,在我的2核机器上会有如下CPU使用情况,每个CPU都维持在50%左右的使用率(见下图...
  • 今天小编就为大家分享一篇python 多线程串行和并行的实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Python多线程的缺陷1.1 Java单线程和多线程执行倒计时函数1.2 Python单线程和多线程执行倒计时函数2. GIL2.1 什么是GIL2.2 Python为什么不舍弃GIL3. Python的多线程这么辣鸡,那还用不用?3.1 多线程3.2 多进程3.3 ...
  • python多线程结束线程Python threading module is used to implement multithreading in python programs. In this lesson, we will study about Thread and different functions of python threading module. ...
  • GIL 全局解释器锁: GIL(全局解释器锁,GIL 只有cpython有): 在同一个时刻,只能有一个线程在一个 CPU 上执行字节码,没法像 c 和 Java 一样将多个线程映射到多个 CPU...说白了GIL就是伪多线程,一个线程运行其他线程
  • python多线程教程:python多线程详解

    千次阅读 2020-02-03 11:49:20
    文章目录一、线程介绍二...python多线程详解 一、线程介绍 什么是线程 线程(Thread)也叫轻量级进程,是操作系统能够进行运算调度的最小单位,它被包涵在进程之中,是进程中的实际运作单位。线程自己不拥有系统资源...
  • Python多线程能够做并行计算吗 在Python的原始解释器CPython中存在着GIL(Global Interpreter Lock,全局解释器锁),因此在解释执行Python代码时,会产生互斥锁来限制线程对共享资源的访问,直到解释器遇到I/O操作...
  • 工作中经常涉及到加速程序的... 线程:在一个进程内部(一个任务),要同时干件事,就需要同时运行个“子任务”,我们把进程内的这些“子任务”称为线程(Thread)。 这里要注意的是每个进程至少要干一个任务,每
  • python 多线程学习二(并行与并发)0x00 操作系统的基本特性0x01 并发性0x02 共享性0x03 虚拟技术0x04 异步性 0x00 操作系统的基本特性 谈到并发与并行,就不得不学习一下操作系统的基本特性,包括:并发、共享、...
  • Python 多线程教程:并发与并行

    千次阅读 2015-12-09 17:49:02
    在批评Python的讨论中,常常说起Python多线程是多么的难用。还有人对 global interpreter lock(也被亲切的称为“GIL”)指指点点,说它阻碍了Python的多线程程序同时运行。因此,如果你是从其他语言(比如C++或Java)...
  • python 提供了丰富的功能,其中就有多线程编程,常用的有thread,threading和 queue模块。 文章目录前置threading结论 前置 线程是一种对于非顺序依赖的多个任务进行解耦的技术。多线程可以提高应用的响应效率,当...
  • 线程与进程 进程: 我们都知道计算机的核心是CPU,它承担了所有的计算任务;而操作系统是计算机的管理者,它负责任务的调度、资源的分配和管理,统领整个计算机硬件;应用程序侧是具有某种功能的程序,程序是运行于...
  • 多线程,简单理解一下的话可以是多核/多机器/多副本同时运行,对于可并行处理的数据,(理想情况下)4线程可以把效率提高4倍。 实例说话 import threading def thread_job(): # 可以分配给线程的工作(函数) ...
  • Python 多线程是多鸡肋

    千次阅读 2016-11-29 11:52:16
    摘要:Python并行化支持的名声就不是很好,如果你用过 Python 自带的线程库 thread 和 threading,...Python 多线程 基础 Python 多线程 阻塞 Python 多线程 获取返回值 Python 多线程 数据对比测试 正文: 一.
  • Python多线程1、不开多线程1.1、代码1.2、结果:1.3、截图2、开多线程2.1、代码2.2、结果2.3、截图3、若有问题,请挪步“佐佑思维”公众号 4、 ★佐佑思维二维码★ 1、不开多线程 1.1、代码 #不开启多线程演示 ...
  • Python多线程与多进程

    2021-05-25 22:06:01
    目录进程、线程什么是进程什么是线程并发、并行并发并行多线程适用场景Python GILPython多线程、多进程实例:CPU 密集型任务单线程多线程多进程Python多线程、多进程实例:IO密集型任务单线程多线程多进程协程总结 ...
  • 并发:在一个时间段,处理多...引用自:多线程任务下CPU和GPU调度速度 2、Tensorflow可以同时加载两个训练好的模型吗?比如一个模型检测车牌,一个模型识别车牌。具体怎么做? 参考文章1:Python的 并发、并行 ...
  • Threading is just one of the many ways concurrent programs can be ... In this article, we will take a look at threading and a couple of other strategies in building concurrent programs in Python, a...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,742
精华内容 17,896
关键字:

python多线程并行

python 订阅