python多线程和协程开发入门上手
python多线程和协程开发入门上手
今天学习了一下python的多线程的基本知识，感觉随threading稍有些啰嗦但是，比起java的语法还是简洁了不少，由于python本身根据全局锁的设计，所以python的多线程其实本质上不是真正意义上的多线程，因为在无论多么细微的同一个时间点永远都只有一个线程在跑，也许是出于安全的角度才这样设计，不过依然可以大大提高效率。
threading入门例子
最简单的一个例子：
import threading
def test(s):
print
a=threading.Thread(target=test,args=[1])
b=threading.Thread(target=test,args=[2])
a.start()
b.start()mpt'''开启10个线程
最简单的一个例子：
threadlist=[]
for i in range(10):
tmp=threading.Thread(target=test,args=[i])
tmp.start()
threadlist.append(tmp)
[x.join() for x in threadlist]
print 'end!'效率最白痴测试
效率测试：
# def a():
# print 'a begin!'
# time.sleep(2)
# print 'a end!'
# def b():
# print 'b begin'
# time.sleep(2)
# print 'b end'
#
# tmptime=time.time()
# a()
# b()
# print 'tim1',time.time()-tmptime
# tmptime=time.time()
# t1=threading.Thread(target=a)
# t2=threading.Thread(target=b)
# t1.start()
# t2.start()
# t1.join()
# t2.join()
# print time.time()-tmptime加锁和释放锁
最简单的一个例子：
money=500
mLock=threading.Lock()
def addmoney():
global money
mLock.acquire()
for i in range(100):
money+=1
mLock.release()
threads=[]
for x in range(10):
tmp=threading.Thread(addmoney())
tmp.start()
threads.append(tmp)
[t.join() for t in threads]
print money多线程读取文件
最简单的一个例子：
#多线程读取文件或者list
mutex = threading.Lock()
fp = open('D:\\2016-04-01_hi27_ni.txt')
class Reader(threading.Thread):
def __init__(self, num):
threading.Thread.__init__(self)
self.num = num
def run(self):
while True:
with mutex:
line = fp.readline()
if len(line) == 0:
return
print str(self.num)+' '+line
time.sleep(0.1)
if __name__ == '__main__':
r1 = Reader(1)
r2 = Reader(2)
r1.start()
r2.start()
r1.join()
r2.join()非常好用的map
最简单的一个例子：
from multiprocessing.dummy import Pool as ThreadPool
urls = [
'http://www.python.org',
'http://www.python.org/about/',
'http://www.onlamp.com/pub/a/python/2003/04/17/metaclasses.html',
'http://www.python.org/doc/',
'http://www.python.org/download/',
'http://www.python.org/getit/',
'http://www.python.org/community/',
'https://wiki.python.org/moin/',
'http://planet.python.org/',
'https://wiki.python.org/moin/LocalUserGroups',
'http://www.python.org/psf/',
'http://docs.python.org/devguide/',
'http://www.python.org/community/awards/'
# etc..
]*100000
# Make the Pool of workers
pool = ThreadPool(4)
# Open the urls in their own threads
# and return the results
results = pool.map(lambda x:x[-3], urls)
print '\n'.join(results)
#close the pool and wait for the work to finish
pool.close()
pool.join()下面是关于协程：
协程说白了就是两个函数相互配合，达到多线程的效果。
通过生成器来产生的，效率极高，比方说xrange就是这样实现的，只是在遍历的时候才会去生成，不用像range一样立刻生成一块内存，效率高。
next 和send（none）等价，第一次是启动， 执行该函数到yield处停止跳回代码。
a=yield b
那么调用next或者send（c）传过去的值就是a
而返回的的值就是b。
r1=c.send(b)那么把b传给对面函数的yield后，执行到下一个yield就会返回的值让r1接住。
r1=c.next()同样道理只是没有传递值.
c是对面的函数
对于编码人员来说协程是两个函数相互传递信息并配合。不是多线程，但能取得多线程的效果
入门级别例子
最简单的一个例子：
def product():
for i in xrange(10):
print 'I come to ' ,i
yield i
a=product()
[a.next()for x in range(5)]
斐波那契数列的写法
最简单的一个例子：
# fibonacci 不需要参数，因为可以无限下去
def fibonacci():
a=1
b=1
yield a
yield b
while True:
a,b=b,a+b
yield b
fib=fibonacci()
print [fib.next()for x in range(100)]
生产者和消费者问题
最简单的一个例子：
# fibonacci 不需要参数，因为可以无限下去
def consumer():
r = ''
while True:
n = yield r
if not n:
return
print('[CONSUMER] ←← Consuming %s...' % n)
time.sleep(1)
r = '200 OK'
def produce(c):
# 1、首先调用c.next()启动生成器
c.next()
n = 0
while n < 5:
n = n + 1
print('[PRODUCER] →→ Producing %s...' % n)
# 2、然后，一旦生产了东西，通过c.send(n)切换到consumer执行；
cr = c.send(n)
# 4、produce拿到consumer处理的结果，继续生产下一条消息；
print('[PRODUCER] Consumer return: %s' % cr)
# 5、produce决定不生产了，通过c.close()关闭consumer，整个过程结束。
c.close()
# 6、整个流程无锁，由一个线程执行，produce和consumer协作完成任务，所以称为“协程”，而非线程的抢占式多任务。
c = consumer()
produce(c)