python循环怎么用多线程去运行
背景：Python脚本：读取文件中每行，放入列表中；循环读取列表中的每个元素，并做处理操作。
核心：多线程处理单个for循环函数调用
模块：threading
第一部分：
：多线程脚本 (该脚本只有两个线程，t1循环次数《t2)
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
#!/usr/bin/env python#-*- coding: utf8 -*- import sysimport timeimport stringimport threadingimport datetimefileinfo = sys.argvt1 = threading.Thread(target=MainRange,args=(0,mid))threads.append(t1)t2 = threading.Thread(target=MainRange,args=(mid,len(host_list)))threads.append(t2) for t in threads: t.setDaemon(True) t.start()t.join()print “ok“
以上是脚本内容！！！
———————————————————————-
：读取文件的内容
文件内容：
# cat hostinfo.txt
192.168.10.11 1011
192.168.10.12 1012
192.168.10.13 1013
192.168.10.14 1014
192.168.10.15 1015
192.168.10.16 1016
192.168.10.17 1017
192.168.10.18 1018
192.168.10.19 1019
192.168.10.20 1020
192.168.10.21 1021
192.168.10.22 1022
192.168.10.23 1023
192.168.10.24 1024
192.168.10.25 1025
：输出结果：
单线程 : 执行脚本：输出结果：
# ./Threadfor.py hostinfo.txt
The Server’s HostName is 192.168.10.10 and Port is 1010 !!!
The Server’s HostName is 192.168.10.11 and Port is 1011 !!!
The Server’s HostName is 192.168.10.12 and Port is 1012 !!!
.
.
.
The Server’s HostName is 192.168.10.25 and Port is 1025 !!!
多线程：执行脚本：输出 结果
# ./Threadfor.py hostinfo.txt
The Server’s HostName is 192.168.10.11 and Port is 1011 !!!
The Server’s HostName is 192.168.10.18 and Port is 1018 !!!
The Server’s HostName is 192.168.10.12 and Port is 1012 !!!
The Server’s HostName is 192.168.10.19 and Port is 1019 !!!
The Server’s HostName is 192.168.10.13 and Port is 1013 !!!
The Server’s HostName is 192.168.10.20 and Port is 1020 !!!
The Server’s HostName is 192.168.10.14 and Port is 1014 !!!
The Server’s HostName is 192.168.10.21 and Port is 1021 !!!
The Server’s HostName is 192.168.10.15 and Port is 1015 !!!
The Server’s HostName is 192.168.10.22 and Port is 1022 !!!
The Server’s HostName is 192.168.10.16 and Port is 1016 !!!
The Server’s HostName is 192.168.10.23 and Port is 1023 !!!
The Server’s HostName is 192.168.10.17 and Port is 1017 !!!
The Server’s HostName is 192.168.10.24 and Port is 1024 !!!
The Server’s HostName is 192.168.10.25 and Port is 1025 !!!
如何多线程（多进程）加速while循环(语言-python)
import numpy as np
import os
import sys
import multiprocessing as mp
import time
def MCS(input_data, med):
#t1 = time.perf_counter()
left = 0
lp = 0
while True:
lp = lp + 1
data_pool = input_data + left
output_data = med * 0.05 * data_pool / (10000 + med)
output_data = np.where(output_data 》 data_pool, data_pool, output_data)
left = data_pool – output_data
cri = (input_data – output_data) / input_data * 100
#print(lp, data_pool, output_data, cri)
if cri 《= 1:
break
t2 = time.perf_counter()
#print(f’Finished in {t2 – t1} seconds’)
if __name__ == “__main__“:
pool = mp.Pool(processes=5)
tasks =
for i in np.linspace(0.4, 0.6, num = 10):
tasks.append()
t1 = time.perf_counter()
pool.starmap(MCS, tasks)
#pool.apply_async(MCS, args=(100, 0.4))
t2 = time.perf_counter()
#pool.join()
#pool.close()
for i in np.linspace(0.4, 0.6, num = 10):
MCS(100, i)
t3 = time.perf_counter()
print(f’Finished in {t2 – t1} seconds’)
print(f’Finished in {t3 – t2} seconds’)
原因可能是只运行了一个例子，
如图测试了10个例子，测试结果如下
Finished in 15.062450630997773 seconds
Finished in 73.1936681799998 seconds
并行确实有一定的加速。
python多线程怎么用啊，多线程的话是不是能节约时间啊
用pypy执行py脚本比默认的快。Python不支持多cPU，多线程不好用。实在不行多进程吧
python 多线程
python支持多线程效果还不错，很多方面都用到了python 多线程的知识，我前段时间用python 多线程写了个处理生产者和消费者的问题，把代码贴出来给你看下：
#encoding=utf-8
import threading
import random
import time
from Queue import Queue
class Producer(threading.Thread):
def __init__(self, threadname, queue):
threading.Thread.__init__(self, name = threadname)
self.sharedata = queue
def run(self):
for i in range(20):
print self.getName(),’adding’,i,’to queue’
self.sharedata.put(i)
time.sleep(random.randrange(10)/10.0)
print self.getName(),’Finished’
# Consumer thread
class Consumer(threading.Thread):
def __init__(self, threadname, queue):
threading.Thread.__init__(self, name = threadname)
self.sharedata = queue
def run(self):
for i in range(20):
print self.getName(),’got a value:’,self.sharedata.get()
time.sleep(random.randrange(10)/10.0)
print self.getName(),’Finished’
# Main thread
def main():
queue = Queue()
producer = Producer(’Producer’, queue)
consumer = Consumer(’Consumer’, queue)
print ’Starting threads …’
producer.start()
consumer.start()
producer.join()
consumer.join()
print ’All threads have terminated.’
if __name__ == ’__main__’:
main()
如果你想要了解更多的python 多线程知识可以点下面的参考资料的地址，希望对有帮助！
python循环怎么用多线程去运行
import threading
def fun1(func):
func.start() #启动线程2
for i in range(5):
print ’x’,i
func.join()
fun2()
def fun2():
for i in range(60):
print ’y’,i
tfunc2=threading.Thread(target=fun2)
tfunc1=threading.Thread(target=fun1,args=(tfunc2,))
tfunc1.start() #启动线程1
python实现多线程并发执行
由于停服维护的需求(服务越来越多的原因),此前编写的shell脚本执行速度缓慢(for循环,这就会很慢),为提高执行速度,参考很多资料,完成此脚本,实现并发执行机制.(当然这是测试脚本,有需要的同学,拿去改ba改ba,应该就可以用了)
此处脚本参考了 https://www.jb51.net/article/86053.htm
python运行多线程程序会影响电脑硬件么
PYTHON多进程CPU利用率高,PYTHON多进程反而慢
Python · 2022年7月14日 · 338 次浏览
导读
很多时候，当我们需要使用Python来处理大量的数据的时候，为了缩短处理的时间，我们会使用多线程或多进程来并行处理任务。
由于Python全局解释器锁的存在，导致在执行多线程的时候实际上只有一个线程在运行，这使得多核CPU无法发挥它真正的效率。而多进程就可以很好地解决这个问题。如果你打开多进程的姿势不对，会导致它比单进程更慢，下面我们就来看看如何正确地打开多进程。
实验环境
系统：Ubuntu16.04
Python：3.7
示例
这个示例是基于Python对图片做一个预处理
图片预处理

