线程

#!/usr/bin/env python
#coding:utf-8

import time

from threading import Thread

def foo(arg,v):
    for item in range(100):
        print item
        time.sleep(1)

print 'before'
t1 = Thread(target=foo,args=('addfa',11,))#将线程与方法联系起来，两者建立关系，该格式的固定格式，前者是函数名，后者是要传递的参数，后面需要逗号，说明是个序列

t1.setDaemon(True)#在执行线程之前确定
#设置为后台线程或前台线程（默认Flase）
#如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止
#如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止

t1.start()
#print t1.getName()#获得线程的名字
#t1.join(5)#逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义,加上参数之后变成先执行5个，然后再继续向下执行
print t1.isDaemon()

print 'after'
print 'after'
print 'after'
time.sleep(10)



#主线程从上往下执行，当主线程创建子线程之后，然后主线程再继续往下走，不去管子线程。就算主线程执行完了，也得等子线程执行完了才能结束程序。

 自定义线程类
 1 #!/usr/bin/env python
#coding:utf-8

from threading import Thread
import time

class mythread(Thread):
    def run(self):
        time.sleep(10)
        print '我是线程'


def bar():
    print 'bar'


t1 = mythread(target=bar())#不加参数是可以只写一个参数,自定义线程类跟不自定义的参数是不一样的
t1.start()

print 'over'

生产者消费者

#!/usr/bin/env python
#coding:utf-8

from threading import Thread
from Queue import Queue
import time

class procuder(Thread):#生产者
    #def __init__(self, group=None, target=None, name=None,args=(), kwargs=None, verbose=None):
        #super(procuder).__init__(self, group=None, target=None, name=None,args=(), kwargs=None, verbose=None)

    def __init__(self,name,queue):
        self.__name=name
        self.__queue=queue
        super(procuder, self).__init__()
        '''
        @:param name:生产者的名字
        @:param queue:容器
        '''
    def run(self):
        while True:
            if self.__queue.full():
                time.sleep(1)
            else:
                self.__queue.put('baozi')
                print '%s 生产了一个包子'%(self.__name,)
        #Thread.run(self)



class consumer(Thread):#消费者
    def __init__(self,name,queue):
        self.__name=name
        self.__queue=queue
        super(consumer,self).__init__()
        '''
        @:param name:消费者的名字
        @:param queue:容器
        '''
    def run(self):
        while True:
            if self.__queue.empty():
                time.sleep(1)
            else:
                self.__queue.get()
                print '%s 消费了一个包子' % (self.__name,)
        #Thread.run(self)

que=Queue(maxsize=100)#队列最大存放100个数据

#三个生产者
laogou1=procuder('老狗1',que)
laogou1.start()
laogou2=procuder('老狗2',que)
laogou2.start()
laogou3=procuder('老狗3',que)
laogou3.start()

#20个消费者
for item in range(20):
    name='chentao%d'%(item,)
    temp=consumer(name,que)
    temp.start()








'''
print que.qsize()
que.put('1')#往队列放数据
que.put('2')
print que.empty()
print que.qsize()
print que.get()#一次只能拿一个参数
print que.get()
print que.empty()#看队列是否为空
'''

进程锁
 1 #!/usr/bin/env python
#coding:utf-8

import threading
import time

num=0

def run(n):

    time.sleep(1)
    global num

    lock.acquire()#获取锁，独占cpu操作，需要操作的时候再加上锁
    num+=1
    print '%s
'%num
    lock.release()#释放锁

lock=threading.Lock()#加上锁

#samp=threading.BoundedSemaphore(4)#允许同时有多少个线程进去

for i in range(100):
    t=threading.Thread(target=run,args=(i,))
    t.start()

'''
def run(n):

    time.sleep(1)
    global num
    global num2
    lock.acquire()
    num+=1
    lock.acquire()
    num2+=2
    print '%s
'%num
    lock.release()
    lock.release()
这种情况就是同时打开两把相同的锁之后不知道该怎么办了，此时就需要使用RLock,可以允许同时获得几个锁，打开几把锁就需要关闭几把锁
lock=threading.RLock()
'''