Python多线程及多线程应用实例：使用多线程批量修改主机名

python实现多线程

python中关于多线程的操作可以使用thread和threading模块来实现，其中thread模块在Py3中已经改名为_thread，不再推荐使用。而threading模块是在thread之上进行了封装，也是推荐使用的多线程模块，本文主要基于threading模块进行介绍。在某些版本中thread模块可能不存在，要使用dump_threading来代替threading模块。
线程创建

threading模块中每个线程都是一个Thread对象，创建一个线程有两种方式，一种是将函数传递到Thread对象中执行，另一种是从Thread继承，然后重写run方法（是不是跟Java很像）。

下面使用这两种方法分别创建一个线程并同时执行

 代码如下 复制代码
def threadFunction():
    for i in range(10):
        print 'ThreadFuction - %d'%i
        time.sleep(random.randrange(0,2))
class ThreadClass(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self);
       
    def run(self):
        for i in range(10):
            print 'ThreadClass - %d'%i
            time.sleep(random.randrange(0,2))
if __name__ == '__main__':
    tFunc = threading.Thread(target = threadFunction);
    tCls  = ThreadClass()
    tFunc.start()
    tCls.start()

执行结果如下，可以看到两个线程在交替打印。至于空行和一行多个输出，是因为Py的print并不是线程安全的，在当前线程的print打印了部分内容后，准备打印换行之前，被别的线程中的print抢先，在换行之前打印了其它的内容。

ThreadFuction - 0
ThreadFuction - 1
ThreadFuction - 2
ThreadClass - 0
ThreadFuction - 3
ThreadClass - 1
ThreadFuction - 4
ThreadClass - 2
ThreadClass - 3
ThreadClass - 4ThreadFuction - 5
ThreadClass - 5
ThreadClass - 6
ThreadClass - 7
ThreadClass - 8
ThreadFuction - 6ThreadClass - 9
ThreadFuction - 7
ThreadFuction - 8
ThreadFuction - 9

Thread类的构造函数定义如下
class threading.Thread(group=None, target=None, name=None, args=(), kwargs={})
group： 留作ThreadGroup扩展使用，一般没什么用
target：新线程的任务函数名
name： 线程名，一般也没什么用
args： tuple参数
kwargs：dictionary参数

Thread类的成员变量和函数如下
start() 启动一个线程
run() 线程执行体，也是一般要重写的内容
join([timeout]) 等待线程结束
name 线程名
ident 线程ID
daemon 是否守护线程
isAlive()、is_alive() 线程是否存活
getName()、setName() Name的get&set方法
isDaemon()、setDaemon() daemon的get&set方法

这里的守护线程与Linux中的守护进程并不是一个概念。这里是指当所有守护线程退出后主程序才会退出，否则即使线程任务没有结束，只要不是守护线程，都会跟着主程序一起退出。而Linux中的守护进程定义正好相反，守护进程已经脱离父进程，不会随着父进程的结束而退出。
线程同步

线程同步是多线程中的一个核心问题，threading模块对线程同步有着良好的支持、包括线程特定数据、信号量、互斥锁、条件变量等。
线程特定数据

简而言之，线程特定数据就是线程独自持有的全局变量，相互之间的修改不会造成影响。

threading模块中使用local()方法生成一个线程独立对象，举例如下，其中sleep(1)是为了保证让子线程先运行完再运行接下来的语句。

 代码如下 复制代码
data = threading.local()
def threadFunction():
    global data
    data.x = 3
    print threading.currentThread(), data.x
   
if __name__ == '__main__':
    data.x = 1
    tFunc = threading.Thread(target = threadFunction).start();
    time.sleep(1)
    print threading.current_thread(), data.x

输出如下，可以看到，Thread-1中对data.x的修改并没有影响到主线程中data.x的值。

<Thread(Thread-1, started 36208)> 3
<_MainThread(MainThread, started 35888)> 1

互斥锁

