备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

Python Day Eleven

2017-11-08 916
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

目录：


一、线程

    1.线程基本操作 

        1.创建线程的方式

        2.线程锁

        3.信号量以及事件

        4.条件以及定时器

    2.队列的使用

        1.队列的使用

        2.生产者消费者模型

    3.自定义线程池


二、进程   

    1.进程基本操作

        1.创建进程

        2.进程锁

    2.进程池


三、协程

   1.greenlet

    2.gevent


四、缓存    

    1.python操作memcache

    2.python操作redis

一、线程

    

  1.线程基本操作

      1.创建线程的方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#创建线程方法一（最常见）
import  threading
 
def  f1(args):
     print (args)
t  =  threading.Thread(target = f1,args = ( 123 ,))
t.start()    #线程开启，等待cpu调用
 
'''
t.run() 方法：
     当cpu调度的时候，就执行Thread里边的run方法
     t.run() #是由cpu替我们调度执行的
'''
 
#创建线程方法二 (通过创建类创建线程) (自定义方式)
import  threading
class  MyThread(threading.Thread):
     def  __init__( self ,func,args):  #定义init，就不执行父类的方法了，执行自己的
         self .func  =  func
         self .args  =  args
         super (MyThread, self ).__init__()
     def  run( self ):
         self .func( self .args)
 
def  f2(arg):
     print (arg)
obj  =  MyThread(f2, 123 )             #func = f2  args=123
obj.start()

      2.线程锁（同时只允许一个线程进入取值。）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
线程锁分类：
     1.
         l.acquire()
         l.release()
         lock  =  threading.Lock()      #只能锁一次
     2.
         l.acquire()
         l.release()
         lock  =  threadingRLock()     #可以递归锁，可以锁多层，可以嵌套。 （常用）
 
例子：
当有一个数字 10 ，如果同时 10 个线程去减 1 ，
那么就会产生脏数据，输出结果都输出为 0 。
 
#例1
import  threading
import  time
NUM  =  10
 
def  func(l):
     global  NUM
     NUM  - =  1
     time.sleep( 2 )            #会产生脏数据，造成输出都是0
     print (NUM)
lock  =  threading.Lock()      #只能锁一次
for  i  in  range ( 10 ):
     t  =  threading.Thread(target = func,args = (lock,))
     t.start()
 
#解决此问题就是加锁，同时只允许一个线程进入取值。；(单层锁)
#例2
import  threading
import  time
NUM  =  10
 
def  func(l):
     global  NUM
     l.acquire()              #上锁 使同一时刻只有一个进程使用
     NUM  - =  1
     time.sleep( 2 )            #会产生脏数据，造成输出都是0
     print (NUM)
     l.release()              #开锁
lock  =  threading.Lock()      #只能锁一次
for  i  in  range ( 10 ):
     t  =  threading.Thread(target = func,args = (lock,))
     t.start()
     
#例3 多层锁
import  threading
import  time
NUM  =  10
 
def  func(l):
     global  NUM
     #上锁               #使同一时刻只有一个进程使用
     l.acquire()
     NUM  - =  1
     l.acquire()      #多层锁
     time.sleep( 2 )        #会产生脏数据，造成输出都是0
     l.release()      #多层锁
     print (NUM)
     l.release()      #开锁
#lock = threading.Lock()     #只能锁一次
lock  =  threading.RLock()     #可以递归锁，可以锁多层，可以嵌套。
for  i  in  range ( 10 ):
     t  =  threading.Thread(target = func,args = (lock,))
     t.start()

      3.信号量以及事件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
信号量（semaphore）（同时允许一定数量的线程更改数据）
 
#例1 信号量（semaphore）（同时允许一定数量的线程更改数据）
import  threading
import  time
NUM  =  10
 
def  func(i,l):
     global  NUM
     #上锁             #使同一时刻只有一个进程使用
     lock.acquire()        #一次放5个出去
     NUM  - =  1
     time.sleep( 2 )        #会产生脏数据，造成输出都是0
     print (NUM,i)
     #开锁
     lock.release()
lock  =  threading.BoundedSemaphore( 5 )
for  i  in  range ( 30 ):
     t  =  threading.Thread(target = func,args = (i,lock,))
     t.start()
     
#例2 事件（event）（事件用于主线程控制其他线程的执行，相当于红绿灯。主要有三个方法：set、wait、clear）
#批量将所有线程挡住，改一个标识，全部放走
#内部就是维护了一个状态，默认是False，改成True就能走了 。
#输出结果顺序不一样，是因为线程调度事件不一样
import  threading
 
def  func(i,e):
     print (i)
     e.wait()         #表示它在这等待；检测是什么灯，如果是红灯就停；
     print (i + 100 )
event  =  threading.Event()
for  i  in  range ( 10 ):
     t  =  threading.Thread(target = func,args = (i,event,))
     t.start()
#==========
event.clear()        #主动设置成红灯就是False，默认是False
inp  =  input ( ">>" )
if  inp  = =  "1" :      #当输入1的时候就继续
     event. set ()      #把上边的红灯设置成绿灯，将Flag设置为True

      4.条件以及定时器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
