python多线程for循环

⑴ python多线程中为什么要用for遍历所有线程然后依次调用join

join 主要用于进程/线程之间的协同，其功能在于等待目的进程/线程执行完毕。
在此，因为你的线程操作很简单，功能函数执行完成后线程就结束了。join与否就显得区别不大。

⑵ python循环怎么用多线程去运行

背景：Python脚本：读取文件中每行，放入列表中；循环读取列表中的每个元素，并做处理操作。
核心：多线程处理单个for循环函数调用
模块：threading
第一部分：

：多线程脚本 (该脚本只有两个线程，t1循环次数<t2)#!/usr/bin/env python#-*- coding: utf8 -*- import sysimport timeimport stringimport threadingimport datetimefileinfo = sys.argv[1] # 读取文件内容放入列表host_list = []port_list = [] # 定义函数：读取文件内容放入列表中def CreateList(): f = file(fileinfo,'r') for line in f.readlines(): host_list.append(line.split(' ')[0]) port_list.append(line.split(' ')[1]) return host_list return port_list f.close() # 单线程 循环函数，注释掉了#def CreateInfo(): # for i in range(0,len(host_list)): # 单线程：直接循环列表# time.sleep(1)# TimeMark = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')# print "The Server's HostName is %-15s and Port is %-4d !!! [%s]" % (host_list[i],int(port_list[i]),TimeMark)# # 定义多线程循环调用函数def MainRange(start,stop): #提供列表index起始位置参数 for i in range(start,stop): time.sleep(1) TimeMark = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') print "The Server's HostName is %-15s and Port is %-4d !!! [%s]" % (host_list[i],int(port_list[i]),TimeMark) # 执行函数，生成列表CreateList()# 列表分割成：两部分 mid为列表的index中间位置mid = int(len(host_list)/2) # 多线程部分threads = []t1 = 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"

以上是脚本内容！！！
----------------------------------------------------------------------
：读取文件的内容
文件内容：
[root@monitor2 logdb]# 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

：输出结果：
单线程 : 执行脚本：输出结果：
[root@monitor2 logdb]# ./Threadfor.py hostinfo.txt
The Server's HostName is 192.168.10.10 and Port is 1010 !!! [2017-01-10 14:25:14]
The Server's HostName is 192.168.10.11 and Port is 1011 !!! [2017-01-10 14:25:15]
The Server's HostName is 192.168.10.12 and Port is 1012 !!! [2017-01-10 14:25:16]
.
.
.
The Server's HostName is 192.168.10.25 and Port is 1025 !!! [2017-01-10 14:25:29]

多线程：执行脚本：输出 结果
[root@monitor2 logdb]# ./Threadfor.py hostinfo.txt
The Server's HostName is 192.168.10.11 and Port is 1011 !!! [2017-01-10 14:51:51]
The Server's HostName is 192.168.10.18 and Port is 1018 !!! [2017-01-10 14:51:51]
The Server's HostName is 192.168.10.12 and Port is 1012 !!! [2017-01-10 14:51:52]
The Server's HostName is 192.168.10.19 and Port is 1019 !!! [2017-01-10 14:51:52]
The Server's HostName is 192.168.10.13 and Port is 1013 !!! [2017-01-10 14:51:53]
The Server's HostName is 192.168.10.20 and Port is 1020 !!! [2017-01-10 14:51:53]
The Server's HostName is 192.168.10.14 and Port is 1014 !!! [2017-01-10 14:51:54]
The Server's HostName is 192.168.10.21 and Port is 1021 !!! [2017-01-10 14:51:54]
The Server's HostName is 192.168.10.15 and Port is 1015 !!! [2017-01-10 14:51:55]
The Server's HostName is 192.168.10.22 and Port is 1022 !!! [2017-01-10 14:51:55]
The Server's HostName is 192.168.10.16 and Port is 1016 !!! [2017-01-10 14:51:56]
The Server's HostName is 192.168.10.23 and Port is 1023 !!! [2017-01-10 14:51:56]
The Server's HostName is 192.168.10.17 and Port is 1017 !!! [2017-01-10 14:51:57]
The Server's HostName is 192.168.10.24 and Port is 1024 !!! [2017-01-10 14:51:57]
The Server's HostName is 192.168.10.25 and Port is 1025 !!! [2017-01-10 14:51:58]

⑶ python多线程的问题。