threading中定义了两种锁：threading.Lock和threading.RLock。两者的不同在于后者是可重入锁，也就是说在一个线程内重复LOCK同一个锁不会发生死锁，这与POSIX中的PTHREAD_MUTEX_RECURSIVE也就是可递归锁的概念是相同的。

关于互斥锁的API很简单，只有三个函数————分配锁，上锁，解锁。
threading.Lock() 分配一个互斥锁
acquire([blocking=1]) 上锁(阻塞或者非阻塞，非阻塞时相当于try_lock，通过返回False表示已经被其它线程锁住。)
release() 解锁

下面通过一个例子来说明互斥锁的使用。在之前的例子中，多线程print会造成混乱的输出，这里使用一个互斥锁，来保证每行一定只有一个输出。

 代码如下 复制代码
def threadFunction(arg):
    while True:
        lock.acquire()
        print 'ThreadFuction - %d'%arg
        lock.release()
if __name__ == '__main__':
    lock = threading.Lock()
    threading.Thread(target = threadFunction, args=(1,)).start();
    threading.Thread(target = threadFunction, args=(2,)).start();

条件变量

条件变量总是与互斥锁一起使用的，threading中的条件变量默认绑定了一个RLock，也可以在初始化条件变量的时候传进去一个自己定义的锁。

可用的函数如下
threading.Condition([lock]) 分配一个条件变量
acquire(*args) 条件变量上锁
release() 条件变量解锁
wait([timeout]) 等待唤醒，timeout表示超时
notify(n=1) 唤醒最大n个等待的线程
notifyAll()、notify_all() 唤醒所有等待的线程

下面这个例子使用条件变量来控制两个线程交替运行

 代码如下 复制代码
num = 0
def threadFunction(arg):
    global num
    while num < 10:
        cond.acquire()
        while num % 2 != arg:
            cond.wait()
        print 'Thread %d - %d' %(arg, num)
        num += 1
        cond.notify()
        cond.release()
if __name__ == '__main__':
    cond = threading.Condition()
    threading.Thread(target = threadFunction, args=(0,)).start();
    threading.Thread(target = threadFunction, args=(1,)).start();

输出如下

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

其实上面这个程序是有问题的，我们想打印的是0~9，但实际上10也被打印了出来，原因很简单，因为两个线程交替打印，使得num在一个线程中可能加2，从而导致10被打印出来，所以必须在打印前再次check。


下面来举个例子来说明下： 使用多线程批量修改主机名

新上的服务器初始化时，需要批量修改服务器主机名。

代码如下所示：

 代码如下 复制代码
#!/usr/bin/env python
# -*- coding : UTF-8 -*-

import re
import os,sys,datetime
import threading

class ThreadClass(threading.Thread):
  def run(self):
    now = datetime.datetime.now()
    print "%s over at time %s" % (self.getName(),now)

f = file(hostadd,r)
for line in f.readlines():
  ip = re.findall(d .d .d .d ,line)[0]
  host = line[15:].replace(" ","")
  cmd = "hostname %s && sed -i s/HOSTNAME=.*/HOSTNAME=%s/g /etc/sysconfig/network" % (host,host)
  process = os.popen(ssh %s % ip "%s" % cmd).read()
  print process
  t = ThreadClass()
  t.start()
时间： 2024-09-17 03:49:14

Python多线程及多线程应用实例：使用多线程批量修改主机名的相关文章

Python多线程和队列操作实例

  这篇文章主要介绍了Python多线程和队列操作实例,本文直接给给实例代码,需要的朋友可以参考下 Python3,开一个线程,间隔1秒把一个递增的数字写入队列,再开一个线程,从队列中取出数字并打印到终端 代码如下: #! /usr/bin/env python3 import time import threading import queue # 一个线程,间隔一定的时间,把一个递增的数字写入队列 # 生产者 class Producer(threading.Thread): def __i

Python 爬虫多线程详解及实例代码_python