条件Condition （使得线程等待，只有满足某条件时，才释放n个线程）
 
#例1： 当输入数字等于几时，那么久释放几个线程过去。
import  threading
 
def  run(n):
     con.acquire()        #配合下边wait使用
     con.wait()           #在这里等着了
     print ( "run the thread: %s"  % n)
     con.release()
 
if  __name__  = =  '__main__' :
 
     con  =  threading.Condition()      #创建条件
     for  i  in  range ( 10 ):
         t  =  threading.Thread(target = run, args = (i,))
         t.start()
 
     while  True :
         inp  =  input ( '>>>' )
         if  inp  = =  'q' :
             break
         #以下三行是固定用法
         con.acquire()
         con.notify( int (inp))
         con.release()
         
#当条件满足之后，出去一个，再满足，再出去一个
#例2     当满足条件，输入true，那么就i+100 ，再输入true 下个数再加100
import  threading
def  condition():
     ret  =  False
     r  =  input ( ">>>>" )
     if  r  = =  'true' :
         ret  =  True
     else :
         ret  =  False
     return  ret
 
def  func(i,con):
     print (i)
     con.acquire()    #配合下边wait使用
     con.wait_for(condition)   #在这里等着了
     print (i + 100 )
     con.release()
 
c  =  threading.Condition()
for  i  in  range ( 10 ):
     t  =  threading.Thread(target = func,args = (i,c,))
     t.start()
     
#定时器 Timer   （定时器，指定n秒后执行某操作）
#例3
#1秒钟之后执行某函数
#应用到写客户端、监控的时候。
 
from  threading  import  Timer
 
def  hello():
     print ( "hello world" )
 
t  =  Timer( 1 ,hello)     #1秒钟之后执行
t.start()

  2.队列的使用（Python中队列是线程间最常用的交换数据的形式）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
1.queue 队列
     基本特点：
         先进先出
     方法：
         put         放数据，是否阻塞，阻塞时的超时时间
         get         取数据，默认阻塞，是否阻塞，阻塞时的超时时间
         q.empty     检查队列是否为空，为空返回 True ，否则 False
         q.full      判对是否满了
         q.qsize     队列里边有几个元素；当前真实个数
         q.maxsize   元素最大支持的个数
         q.join      如果队列任务没有完成，还在等待。
         q.taskdone  每一次取完数据的时候执行q.task_done（），告诉我执行完了，系统做一个计数。表示我取完数据了
         join,task_done 阻塞进程，当队列中任务执行完毕之后，不再阻塞。
2. 其他队列：
     1 、后进先出
         queue.LifoQueue
     2 、优先级队列 （放数据的时候加上权重值；内容包括：数据 + 权重）
         queue.PriorityQueue
     3 、双向队列    （两边存、两边取）
         queue.deque
 
import  queue         #导入队列模块
 
q  =  queue.Queue( 10 )           #创建一个队列；参数10代表最多接收10个数据。放不进去就等着或者报错
q.put( 11 ,timeout = 2 )           #放数据；timeout=2 代表等待2秒，如果还没有位置就报错；有位置就加进去
q.put( 22 ,block = False )        #默认block是阻塞等待，只要没有位置就等待；如果改成True，就不等待，直接报错
q.put( 33 )
print (q.qsize())              #显示当前多少数据
print (q.get(block = False ))    #取数据；默认是阻塞，默认情况下没有数据的时候就一直等待，
print (q.empty())              #检查队列是否为空，为空返回True，否则False
#输出
     3
     11
     False
 
q  =  queue.Queue( 5 )
q.put( 33 )
q.put( 44 )
print (q.get())
print (q.task_done())
print (q.get())
print (q.task_done())
#输出：
     33
     None
     44
     None
#每一次取完数据的时候执行q.task_done（），告诉我执行完了，系统做一个计数。表示我取完数据了
#q.join()    #如果队列任务没有完成，还在等待。
 
#queue.LifoQueue    特点：后进先出
q  =  queue.LifoQueue()
q.put( 123 )
q.put( 456 )
print (q.get())       #456是后进去的，先取出来
#输出：
     456
 
#queue.PriorityQueue    特点：优先级队列
q  =  queue.PriorityQueue()
q.put(( 1 , 'aaa' ))
q.put(( 2 , 'bbb' ))
print (q.get())       #按照优先级取数据，如果优先级相同，谁先放，先取谁
#输出：
     ( 1 ,  'aaa' )
 
#queue.deque    特点：双向队列（两边都可以取数据，都可以放数据）
q  = queue.deque()
q.append( 123 )
q.append( 456 )
q.appendleft( 333 )    #左边放数据
print (q.pop())       #取数据，默认取最右边的
print (q.popleft())   #左边取数据
#输出：
     456
     333

  3.自定义线程池

1
<br>




     本文转自506554897 51CTO博客，原文链接：http://blog.51cto.com/506554897/1843549，如需转载请自行联系原作者
