创建线程
创建线程的两种方法：
1，直接调用threading.Thread来构造thread对象，Thread的参数如下：
class threading.Thread(group=None, target=None, name=None, args=(), kwargs={})
group为None；
target为线程将要执行的功能函数；
name为线程的名字，也可以在对象构造后调用setName()来设定；
args为tuple类型的参数，可以为多个，如果只有一个也的使用tuple的形式传入，例如(1,)；
kwargs为dict类型的参数，也即位命名参数
threading.Thread对象的其他方法：
start()，用来启动线程；
join(), 等待直到线程结束；
isAlive(),获取线程状态
setDeamon(), 设置线程为deamon线程，必须在start()调用前调用，默认为非demon。
注意： python的主线程在没有非deamon线程存在时就会退出。
threading.currentthread() , 用来获得当前的线程；
threading.enumerate() ， 用来多的当前存活的所有线程；
#coding:utf-8import threadingdef func1(num): for i in range(num): #threading.currentThread()获取当前线程，getName()获取线程名字 print 'I am %s.num:%s' % (threading.currentThread().getName(), i) def main(thread_num): thread_list = [] #定义一个线程列表 for i in range(thread_num): thread_list.append(threading.Thread(target=func1, args = (3, ))) for a in thread_list: #a.setDaemon(True)这个setDaemon默认为False 非守护线程 #表示主线程等所有子线程结束后，在结束 #设置为True的话 表示是个守护线程 子线程就会随着主线程的结束而结束 #听说服务监控工具生成的心跳线程 就是用的守护线程 a.start() for a in thread_list: a.join() #表示等待直到线程运行完毕 main(3)
运行结果
I am Thread-1.num:0I am Thread-1.num:1I am Thread-1.num:2I am Thread-2.num:0I am Thread-2.num:1I am Thread-2.num:2I am Thread-3.num:0I am Thread-3.num:1I am Thread-3.num:2
2，直接从threading.Thread继承，然后重写__init__方法和run方法
#coding:utf-8import threadingclass MyThread(threading.Thread): #继承父类threading.Thread def __init__(self, num ): threading.Thread.__init__(self) self.num = num #把要执行的代码写到run函数里面 线程在创建后会直接运行run函数 def run(self): for i in range(self.num): print 'I am %s.num:%s' % (self.getName(), i) for i in range(3): t = MyThread(3) t.start() t.join()
运行结果
I am Thread-1.num:0I am Thread-1.num:1I am Thread-1.num:2I am Thread-2.num:0I am Thread-2.num:1I am Thread-2.num:2I am Thread-3.num:0I am Thread-3.num:1I am Thread-3.num:2
锁的使用
假设我们有一个公共数据x(也可以叫共享资源，临界资源)，然后跑10个线程都去访问这变量并对这个变量进行修改的操作，那么就得到意料之外的结果。
import threading # 导入threading模块import time # 导入time模块class mythread(threading.Thread): # 通过继承创建类 def __init__(self,threadname): # 初始化方法 # 调用父类的初始化方法 threading.Thread.__init__(self,name = threadname) def run(self): # 重载run方法 global x # 使用global表明x为全局变量 for i in range(3): x = x + 1 time.sleep(2) # 调用sleep函数，让线程休眠5秒 print x tl = [] # 定义列表for i in range(10): t = mythread(str(i)) # 类实例化 tl.append(t) # 将类对象添加到列表中 x=0 # 将x赋值为0for i in tl: i.start() # 依次运行线程
运行结果
[root@localhost ~]# python syn.py
由于x是全局变量（共享资源），每个线程对x操作后就休眠了
在线程休眠的时候其他线程也都开始执行操作，
最终休眠5秒后x的值最终就被修改为30了
使用互斥锁来保护公共资源。用互斥锁来保证同一时刻只有一个线程访问公共资源,实现简单的同步
互斥锁：threading.Lock
互斥锁方法：acquire() 获取锁 release():释放锁
当有一个线程获的锁之后，这把锁就会进入locke状态（被锁起来了），另外的线程试图获取锁的时候就会变成同步阻塞状态，
当拥有线程锁的的线程调用锁方法 release()之后就会释放锁，那么锁就会变成开锁unlocked状态，之后再从同步阻塞状态的线程中选择一个来获得锁
import threading # 导入threading模块import time # 导入time模块class mythread(threading.Thread): # 通过继承创建类 def __init__(self,threadname): # 初始化方法 threading.Thread.__init__(self,name = threadname) def run(self): # 重载run方法 global x # 使用global表明x为全局变量 lock.acquire() # 调用lock的acquire方法 for i in range(3): x = x + 1 time.sleep(2) # 调用sleep函数，让线程休眠5秒 print x lock.release() # 调用lock的release方法lock = threading.Lock() # 类实例化tl = [] # 定义列表for i in range(10): t = mythread(str(i)) # 类实例化 tl.append(t) # 将类对象添加到列表中 x=0 # 将x赋值为0for i in tl: i.start() # 依次运行线程
运行结果：
[root@localhost ~]# python syn.py
可重入锁：threading.RLock()
方法和互斥锁一样。
假设一个锁嵌套的情况：有个线程以及获取到锁和共享资源了，但是又需要一把锁来获取另外一个资源，那么只要把代码里面的：
修改为：