读取图片将图片转换为bytes数组

采用for循环处理批量图片
这里我们直接通过循环调用图片的预处理函数，其实也就是单进程。处理了1349张图片，一共花了将近10s。这里我为了方便就没有采用多次调用来取平均值了，如果大家想要计算得更加准确，可以采用取平均值。

采用进程池多进程处理图片

使用4个进程居然花了将近13s，按道理来说这不科学呀？4个进程的处理速度应该要快于单个进程，现在看来居然还更慢。也就是说，我们花了更多的硬件资源，居然还花费了更多的时间。这是为什么呢？
接下来看看，我们使用Queue来改进使用多进程对图片进行预处理

惊讶地发现，当我们将进程池改为根据进程的个数来分发任务时，居然速度要快将近一倍左右。
特别注意：这里其实使用多线程来处理会比多进程的速度更快，而且消耗的资源也要少点。举这个例子只是为了说明，影响多进程速度的原因。
影响进程速度的原因
进程池速度慢可能有下面几个原因：
CPU资源不足，开启更多的进程只会导致速度更慢
进程之间通信传输的数据量大
使用了Lock处理共享的数据
进程使用了大量的os.fork()
在上面的例子中，其实影响多进程速度的主要原因是因为调用preprocess函数每次都会返回一个image array占用的内存比较大，如果你将返回值由image array改为一个字符串你会发现最终它们的速度会差不多。
那为什么使用Queue的速度会比进程池快那么多呢？这里主要也是因为进程池在保存数据与Queue的差异导致的。
虽然说，我们在使用进程池的时候采用的也是异步调用的方式。但是，进程池在接受返回结果的时候使用了self.wait(timeout)，而进程池最终返回结果的顺序也和调用的时候保持一致。而Queue在保存数据的时候，会通过后台的线程来写数据，所以它最终保存的结果是乱序的，相对来说它的速度会更快点。
python 循环中使用多线程
import time
import threading
def p(*listp):
for i in range(0,len(listp)):
print (listp)
p1=
p2=
for i in range(1,100):
if(i%10==1):
p1.append(i)
elif(i%10==2):
p2.append(i)
threads=
th1=threading.Thread(target=p,args=(p1))
threads.append(th1)
th3=threading.Thread(target=p,args=(p2))
threads.append(th3)
if __name__==’__main__’:
for t in threads:
t.setDaemon(True)
t.start()
python 中多线程总运行时间的统计
子线程开启后，让主线程等待，也就是join方法，子线程全部执行完了，主线程才接着执行，这样时间就可以统计了
python之多线程
进程的概念：以一个整体的形式暴露给操作系统管理，里面包含各种资源的调用。 对各种资源管理的集合就可以称为进程。
线程的概念：是操作系统能够进行运算调度的最小单位。本质上就是一串指令的集合。
进程和线程的区别：
1、线程共享内存空间，进程有独立的内存空间。
2、线程启动速度快，进程启动速度慢。注意：二者的运行速度是无法比较的。
3、线程是执行的指令集，进程是资源的集合
4、两个子进程之间数据不共享，完全独立。同一个进程下的线程共享同一份数据。
5、创建新的线程很简单，创建新的进程需要对他的父进程进行一次克隆。
6、一个线程可以操作（控制）同一进程里的其他线程，但是进程只能操作子进程
7、同一个进程的线程可以直接交流，两个进程想要通信，必须通过一个中间代理来实现。
8、对于线程的修改，可能会影响到其他线程的行为。但是对于父进程的修改不会影响到子进程。
第一个程序，使用循环来创建线程，但是这个程序中一共有51个线程，我们创建了50个线程，但是还有一个程序本身的线程，是主线程。这51个线程是并行的。注意：这个程序中是主线程启动了子线程。
相比上个程序，这个程序多了一步计算时间，但是我们观察结果会发现，程序显示的执行时间只有0.007秒，这是因为最后一个print函数它存在于主线程，而整个程序主线程和所有子线程是并行的，那么可想而知，在子线程还没有执行完毕的时候print函数就已经执行了，总的来说，这个时间只是执行了一个线程也就是主线程所用的时间。
接下来这个程序，吸取了上面这个程序的缺点，创建了一个列表，把所有的线程实例都存进去，然后使用一个for循环依次对线程实例调用join方法，这样就可以使得主线程等待所创建的所有子线程执行完毕才能往下走。 注意实验结果：和两个线程的结果都是两秒多一点
注意观察实验结果，并没有执行打印task has done，并且程序执行时间极其短。
这是因为在主线程启动子线程前把子线程设置为守护线程。
只要主线程执行完毕，不管子线程是否执行完毕，就结束。但是会等待非守护线程执行完毕
主线程退出，守护线程全部强制退出。皇帝死了，仆人也跟着殉葬
应用的场景 ： socket-server
注意：gil只是为了减低程序开发复杂度。但是在2.几的版本上，需要加用户态的锁（gil的缺陷）而在3点几的版本上，加锁不加锁都一样。
下面这个程序是一个典型的生产者消费者模型。
生产者消费者模型是经典的在开发架构中使用的模型
运维中的集群就是生产者消费者模型，生活中很多都是
那么，多线程的使用场景是什么？
python中的多线程实质上是对上下文的不断切换，可以说是假的多线程。而我们知道，io操作不占用cpu，计算占用cpu，那么python的多线程适合io操作密集的任务，比如socket-server，那么cpu密集型的任务，python怎么处理？python可以折中的利用计算机的多核：启动八个进程，每个进程有一个线程。这样就可以利用多进程解决多核问题。