线程 进程 协程

一.线程

#1.创建线程

import threading
def f1(args):
    print(args)

t = threading.Thread(target=f1,args =(123,))
t.start()

#2.自定义类创建线程

import threading
class MyThread(threading.Thread):
    def __init__(self,func,args):
        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)
obj.start()

#3.线程锁机制 线程锁（Lock、RLock）

由于线程之间是进行随机调度，并且每个线程可能只执行n条执行之后，当多个线程同时修改同一条数据时可能会出现脏数据，所以，出现了线程锁 - 同一时刻允许一个线程执行操作。

import threading
import time
NUM = 10
def func(l):
    global NUM
    l.acquire()
    NUM -=1
    time.sleep(2)
    print(NUM)
    l.release()
lock = threading.Lock()
#lock = threading.RLock()
#lock = threading.BoundedSemaphore(5) #放行5个
for i in range(10):
    t = threading.Thread(target=func,args=(lock,))
    t.start()

信号量（Semaphore）

互斥锁 同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据 ，比如厕所有3个坑，那最多只允许3个人上厕所，后面的人只能等里面有人出来了才能再进去。

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()#设置成绿灯

事件（event）

python线程的事件用于主线程控制其他线程的执行，事件主要提供了三个方法 set、wait、clear。

事件处理的机制：全局定义了一个“Flag”，如果“Flag”值为 False，那么当程序执行 event.wait 方法时就会阻塞，如果“Flag”值为True，那么event.wait 方法时便不再阻塞。

clear：将“Flag”设置为False set：将“Flag”设置为True

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
    c.acquire()
    c.notify(int(inp))
    c.release()
from threading import Timer


def hello():
    print("hello, world")

t = Timer(1, hello)
t.start()  # after 1 seconds, "hello, world" will be printed

二.队列

import queue

queue.Queue，先进先出队列

queue.LifoQueue，后进先出队列

queue.PriorityQueue，优先级队列

queue.deque，双向对队

queue.Queue(2) 先进先出队列

put放数据，是否阻塞，阻塞时的超时事件

get取数据（默认阻塞）,是否阻塞，阻塞时的超时事件

qsize()真实个数

maxsize 最大支持的个数

join,task_done，阻塞进程，当队列中任务执行完毕之后，不再阻塞

#1.先进先出队列

import queue

q = queue.Queue(5)

q.put(123)
q.put(232)
q.get()
q.task_done()
q.get()
q.task_done()
q.join()

#2.后进先出队列

import queue
q = queue.LifoQueue()
q.put(123)
q.put(456)
print(q.get())

#3.优先级队列

q = queue.PriorityQueue()   #根据优先级处理
q.put((1,"alex1"))
q.put((2,"alex2"))
q.put((3,"alex3"))
print(q.get())

#4.双向对队

q= queue.deque()          #双向队列
q.append((123))
q.append(234)
q.appendlef(456)
q.pop()
q.popleft()

三.生产者消费者模型

import queue
import threading
import time
q = queue.Queue()
def productor(arg):
    q.put(str(arg)+'包子')

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

def consumer(arg):
    while True:
        print(arg,q.get())
        time.sleep(2)

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

四.线程池

import queue
import threading
import time
class ThreadPool:
    def __init__(self,maxsize=5):
        self.maxsize = maxsize
        self._q = queue.Queue(maxsize)
        for i in range(maxsize):
            self._q.put(threading.Thread)
    def get_thread(self):
        return self._q.get()
    def add_thread(self):
        self._q.put(threading.Thread)
pool = ThreadPool(5)
def  task(arg,p):
    print(arg)
    time.sleep(1)
    p.add_thread()
for i in range(100):
    t = pool.get_thread()
    obj = t(target=task,args=(i,pool,))
    obj.start()

Python操作 RabbitMQ、Redis、Memcache、SQLAlchemy

Memcached Memcached 是一个高性能的分布式内存对象缓存系统，用于动态Web应用以减轻数据库负载。它通过在内存中缓存数据和对象来减少读取数据库的次数，从而提高动态、数据库驱动网站的速度。Memcached基于一个存储键/值对的hashmap。其守护进程（daemon ）是用C写的，但是客户端可以用任何语言来编写，并通过memcached协议与守护进程通信。

Memcached安装和基本使用

Memcached安装：

wget http://memcached.org/latest
tar -zxvf memcached-1.x.x.tar.gz
cd memcached-1.x.x
./configure && make && make test && sudo make install
 
PS：依赖libevent
       yum install libevent-devel
       apt-get install libevent-dev

启动Memcached

memcached -d -m 10    -u root -l 10.211.55.4 -p 12000 -c 256 -P /tmp/memcached.pid
 
参数说明:
    -d 是启动一个守护进程
    -m 是分配给Memcache使用的内存数量，单位是MB
    -u 是运行Memcache的用户
    -l 是监听的服务器IP地址
    -p 是设置Memcache监听的端口,最好是1024以上的端口
    -c 选项是最大运行的并发连接数，默认是1024，按照你服务器的负载量来设定
    -P 是设置保存Memcache的pid文件

Memcached命令

存储命令: set/add/replace/append/prepend/cas
获取命令: get/gets
其他命令: delete/stats..

Python操作Memcached

安装API

python操作Memcached使用Python-memcached模块
下载安装：https://pypi.python.org/pypi/python-memcached

1、第一次操作

import memcache
 
mc = memcache.Client(['10.211.55.4:12000'], debug=True)
mc.set("foo", "bar")
ret = mc.get('foo')
print ret

如果用户根据如果要在内存中创建一个键值对（如：k1 = "v1"），那么要执行一下步骤：

根据算法将 k1 转换成一个数字 将数字和主机列表长度求余数，得到一个值 N（ 0 <= N < 列表长度 ） 在主机列表中根据 第2步得到的值为索引获取主机，例如：host_list[N] 连接 将第3步中获取的主机，将 k1 = "v1" 放置在该服务器的内存中

mc = memcache.Client([('1.1.1.1:12000', 1), ('1.1.1.2:12000', 2), ('1.1.1.3:12000', 1)], debug=True)
 
mc.set('k1', 'v1')

Ps：debug = True 表示运行出现错误时，现实错误信息，上线后移除该参数

转载于:https://my.oschina.net/u/2551551/blog/713186