在弹出的添加新下载对话框中全选从网址后面的一长串地址并复制。

⑷ python多线程问题

a、b线程的执行顺序是由系统进行调度决定的。这种调度有很强的随机性。因此a、b线程谁先结束、谁后结束都是未知的。你可以运行以下程序，从而进一步的观察其中a、b线程的执行情况。

后结束的线程必然是20000。因为最终次数会达到20000。而另一个必然是一个小于等于19999的数。相差次数是系统调度决定，是随机的。并不存在“循环次数越大，相差就越大”的情况。你可以多试验几次试试。

importthreading
TOTAL=0
defmain():
MY_LOCK=threading.Lock()
classCountThread(threading.Thread):
def__init__(self,threadname):
threading.Thread.__init__(self)
self.threadname=threadname


defrun(self):
globalTOTAL
foriinrange(100):
MY_LOCK.acquire()
TOTAL=TOTAL+1
MY_LOCK.release()
print('%s:%s
'%(self.threadname,TOTAL))
a=CountThread("a")
b=CountThread("b")
a.start()
b.start()

⑸ 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多线程怎么用啊，多线程的话是不是能节约时间啊

用pypy执行py脚本比默认的快。Python不支持多cPU，多线程不好用。实在不行多进程吧

⑺ python 循环中使用多线程

import time
import threading
def p(*listp):
for i in range(0,len(listp)):
print (listp[i])
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)
th2=threading.Thread(target=p,args=(p2))
threads.append(th2)

if __name__=='__main__':
for t in threads:
t.setDaemon(True)
t.start()

⑻ python 多线程 改变变量需要加锁么

python的锁可以独立提取出来

1
2
3
4
5
6
7
8

mutex = threading.Lock()
#锁的使用
#创建锁
mutex = threading.Lock()
#锁定
mutex.acquire([timeout])
#释放
mutex.release()

概念
好几个人问我给资源加锁是怎么回事，其实并不是给资源加锁, 而是用锁去锁定资源，你可以定义多个锁, 像下面的代码, 当你需要独占某一资源时，任何一个锁都可以锁这个资源
就好比你用不同的锁都可以把相同的一个门锁住是一个道理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import threading
import time

counter = 0
counter_lock = threading.Lock() #只是定义一个锁,并不是给资源加锁,你可以定义多个锁,像下两行代码,当你需要占用这个资源时，任何一个锁都可以锁这个资源
counter_lock2 = threading.Lock()
counter_lock3 = threading.Lock()

#可以使用上边三个锁的任何一个来锁定资源

class MyThread(threading.Thread):#使用类定义thread，继承threading.Thread
def __init__(self,name):
threading.Thread.__init__(self)
self.name = "Thread-" + str(name)
def run(self): #run函数必须实现
global counter,counter_lock #多线程是共享资源的，使用全局变量
time.sleep(1);
if counter_lock.acquire(): #当需要独占counter资源时，必须先锁定，这个锁可以是任意的一个锁，可以使用上边定义的3个锁中的任意一个
counter += 1
print "I am %s, set counter:%s" % (self.name,counter)
counter_lock.release() #使用完counter资源必须要将这个锁打开，让其他线程使用

if __name__ == "__main__":
for i in xrange(1,101):
my_thread = MyThread(i)
my_thread.start()

线程不安全:
最普通的一个多线程小例子。我一笔带过地讲一讲，我创建了一个继承Thread类的子类MyThread，作为我们的线程启动类。按照规定，重写Thread的run方法，我们的线程启动起来后会自动调用该方法。于是我首先创建了10个线程，并将其加入列表中。再使用一个for循环，开启每个线程。在使用一个for循环，调用join方法等待所有线程结束才退出主线程。
这段代码看似简单，但实际上隐藏着一个很大的问题，只是在这里没有体现出来。你真的以为我创建了10个线程，并按顺序调用了这10个线程，每个线程为n增加了1.实际上，有可能是A线程执行了n++，再C线程执行了n++，再B线程执行n++。
这里涉及到一个“锁”的问题，如果有多个线程同时操作一个对象，如果没有很好地保护该对象，会造成程序结果的不可预期（比如我们在每个线程的run方法中加入一个time.sleep(1)，并同时输出线程名称，则我们会发现，输出会乱七八糟。因为可能我们的一个print语句只打印出一半的字符，这个线程就被暂停，执行另一个去了，所以我们看到的结果很乱），这种现象叫做“线程不安全”