文章标签：
Python
调度
技术小胖子
目录
相关文章
使者大牙
|
30天前
|
Python
基于Python画曼德勃罗集
基于Python画曼德勃罗集
使者大牙
11 1
白猫a
|
8月前
|
人工智能 开发框架 Java
Python到底能做什么
Python到底能做什么
白猫a
41 0
bill19970108118
|
10月前
|
运维 算法 Java
Python
python是一种面向对象，直译式的计算机程序语言，Python崇尚优美、清晰、简单，是一个优秀并广泛使用的语言。
bill19970108118
107 0
游客rigajubvzf2hs
|
Python
python colormaps汇总
最近在进行python绘制散点图时，需要将一些数据根据大小进行颜色显示。需要引入colormaps模块，现将color maps进行汇总如下：
游客rigajubvzf2hs
141 0
python colormaps汇总
游客s7g2tqb7xnb3e
|
自然语言处理 Java 程序员
初识python
Python是1门程序设计语言。在开发者眼里，语言可以分为3类： 1.自然语言：人能听懂的语言，例如汉语，英语，法语等等。 2.机器语言：机器能听懂的语言，机器只能听懂0和1。 3.程序设计语言：机器能够听懂，人能听懂的语言，例如Python，C，C++ 、C# 、Java等等。 同样的，在开发者眼里还可以分为高级程序设计语言和低级程序设计语言。越接近于人类的语言越高级 ，例如Python；越接近于机器语言越低级，例如汇编就属于低级程序员设计语言。
游客s7g2tqb7xnb3e
91 0
初识python
Violent-Ayang
|
机器学习/深度学习 Python
(Python)矩阵旋转
(Python)矩阵旋转
Violent-Ayang
82 0
auqbllxiu
|
Python
Python：使用2to3将Python2转Python3
Python：使用2to3将Python2转Python3
auqbllxiu
40 0
邻居的尾巴
|
JSON 数据格式 Python
每天一个Python小技巧(1)
每天一个Python小技巧(1)
邻居的尾巴
99 0
每天一个Python小技巧(1)
馆主阿牛
|
Python
用python画福字
春节快到了，一年一度的支付宝集五福活动就要来了，阿牛也是突发奇想，看能不能用python的turtle库画个"福"字，试了很久，我的这个“福“”字终于看起来可以了，现将源码分享给大家，拿过去放到python的环境中就可以直接运行哦！嘿嘿嘿！这五福手到擒来啦！
馆主阿牛
176 0
用python画福字
cxhuan
|
Python
Python 小技之繁花盛开
Python 小技之繁花盛开
cxhuan
138 0
Python 小技之繁花盛开

热门文章

最新文章

  • 1
    Mac安装并使用telnet命令操作
  • 2
    OSS回源的几种方式和应用场景
  • 3
    [剑指offer] 孩子们的游戏(圆圈中最后剩下的数)
  • 4
    网络安全系列之二十二 Windows用户账号加固
  • 5
    我理解的一个程序员如何学习前端开发
  • 6
    《社交网站界面设计（原书第2版）》——1.9　为设备之间的空间进行设计
  • 7
    《Microduino实战》——1.2　为什么要开源
  • 8
    .Net函数Math.Round你会用吗？
  • 9
    麻省理工大学新发明：暗黑WiFi透视技术
  • 10
    2014秋C++第19周 补充代码 哈希法的存储与查找
  • 1
    R语言关联规则模型(Apriori算法)挖掘杂货店的交易数据与交互可视化
    25
  • 2
    R语言近似贝叶斯计算MCMC（ABC-MCMC）轨迹图和边缘图可视化
    21
  • 3
    r语言中对LASSO回归，Ridge岭回归和弹性网络Elastic Net模型实现-4
    31
  • 4
    Sentieon | 每周文献-Multi-omics-第四十一期
    26
  • 5
    数据分享|R语言广义线性模型GLM：线性最小二乘、对数变换、泊松、二项式逻辑回归分析冰淇淋销售时间序列数据和模拟-2
    17
  • 6
    数据分享|R语言广义线性模型GLM：线性最小二乘、对数变换、泊松、二项式逻辑回归分析冰淇淋销售时间序列数据和模拟-1
    23
  • 7
    基于RT-Thread摄像头车牌图像采集系统
    22
  • 8
    R语言极值理论：希尔HILL统计量尾部指数参数估计可视化
    17
  • 9
    【视频】R语言中的分布滞后非线性模型（DLNM）与发病率，死亡率和空气污染示例
    23
  • 10
    sql语句创建数据库
    19

    • 相关课程

    更多
  • Python 脚本入门
  • Python 脚本进阶
  • 【Python入门】Python数据处理编程基础
  • Python入门与实践
  • Python入门 2020年版
  • Python 科学计算库 NumPy 快速入门

    • 相关电子书

    更多
  • Python系列直播第一讲——Python中的一切皆对象
  • From Python Scikit-Learn to Sc
  • Python 脚本速查手册

    • 相关实验场景

    更多
  • 用Python画圣诞树
  • Python选择及循环结构
  • 云端Python及基本操作
  • Python新手入门（Anolis OS）
  • Python新手入门
  • Python入门
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）