python第十一天

先写博客，复习学习到的知识点后再写作业，这次作业也比较简单哈，这几周的课程不是没有作业就是作业很简单，北方表示很喜欢，学习进度一下子就上去了，Python持续学习中，运维方面下一阶段转战docker~~~openstack的各个组件已经完全理解，网络模式理解到了80%左右，ceph进度较慢，仅仅理解了估计不到40%，马上10.1了放假再补上吧，也祝大家国庆节快乐，北方一直以为国庆只放假3天的，没想到是7天

10.1学习计划如下：学习openstack剩余知识点，python进度进展到最少第13天，把docker技术入门及实践书籍看完，离10.1结束还有11天，加油

 

线程：用于IO密集形

进程：用于CPU密集形

协程：用于IO密集形

 

1.线程创建有2种方式，一种自己创建类实现顶掉python自带的创建线程的类去实现，一种使用python自带的创建线程的类。使用的话当然使用人家直接提供的了

import threading

 

2.队列，先进先出，也有先进后出的，这个特性不就是栈么....还有两头都可以出线程的类是threading的，wtf，什么鬼，反正标准的就是先进先出就是

#!/usr/bin/env python
import queue
q = queue.Queue(2)
print(q.empty())            #验证队列是否为空，返回True或者False
q.put(1)                    #向对列中放置一个消息，可以是任何类型
q.put(2)                    #在放一个
print(q.qsize())            #检测当前队列中任务的个数
print(q.get())              #获取一个任务，遵循先进先出的规律，因此出来的是1
print(q.empty())
q.put(3, block=True, timeout=2)     #当队列中的任务已经到达队列可容纳上限后之后的任务就会等待
                                    # 可以设置超时时间，或者选择不等待他
print(q.qsize())

C:\Users\Administrator\AppData\Local\Programs\Python\Python35\python.exe C:/Users/Administrator/PycharmProjects/ACE/study11/s2.py
True
2
1
False
2

Process finished with exit code 0

生产者消费者模型，只要是解决高并发请求的，也就是我们架构中部署的消息队列服务器，例如rabbitmq,zeromq等等，消息队列服务器的好处有很多了，最主要的功能就是消峰跟解耦，这个知识点在开发这里就不对介绍了

#!/usr/bin/env python
import queue
import threading
import time
q = queue.Queue()


def productor(arg):
    q.put(str(arg) + '--食物')

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


def cousumer(arg):
    while True:
        print(arg, q.get())
        time.sleep(0.1)

for j in range(3):
    t = threading.Thread(target=cousumer, args=(j, ))
    t.start()

线程同时对数据进行操作，那么就会产生脏数据，脏数据是什么鬼，好比买衣服仅剩一件了，但是有10个人同时买了，这时候库存变为了-9，这明显不合理，这就产生了脏数据，因此我们需要加一把锁给线程，线程锁有以下几种：互斥锁，信号量，事件，定时器，条件

#!/usr/bin/env python
import threading
import time

NUM = 10


def func(lock):
    global NUM
    lock.acquire()          #上锁，acquire()固定写法
    NUM -= 1
    time.sleep(1)
    print(NUM)
    lock.release()          #开锁，release()固定写法

# lock = threading.BoundedSemaphore(5)      #信号量，可每次释放指定个数的线程
lock = threading.RLock()                    #互斥锁，每次只会释放一个线程，可复用，包含了threading.Lock()功能
lock = threading.Lock()                     #互斥锁，每次只会释放一个线程，不可复用，一般不用
for i in range(30):
    t = threading.Thread(target=func, args=(lock,))
    t.start()

#!/usr/bin/env python
from threading import Timer         #定时器，线程相关的都在threading类内


def hello():
    print('hello world')

t = Timer(1, hello)                 #1秒后执行hello函数
t.start()

#!/usr/bin/env python
import threading


def func(i, con):
    print(i)
    con.acquire()
    con.wait()
    print(i + 100)
    con.release()

c = threading.Condition()       #条件
for i in range(10):
    t = threading.Thread(target=func, args=(i, c,))
    t.start()

while True:
    inp = input('>>>')
    if inp == 'q':
        break
    else:
        c.acquire()             #固定写法
        c.notify(int(inp))      #每次放行几个线程
        c.release()             #固定写法

#!/usr/bin/env python
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()                   #线程禁止通行，默认状态
inp = input('>>>')
if inp == '1':
    event.set()                 #线程放行

C:\Users\Administrator\AppData\Local\Programs\Python\Python35\python.exe C:/Users/Administrator/PycharmProjects/ACE/study11/s5.py
0
1
2
3
4
5
6
7
8
9
>>>1
100
103
104
107
108
101
105
109
102
106

Process finished with exit code 0

 进程相关：与线程所具有的功能类似，所有功能都在multiprocessing类内，类内直接提供了进程池（线程池线程类未提供，需要自己定义）

#!/usr/bin/env python
from multiprocessing import Pool            #进程池
import time


def f1(arg):
    time.sleep(1)
    print(arg)

if __name__ == '__main__':
    pool = Pool(5)                          #存放指定个数的进程
    for i in range(30):
        # pool.apply(func=f1, args=(i,))      #每次只释放一个进程
        pool.apply_async(func=f1, args=(i,))       #多个进程同时启用
    time.sleep(2)
    pool.terminate()                        #立即终止
    # pool.close()                          #等所有任务结束后执行
    pool.join()                             

协程相关：首先要下载gevent模块，在cmd中执行pip install gevent即可，这是一条线程持续执行的过程，效率较高，遇到IO会自动切换

#!/usr/bin/env python
from gevent import monkey; monkey.patch_all()
import gevent
import requests


def f(url):
    print('get %s' % url)
    resp = requests.get(url)
    data = resp.text
    print('%d bytes from %s' % (len(data), url))

gevent.joinall([
    gevent.spawn(f, 'http://www.baidu.com'),
    gevent.spawn(f, 'http://www.163.com'),
    gevent.spawn(f, 'http://www.xy2.com'),
])

C:\Users\Administrator\AppData\Local\Programs\Python\Python35\python.exe C:/Users/Administrator/PycharmProjects/ACE/study11/s11.py
get http://www.baidu.com
get http://www.163.com
get http://www.xy2.com
2381 bytes from http://www.baidu.com
95564 bytes from http://www.xy2.com
721371 bytes from http://www.163.com

Process finished with exit code 0