Python之路_Day11

Python之路_Day11_课堂笔记

前期回顾




本节摘要
一、多线程
基本使用
生产者消费者模型(队列)
自定义线程池
二、多进程
基本使用
进程池
三、协程
greenlet
gevent
四、缓存
memcache
redis
五、rabbitMQ

六、下节预告：
MySQL
ORM框架-sqlchemy
堡垒机


一、线程
创建线程的两种基本使用方法：
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. import threading
  7. # def f1(arg):
  8. #     print(arg)
  9. #
  10. # t = threading.Thread(target=f1,args=(123,))
  11. # t.start()
  14. class MyThread(threading.Thread):
  15.     def __init__(self,func,args):
  16.         self.func = func
  17.         self.args = args
  18.         super(MyThread,self).__init__()
  20.     def run(self):
  21.         self.func(self.args)
  23. def f2(arg):
  24.     print(arg)
  26. obj = MyThread(f2,123)
  27. obj.start()

先进先出队列Queue：
put放数据，是否阻塞，阻塞时的超时时间
get取数据（默认阻塞），是否阻塞，阻塞时的超时时间
队列最大长度
qsize()真实个数
maxsize最大支持的个数
join,task_done,阻塞进程，当队列中任务执行完毕后，释放阻塞，不再阻塞
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. import queue
  7. q = queue.Queue(3)
  8. print(q.empty())
  9. q.put(11)
  10. q.put(22)
  11. q.put(33)
  12. print(q.empty())
  13. print(q.qsize())
  14. q.put(44)
  15. q.put(55,block=False)
  16. q.put(55,block=False,timeout=2)
  17. print(q.get())
  18. print(q.get())
  19. print(q.get())
  20. print(q.get(timeout=2))
  22. q = queue.Queue(5)
  23. q.put(123)
  24. q.put(456)
  25. q.get()
  26. q.task_done()
  27. q.get()
  28. q.task_done()
  29. q.join()

后进先出队列LifoQueue：

  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. import queue
  7. q = queue.LifoQueue()
  8. q.put(123)
  9. q.put(456)
  10. print(q.get())




优先级队列PriorityQueue：

  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. import queue
  7. # 优先级队列
  8. q = queue.PriorityQueue()
  9. q.put((1,123))
  10. q.put((2,456))
  11. q.put((3,789))
  12. print(q.get())


双向队列deque：

  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. import queue
  7. # 双向队列
  8. q = queue.deque()
  9. q.append(123)
  10. q.append(456)
  11. q.appendleft(789)
  12. q.pop()
  13. q.popleft()

生产者消费者模型：


  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  4. # 生产者消费者模型
  6. import queue
  7. import threading
  8. import time
  10. q = queue.Queue(20)
  12. def productor(arg):
  13.     '''
  14.     买票
  15.     :param arg:
  16.     :return:
  17.     '''
  18.     q.put(str(arg) + ' 火车票 ')
  20. for i in range(300):
  21.     t = threading.Thread(target=productor,args=(i,))
  22.     t.start()
  24. def consumer(arg):
  25.     '''
  26.     服务器后台
  27.     :param arg:
  28.     :return:
  29.     '''
  30.     while True:
  31.         print(arg,q.get())
  32.         time.sleep(2)
  34. for j in range(3):
  35.     t = threading.Thread(target=consumer,args=(j,))
  36.     t.start()


线程锁
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. import threading
  6. import time
  8. NUM = 10
  10. def func(l):
  11.     global NUM
  12.     # 上锁
  13.     l.acquire()
  14.     NUM -= 1
  15.     time.sleep(2)
  16.     print(NUM)
  17.     # 开锁
  18.     l.release()
  20. lock = threading.RLock()    # 支持多层所，嵌套锁
  21. # lock = threading.Lock()     # 只支持单层所
  23. for i in range(10):
  24.     t = threading.Thread(target=func , args=(lock,))
  25.     t.start()

  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. import threading
  7. def func(i,e):
  8.     print(i)
  9.     e.wait()    # 检测时什么灯，如果是红灯，停，绿灯，行；
  10.     print(i+100)
  12. event = threading.Event()
  14. for i in range(10):
  15.     t = threading.Thread(target=func,args=(i,event,))
  16.     t.start()
  18. event.clear()   # 设置成红灯
  19. inp = input('>>>')
  20. if inp == '1':
  21.     event.set() # 设置成绿灯