python是支持多线程的,主要是通过thread和threading这两个模块来实现的.thread模块是比较底层的模块,threading模块是对thread做了一些包装的,可以更加方便的使用. 虽然python的多线程受GIL限制,并不是真正的多线程,但是对于I/O密集型计算还是能明显提高效率,比如说爬虫. 下面用一个实例来验证多线程的效率.代码只涉及页面获取,并没有解析出来. # -*-coding:utf-8 -*- import urllib2, time import thread

分析Python编程时利用wxPython来支持多线程的方法_python

如果你经常使用python开发GUI程序的话,那么就知道,有时你需要很长时间来执行一个任务.当然,如果你使用命令行程序来做的话,你回非常惊讶.大部分情况下,这会堵塞GUI的事件循环,用户会看到程序卡死.如何才能避免这种情况呢?当然是利用线程或进程了!本文,我们将探索如何使用wxPython和theading模块来实现. wxpython线程安全方法 wxPython中,有三个"线程安全"的函数.如果你在更新UI界面时,三个函数都不使用,那么你可能会遇到奇怪的问题.有时GUI也忙运行挺正

java基本教程之常用的实现多线程的两种方式 java多线程教程_java

关于线程池的内容,我们以后会详细介绍:现在,先对的Thread和Runnable进行了解.本章内容包括:Thread和Runnable的简介Thread和Runnable的异同点Thread和Runnable的多线程的示例 Thread和Runnable简介Runnable 是一个接口,该接口中只包含了一个run()方法.它的定义如下: 复制代码 代码如下: public interface Runnable {    public abstract void run();} Runnable的

Python实现程序的单一实例用法分析

  本文实例讲述了Python实现程序的单一实例用法.分享给大家供大家参考.具体如下: 这里先使用win32ui.FindWindow查找窗口名字,如果不存在则会抛出一个异常 ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 import wx import win32ui import win32con try: # 首先查找该程序是否已经运行 win = win32ui.FindWindow(None, '窗口名字') try: if win: win.

Python中super的用法实例

  这篇文章主要介绍了Python中super的用法实例,本文对比了普通继承和super继承的相关内容,从运行结果上看,普通继承和super继承是一样的,但是其实它们的内部运行机制不一样,这一点在多重继承时体现得很明显,需要的朋友可以参考下 super 是用来解决多重继承问题的,直接用类名调用父类方法在使用单继承的时候没问题,但是如果使用多继承,会涉及到查找顺序(MRO).重复调用(钻石继承)等种种问题.总之前人留下的经验就是:保持一致性.要不全部用类名调用父类,要不就全部用 super,不要一

python通过定义一个类实例作为ftp回调方法

  本文实例讲述了python通过定义一个类实例作为ftp回调方法.分享给大家供大家参考.具体实现方法如下: ? 1 2 3 4 5 6 7 8 9 10 11 12 class Writer: def __init__(self, file): self.f = open(file, "w") def __call__(self, data): self.f.write(data) self.f.write('n') print data FILENAME = "AutoI

Python psutil模块简单使用实例

  这篇文章主要介绍了Python psutil模块简单使用实例,本文直接给出使用脚本,实现查看cpu的信息.查看内存信息.查看系统启动时间.查看网卡信息等,需要的朋友可以参考下 安装很简单 代码如下: pip install psutil 官网地址为: https://pythonhosted.org/psutil/ (文档上有详细的api) github地址为: https://github.com/giampaolo/psutil/ psutil比较好的地方,一个是跨平台,不需要切换平台的

Python实现命令行通讯录实例教程_python

1.实现目标 编写一个命令行通讯录程序,可以添加.查询.删除通讯录好友及电话 2.实现方法 创建一个类来表示一个人的信息.使用字典存储每个人的对象,名字作为键. 使用pickle模块永久地把这些对象存储下来. 使用字典内建的方法添加.删除修改人员信息. 3.思维导图 4.编写伪代码 # 1.创建字典用来存储通讯录信息 # 2.创建人员类,包含姓名.关系.电话三个属性 # 3.创建操作类,包含增加.查询.删除人员,退出,保存并退出五个方法 # 4.程序运行 # 5.判断通讯录文件是否存在 # 6.