线程锁：
于是，Threading模块为我们提供了一个类，Threading.Lock，锁。我们创建一个该类对象，在线程函数执行前，“抢占”该锁，执行完成后，“释放”该锁，则我们确保了每次只有一个线程占有该锁。这时候对一个公共的对象进行操作，则不会发生线程不安全的现象了。
于是，我们把代码更改如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# coding : uft-8
__author__ = 'Phtih0n'
import threading, time
class MyThread(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
def run(self):
global n, lock
time.sleep(1)
if lock.acquire():
print n , self.name
n += 1
lock.release()
if "__main__" == __name__:
n = 1
ThreadList = []
lock = threading.Lock()
for i in range(1, 200):
t = MyThread()
ThreadList.append(t)
for t in ThreadList:
t.start()
for t in ThreadList:
t.join()

1
2
3
4
5
6
7
8
9
10
11

1 Thread-2
2 Thread-3
3 Thread-4
4 Thread-6
5 Thread-7
6 Thread-1
7 Thread-8
8 Thread-9
9 Thread-5

Process finished with exit code 0


我们看到，我们先建立了一个threading.Lock类对象lock,在run方法里，我们使用lock.acquire()获得了这个锁。此时，其他的线程就无法再获得该锁了，他们就会阻塞在“if lock.acquire()”这里，直到锁被另一个线程释放：lock.release()。
所以，if语句中的内容就是一块完整的代码，不会再存在执行了一半就暂停去执行别的线程的情况。所以最后结果是整齐的。
就如同在java中，我们使用synchronized关键字修饰一个方法，目的一样，让某段代码被一个线程执行时，不会打断跳到另一个线程中。
这是多线程占用一个公共对象时候的情况。如果多个线程要调用多个现象，而A线程调用A锁占用了A对象，B线程调用了B锁占用了B对象,A线程不能调用B对象，B线程不能调用A对象，于是一直等待。这就造成了线程“死锁”。
Threading模块中，也有一个类，RLock，称之为可重入锁。该锁对象内部维护着一个Lock和一个counter对象。counter对象记录了acquire的次数，使得资源可以被多次require。最后，当所有RLock被release后，其他线程才能获取资源。在同一个线程中，RLock.acquire可以被多次调用，利用该特性，可以解决部分死锁问题。

⑼ python多线程几种方法实现

Python进阶(二十六)-多线程实现同步的四种方式
临界资源即那些一次只能被一个线程访问的资源，典型例子就是打印机，它一次只能被一个程序用来执行打印功能，因为不能多个线程同时操作，而访问这部分资源的代码通常称之为临界区。
锁机制
threading的Lock类，用该类的acquire函数进行加锁，用realease函数进行解锁
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.lock = threading.Lock() def add(self):
self.lock.acquire()#加锁，锁住相应的资源
self.num += 1
num = self.num
self.lock.release()#解锁，离开该资源
return num

n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item def run(self):
time.sleep(2)
value = n.add()#将num加1，并输出原来的数据和+1之后的数据
print(self.item,value)for item in range(5):
t = jdThread(item)
t.start()
t.join()#使线程一个一个执行

当一个线程调用锁的acquire()方法获得锁时，锁就进入“locked”状态。每次只有一个线程可以获得锁。如果此时另一个线程试图获得这个锁，该线程就会变为“blocked”状态，称为“同步阻塞”（参见多线程的基本概念）。
直到拥有锁的线程调用锁的release()方法释放锁之后，锁进入“unlocked”状态。线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁，并使得该线程进入运行（running）状态。
信号量
信号量也提供acquire方法和release方法，每当调用acquire方法的时候，如果内部计数器大于0，则将其减1，如果内部计数器等于0，则会阻塞该线程，知道有线程调用了release方法将内部计数器更新到大于1位置。
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.sem = threading.Semaphore(value = 3) #允许最多三个线程同时访问资源

def add(self):
self.sem.acquire()#内部计数器减1
self.num += 1
num = self.num
self.sem.release()#内部计数器加1
return num

n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item def run(self):
time.sleep(2)
value = n.add()
print(self.item,value)for item in range(100):

⑽ python多线程中为什么要用for遍历所有线程然后依次调用join

线程之间的输出，需要在池中中转，死循环的时间长了，出现满栈的概率提高，外在表现就是卡一会儿