MF8SE9UCMHW%9HHA{YT}328.png

6H2`WT%X2ZK$[5]UHM$EU`C.png

线程池
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. import queue
  6. import threading
  7. import time
  9. class ThreadPool:
  10.     def __init__(self,maxsize=5):
  11.         self.maxsize = maxsize
  12.         self._q = queue.Queue(maxsize)
  13.         for i in range(maxsize):
  14.             self._q.put(threading.Thread)
  16.     def get_thread(self):
  17.         return self._q.get()
  19.     def add_thread(self):
  20.         self._q.put(threading.Thread)
  22. pool = ThreadPool(5)
  24. def task(arg, p):
  25.     print(arg)
  26.     time.sleep(1)
  27.     p.add_thread()
  29. for i in range(100):
  30.     t = pool.get_thread()
  31.     obj = t(target=task,args=(i,pool,))
  32.     obj.start()




二、进程
基本使用
默认数据不共享
queues
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  4. # 进程基本使用，
  6. from multiprocessing import Process
  7. from multiprocessing import queues
  8. import multiprocessing
  10. def foo(i,arg):
  11.     arg.put(i)
  12.     print('say hi',i ,arg.qsize())
  14. if __name__ == "__main__":
  15.     li = queues.Queue(20,ctx=multiprocessing)
  16.     for i in range(10):
  17.         p = Process(target=foo,args=(i,li,))
  18.         p.start()

array
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  4. # 进程基本使用2
  6. from multiprocessing import Process
  7. from multiprocessing import queues
  8. import multiprocessing
  9. from multiprocessing import Array
  11. def foo(i,arg):
  12.     arg[i] = i + 100
  13.     for item in arg:
  14.         print(item)
  15.     print('============')
  17. if __name__ == "__main__":
  18.     li = Array('i',10)
  19.     for i in range(10):
  20.         p = Process(target=foo,args=(i,li,))
  21.         p.start()

Manager.dict
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  4. # 进程基本使用3
  6. from multiprocessing import Process
  7. from multiprocessing import queues
  8. import multiprocessing
  9. from multiprocessing import Manager
  11. def foo(i,arg):
  12.     arg[i] = i + 100
  13.     print(arg.values())
  15. if __name__ == "__main__":
  16.     obj = Manager()
  17.     li = obj.dict()
  18.     for i in range(10):
  19.         p = Process(target=foo,args=(i,li,))
  20.         p.start()
  21.     import time
  22.     time.sleep(1)

进程池
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  4. # 进程池
  6. from multiprocessing import Pool
  7. import time
  9. def f1(arg):
  10.     time.sleep(1)
  11.     print(arg)
  13. if __name__ == "__main__":
  14.     pool = Pool(5)
  15.     for i in range(30):
  16.         # pool.apply(func=f1,args=(i,))
  17.         pool.apply_async(func=f1,args=(i,))
  19.     # pool.close()    # 所有的任务执行完毕
  20.     # time.sleep(1)
  21.     # pool.terminate()    # 立即终止
  22.     # pool.join()




PS：
IO密集型使用多线程
计算密集型使用多进程


三、协程
原理：利用一个线程，分解一个线程成为多个“微线程” ===>程序级别

greenlet
gevent
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. from gevent import monkey ; monkey.patch_all()
  6. import gevent
  7. import requests
  9. def f(url):
  10.     print('GET: %s ' % url)
  11.     resp = requests.get(url)
  12.     data = resp.text
  13.     print('%d bytes received from %s.' % (len(data),url ))
  15. gevent.joinall([
  16.     gevent.spawn(f,'http://www.python.org'),
  17.     gevent.spawn(f,'http://www.yahoo.com'),
  18.     gevent.spawn(f,'http://www.github.com')
  19. ])


四、缓存
1、安装软件
2、程序：安装其对应的模块
Socket连接，

Memcache
1、天生的集群
2、基本操作
3、gets和cas

Redis
LQ01`K[5EZNCSLDPN7$GTJ6.png

AKYO@1Z@KI]BF@O{NE$2L)P.png










http://www.cnblogs.com/wupeiqi/articles/5132791.html

http://www.cnblogs.com/wupeiqi/articles/4839959.html

http://www.cnblogs.com/wupeiqi/articles/5040827.html










【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/sandler613/p/5720003.html