python 网络编程基础 day11

　　　　概述：

　　　　　　　　1、线程

　　　　　　　　2、进程

　　　　　　　　3、协程

　　　　　　　　4、缓存

线程

基本使用

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

t = threading.Thread(target=f1, args=(123,))
t.start() #等待cpu调度

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()

自定义线程类

队列

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

后进先出队列

import queue

q = queue.PriorityQueue()
q.put((1,"alex1"))
q.put((1,"alex2"))
q.put((1,"alex3"))
q.put((3,"alex3"))
print(q.get())       #(1, 'alex1')

优先级队列

import queue
q = queue.deque()
q.append(123)
q.append(333)
q.appendleft(456)
print(q)
q.pop() #清除第最后一个元素
q.popleft() #清除最左边的元素
print(q)

#输出
deque([456, 123, 333])
deque([123])

双向对队列

# queue.Queue(2) 先进先出队列
# put放数据，是否阻塞，阻塞时的超时时间
# get取数据（默认阻塞）,是否阻塞，阻塞时的超时时间
# qsize()真实个数
# maxsize 最大支持的个数
# join,task_done，阻塞进程，当队列中任务执行完毕之后，不再阻塞

import queue

q = queue.Queue(2) #最大排队数
print(q.empty())
q.put(11)
q.put(22)
print(q.empty())
print(q.qsize()) #返回队列的大小
#q.put(33, block=False) #是否阻塞
#q.put(33,block=True, timeout=2)
print(q.get())
print(q.get(timeout=2))

#q.task_done()
#q.join()

先进先出队列

queue模块
import queue
myqueue = queue.Queue(maxsize = 10)

queue.Queue类即是一个队列的同步实现。队列长度可为无限或者有限。可通过queue的构造函数的可选参数maxsize来设定队列长度。如果maxsize小于1就表示队列长度无限。

将一个值放入队列中
myqueue.put(10)

调用队列对象的put()方法在队尾插入一个项目。put()有两个参数，第一个item为必需的，为插入项目的值；第二个block为可选参数，默认为 1。如果队列当前为空且block为1，put()方法就使调用线程暂停,直到空出一个数据单元。如果block为0，put方法将引发Full异常。

将一个值从队列中取出
myqueue.get()


调用队列对象的get()方法从队头删除并返回一个项目。可选参数为block，默认为True。如果队列为空且block为True，get()就使调用线程暂停，直至有项目可用。如果队列为空且block为False，队列将引发Empty异常。

python queue模块有三种队列:
1、python queue模块的FIFO队列先进先出。
2、LIFO类似于堆。即先进后出。
3、还有一种是优先级队列级别越低越先出来。

针对这三种队列分别有三个构造函数:
1、class queue.Queue(maxsize) FIFO 
2、class queue.LifoQueue(maxsize) LIFO 
3、class queue.PriorityQueue(maxsize) 优先级队列

介绍一下此包中的常用方法:

queue.qsize() 返回队列的大小 
queue.empty() 如果队列为空，返回True,反之False 
queue.full() 如果队列满了，返回True,反之False
queue.full 与 maxsize 大小对应 
queue.get([block[, timeout]]) 获取队列，timeout等待时间 
queue.get_nowait() 相当queue.get(False)
非阻塞 queue.put(item) 写入队列，timeout等待时间 
queue.put_nowait(item) 相当queue.put(item, False)
queue.task_done() 在完成一项工作之后，queue.task_done() 函数向任务已经完成的队列发送一个信号
queue.join() 实际上意味着等到队列为空，再执行别的操作

queue一些方法

关于join

join 逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义

关于join的方法有问题.如果用的不得当会变成线程的顺序执行; 合理使用时, 是让线程顺序的退出.比如:

from threading import Thread
import time
def f(i):
    print(i)
    time.sleep(1)

def main1():
    print("Main1 start run")
for i in range(3):
    t = Thread(target=f, args=(i,))
    t.start()
    t.join()
print("Main1 END run")

def main2():
    print( "Main2 start run")
threads = []
for i in range(3):
    t = Thread(target=f, args=(i,))
    threads.append(t)
    t.start()

for i in threads:
    i.join()

print("Main2 END run")
#main1是阻塞后顺序执行，main2是退出时阻塞顺序退出。

生产者和消费者模型

拿火车票举例：一次可发放300张火车票，但是有三个窗口可以同时取票。

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 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()

#输出
0 0- 火车票
1 1- 火车票
2 2- 火车票
1 3- 火车票
0 4- 火车票
2 5- 火车票
1 6- 火车票
0 7- 火车票
2 8- 火车票
1 9- 火车票
......

线程锁（lock,rlock）

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

import threading
import time

gl_num = 0

def show():
    global gl_num
    time.sleep(1)
    gl_num +=1
    print gl_num

for i in range(10):
    t = threading.Thread(target=show,)
    t.start()

print('main thread stop')

未使用锁

import threading
import time
NUM = 10

def func(i,l):
    global NUM
    # 上锁
    l.acquire() #acquire可选参数timeout。设了timeout，在超时后通过返回值判断是否得到了锁，从而可以进行一些其他处理。 30,5 25m5,20
    NUM -= 1
    time.sleep(2)
    print(NUM,i)
    l.release() # 开锁

# lock = threading.Lock()
#创建锁
lock = threading.RLock()
for i in range(30):
    t = threading.Thread(target=func,args=(i,lock,))
    t.start()

上锁

Lock与Rlock的区别

import threading  
lock = threading.Lock() #Lock对象  
lock.acquire()  
lock.acquire()  #产生了死琐。  
lock.release()  
lock.release()  

import threading  
rLock = threading.RLock()  #RLock对象  
rLock.acquire()  
rLock.acquire() #在同一线程内，程序不会堵塞。  
rLock.release()  
rLock.release()

　　RLock允许在同一线程中被多次acquire。而Lock却不允许这种情况。注意：如果使用RLock，那么acquire和release必须成对出现，即调用了n次acquire，必须调用n次的release才能真正释放所占用的琐。threading.Condition
　　可以把Condiftion理解为一把高级的琐，它提供了比Lock, RLock更高级的功能，允许我们能够控制复杂的线程同步问题。threadiong.Condition在内部维护一个琐对象（默认是RLock），可以在创建Condigtion对象的时候把琐对象作为参数传入。Condition也提供了acquire, release方法，其含义与琐的acquire, release方法一致，其实它只是简单的调用内部琐对象的对应的方法而已。

信号量（Semaphore）

互斥锁同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据

import threading
import time
NUM = 10

def func(i,l):
    global NUM
    # 上锁
    l.acquire() 
    NUM -= 1
    time.sleep(2)
    print(NUM,i)
    l.release() # 开锁
lock = threading.BoundedSemaphore(5)#最多允许5个线程同时运行

for i in range(30):
    t = threading.Thread(target=func,args=(i,lock,))
    t.start()
#会5个5个的输出

事件（event）　　

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

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

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

条件（Condition）

使得线程等待，只有满足某条件时，才释放n个线程

import threading
def func(i,con):
    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()

#输出
>>>3
>>>100
101
102
2
>>>103
104

import threading

def condition():
    ret = False
    r = input('>>>')
    if r == 'true':
        ret = True
    else:
        ret = False
    return ret


def func(i,con):
    con.acquire()
    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秒后执行某操作

from threading import Timer

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

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

线程池的作用：

线程池是为突然大量爆发的线程设计的，通过有限的几个固定线程为大量的操作服务，减少了创建和销毁线程所需的时间，从而提高效率。

如果一个线程的时间非常长，就没必要用线程池了(不是不能作长时间操作，而是不宜。)，况且我们还不能控制线程池中线程的开始、挂起、和中止。

什么时候使用ThreadPool？　　

ThreadPool中的线程不用手动开始，也不能手动取消，你要做的只是把工作函数排入线程池，剩下的工作将由系统自动完成，也就是说我们不能控制线程池中的线程。如果想对线程进行更多的控制，那么就不合适使用线程池。在一下情况中不宜使用ThreadPool类而应该使用单独的Thread类：

1、线程执行需要很长时间。

2、需要为线程指定详细的优先级。

3、在执行过程中需要对线程进行操作，比如睡眠，挂起等。

所以ThreadPool适合于并发运行若干个运行时间不长且互不干扰的函数。

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) #往队列里放线程
        # 【threading.Thread，threading.Thread，threading.Thread，threading.Thread，threading.Thread】
    def get_thread(self):
        return self._q.get() #取值

    def add_thread(self):
        self._q.put(threading.Thread) #增加线程到队列

pool = ThreadPool(5)# 线程池里只能放5个

def task(arg,p):
    """p=pool=ThreadPool(5)"""
    print(arg)
    time.sleep(1)
    p.add_thread() #调用方法添加线程到队列

for i in range(100):
    # threading.Thread类
    t = pool.get_thread() #取值(线程类)
    obj = t(target=task,args=(i,pool,)) #定义一个线程对象
    obj.start() #执行

简易版线程池

import queue
import threading
import contextlib
import time

StopEvent = object() #可以设置为空，是为了终止进程

class ThreadPool():

    def __init__(self, max_num, max_task_num = None):
        if max_task_num:     #如果max_task_num有值就创建队列
            self.q = queue.Queue(max_task_num)  #创建队列，最多放max_task_num个任务
        else:     #若max_task_num无值，则不定义最大长度
            self.q = queue.Queue() #创建先进先出队列
        self.max_num = max_num   #表示最多有多少个线程
        self.cancel = False
        self.terminal = False
        self.generate_list = []  #表示当前已经创建多少个线程
        self.free_list = []      #当前还空闲多少个线程

    def run(self, func, args, callback=None):
        """
        线程池执行一个任务
        :param func: 任务函数
        :param args: 任务函数所需参数
        :param callback: 任务执行失败或成功后执行的回调函数，回调函数有两个参数1、任务函数执行状态；2、任务函数返回值（默认为None，即：不执行回调函数）
        :return: 如果线程池已经终止，则返回True否则None
        """
        if self.cancel:
            return
        # 判断 没有空闲线程并且已经创建的线程小于最大线程数
        if len(self.free_list) == 0 and len(self.generate_list) < self.max_num: 
            self.generate_thread() #调用创建线程的方法
        w = (func, args, callback,) #把传过来的三个参数放到一个元组里
        self.q.put(w)   #把任务放到队列中

    def generate_thread(self):
        """
        创建一个线程
        """
        t = threading.Thread(target=self.call)#创建的线程执行call方法
        t.start() #执行

    def call(self):
        """
        循环去获取任务函数并执行任务函数
        """
        current_thread = threading.currentThread  #返回当前线程对象
        self.generate_list.append(current_thread) #把当前创建的线程放到列表里

        event = self.q.get()       #获取队列中的任务
        while event != StopEvent: #任务不等于后面的值就会一直循环

            func, arguments, callback = event
    
            try:  #捕捉异常
                result = func(*arguments)  #执行action函数
                success = True
            except Exception as e:
                success = False
                result = None

            if callback is not None:
                try:  #捕捉异常
                    callback(success, result)
                except Exception as e:
                    pass
            #使线程变为空闲，以便下次再取任务
            with self.worker_state(self.free_list, current_thread):
                if self.terminal:
                    event = StopEvent
                else:
                    event = self.q.get()
        else:

            self.generate_list.remove(current_thread) #移除当前线程 终止线程

    def close(self):
        """
        执行完所有的任务后，所有线程停止
        """
        self.cancel = True
        full_size = len(self.generate_list) #获取创建的线程个数
        while full_size:
            self.q.put(StopEvent)  #往队列里放入空值，空值的个数和创建线程的个数相等
            full_size -= 1

    def terminate(self):
        """
        无论是否还有任务，终止线程
        """
        self.terminal = True

        while self.generate_list: #若列表还有创建的线程
            self.q.put(StopEvent) #把空值放入队列中

        self.q.empty() #队列为空返回True，否则返回False

    @contextlib.contextmanager
    def worker_state(self, state_list, worker_thread):
        """
        用于记录线程中正在等待的线程数
        """
        state_list.append(worker_thread)
        try:
            yield
        finally:
            state_list.remove(worker_thread)


pool = ThreadPool(5) #线程池里只能放5个

def callback(status, result):
    # status, execute action status
    # result, execute action return value
    pass

def action(i):
    print(i)

for i in range(300):
    ret = pool.run(action, (i,), callback) #执行run方法，参数（函数，i,函数名）

# time.sleep(5)
# print(len(pool.generate_list), len(pool.free_list))
# print(len(pool.generate_list), len(pool.free_list))

复杂版线程池

python进程

默认数据不共享

from multiprocessing import Process


def foo(i):
    print('say hi', i)

if __name__ == '__main__':
    for i in range(10):
        p = Process(target=foo, args=(i,))
        p.start()

　注意：由于进程之间的数据需要各自持有一份，所以创建进程需要的非常大的开销。　

进程数据共享

from multiprocessing import Process

li = []

def foo(i):
    li.append(i)
    print('say hi', li)

if __name__ == '__main__':
    for i in range(5):
        p = Process(target=foo, args=(i,))
        p.start()
        p.join()
    print('ending', li)
#输出
say hi [0]
say hi [1]
say hi [2]
say hi [3]
say hi [4]
ending []  #最后列表是空，说明数据不能共享

默认进程间不能共享数据

queues方式共享数据

#Array方式，共享数据
from multiprocessing import Process
from multiprocessing import Array

def foo(i,arg):
    arg[i] = i + 100
    for item in arg:
        print(item)
    print('================')

if __name__ == "__main__":
    li = Array('i', 10) #数组，必须定义类型和个数
    for i in range(10):
        p = Process(target=foo,args=(i,li,))
        p.start()

#manage.dict()方式，共享数据

from multiprocessing import Process
from multiprocessing import Manager

def foo(i,arg):
    arg[i] = i + 100
    print(arg.values())

if __name__ == "__main__":
    obj = Manager()
    li = obj.dict()
    for i in range(10):
        p = Process(target=foo,args=(i,li,))
        p.start()
        p.join() # 方式二
    # 方式一
    # import time
    # time.sleep(10) #停10s表示主进程还没执行完，连接没断子进程可以连接到主进程
#如果不加p.join或方式一，会报错，因为主进程创建了obj.dict而子进程修改主进程的obj.dict，
# 进程和进程之间想要通信是需要创建连接的。

进程锁

#未使用锁，多个进程操作共同的数据，最终得到统一的结果
from multiprocessing import Process
from multiprocessing import queues
from multiprocessing import Array
from multiprocessing import RLock, Lock, Event, Condition, Semaphore
import multiprocessing
import time

def foo(i,lis):
    lis[0] = lis[0] - 1
    time.sleep(1)

    print('say hi',lis[0])

if __name__ == "__main__":
    li = Array('i', 1)
    li[0] = 10
    for i in range(10):
        p = Process(target=foo,args=(i,li))
        p.start()


#上锁，同一时刻只能一个进程操作。
from multiprocessing import Process
from multiprocessing import Array
from multiprocessing import RLock, Lock, Event, Condition, Semaphore
import time

def foo(i,lis,lc):
    lc.acquire()
    lis[0] = lis[0] - 1
    time.sleep(1)
    print('say hi',lis[0])
    lc.release()

if __name__ == "__main__":

    li = Array('i', 1)
    li[0] = 10
    lock = RLock()
    for i in range(10):
        p = Process(target=foo,args=(i,li,lock))
        p.start()

进程池

进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进程，那么程序就会等待，直到进程池中有可用进程为止

进程池中有两个方法：

apply
apply_async

from multiprocessing import Pool
import time
def f1(arg):
    print(arg,'b')
    time.sleep(2)
    print(arg,'a')
if __name__ == "__main__":
    pool = Pool(5) #创建进程池，最多可以放5个

    for i in range(30):
        # pool.apply(func=f1,args=(i,)) #去进程池取进程串行执行
        pool.apply_async(func=f1,args=(i,)) #拿到一个进程，并行执行

    pool.close() # 所有的任务执行完毕再结束
    # time.sleep(2)
    # pool.terminate() # 立即终止
    pool.join()

协程　　

原理：利用一个线程，分解一个线程为多个“微线程”。（程序级别，跟系统没关系）

线程和进程的操作是由程序触发系统接口，最后的执行者是系统；协程的操作则是程序员。

协程存在的意义：对于多线程应用，CPU通过切片的方式来切换线程间的执行，线程切换时需要耗时（保存状态，下次继续）。协程，则只使用一个线程，在一个线程中规定某个代码块执行顺序。

协程的适用场景：当程序中存在大量不需要CPU的操作时（IO），适用于协程；

#pip3 install gevent 
from greenlet import greenlet

def test1():
    print(12)
    gr2.switch()
    print(34)
    gr2.switch()


def test2():
    print(56)
    gr1.switch()
    print(78)

gr1 = greenlet(test1)
gr2 = greenlet(test2)
gr1.switch()
#输出
12
56
34
78

gevent

遇到IO操作自动切换：

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 received from %s.' % (len(data), url))

gevent.joinall([
        gevent.spawn(f, 'https://www.python.org/'),
        gevent.spawn(f, 'https://www.yahoo.com/'),
        gevent.spawn(f, 'https://github.com/'),
])

#输出谁先返回执行谁
GET: https://www.python.org/
GET: https://www.yahoo.com/
GET: https://github.com/
47394 bytes received from https://www.python.org/.
25529 bytes received from https://github.com/.
445667 bytes received from https://www.yahoo.com/.

缓存

1、服务器安装软件

2、程序安装对应的模块

本质是socket连接

memcache(支持的数据类型)

　　k-->"字符串"

redis　

　　k-->""

　　k-->[]

　　k-->{}

　　k-->[(),(),]

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文件

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

2、天生支持集群

python-memcached模块原生支持集群操作，其原理是在内存维护一个主机列表，且集群中主机的权重值和主机在列表中重复出现的次数成正比

 主机    权重
    1.1.1.1   1
    1.1.1.2   2
    1.1.1.3   1
 
那么在内存中主机列表为：
    host_list = ["1.1.1.1", "1.1.1.2", "1.1.1.2", "1.1.1.3", ]

如果用户根据如果要在内存中创建一个键值对（如：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')

3、add
添加一条键值对，如果已经存在的 key，重复执行add操作异常　

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import memcache
 
mc = memcache.Client(['10.211.55.4:12000'], debug=True)
mc.add('k1', 'v1')
# mc.add('k1', 'v2') # 报错，对已经存在的key重复添加，失败！！！

4、replace
replace 修改某个key的值，如果key不存在，则异常

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import memcache
 
mc = memcache.Client(['10.211.55.4:12000'], debug=True)
# 如果memcache中存在kkkk，则替换成功，否则一场
mc.replace('kkkk','999')

5、set 和 set_multi

set 设置一个键值对，如果key不存在，则创建，如果key存在，则修改
set_multi 设置多个键值对，如果key不存在，则创建，如果key存在，则修改

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import memcache
 
mc = memcache.Client(['10.211.55.4:12000'], debug=True)
 
mc.set('key0', 'wupeiqi')
 
mc.set_multi({'key1': 'val1', 'key2': 'val2'})

6、delete 和 delete_multi

delete 在Memcached中删除指定的一个键值对
delete_multi 在Memcached中删除指定的多个键值对

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import memcache
 
mc = memcache.Client(['10.211.55.4:12000'], debug=True)
 
mc.delete('key0')
mc.delete_multi(['key1', 'key2'])

7、get 和 get_multi

get 获取一个键值对
get_multi 获取多一个键值对

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import memcache
 
mc = memcache.Client(['10.211.55.4:12000'], debug=True)
 
val = mc.get('key0')
item_dict = mc.get_multi(["key1", "key2", "key3"])

8、append 和 prepend

append 修改指定key的值，在该值后面追加内容
prepend 修改指定key的值，在该值前面插入内容

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import memcache
 
mc = memcache.Client(['10.211.55.4:12000'], debug=True)
# k1 = "v1"
 
mc.append('k1', 'after')
# k1 = "v1after"
 
mc.prepend('k1', 'before')
# k1 = "beforev1after"

9、decr 和 incr　　

incr 自增，将Memcached中的某一个值增加 N （ N默认为1 ）
decr 自减，将Memcached中的某一个值减少 N （ N默认为1 ）

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import memcache
 
mc = memcache.Client(['10.211.55.4:12000'], debug=True)
mc.set('k1', '777')
 
mc.incr('k1')
# k1 = 778
 
mc.incr('k1', 10)
# k1 = 788
 
mc.decr('k1')
# k1 = 787
 
mc.decr('k1', 10)
# k1 = 777

10、gets 和 cas

如商城商品剩余个数，假设改值保存在memcache中，product_count = 900
A用户刷新页面从memcache中读取到product_count = 900
B用户刷新页面从memcache中读取到product_count = 900

如果A、B用户均购买商品

A用户修改商品剩余个数 product_count＝899
B用户修改商品剩余个数 product_count＝899

如此一来缓存内的数据便不在正确，两个用户购买商品后，商品剩余还是 899
如果使用python的set和get来操作以上过程，那么程序就会如上述所示情况！

如果想要避免此情况的发生，只要使用 gets 和 cas 即可，如：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import memcache
mc = memcache.Client(['10.211.55.4:12000'], debug=True, cache_cas=True)
 
v = mc.gets('product_count')
# ...
# 如果有人在gets之后和cas之前修改了product_count，那么，下面的设置将会执行失败，剖出异常，从而避免非正常数据的产生
mc.cas('product_count', "899")

Ps：本质上每次执行gets时，会从memcache中获取一个自增的数字，通过cas去修改gets的值时，会携带之前获取的自增值和memcache中的自增值进行比较，如果相等，则可以提交，如果不想等，那表示在gets和cas执行之间，又有其他人执行了gets（获取了缓冲的指定值），如此一来有可能出现非正常数据，则不允许修改。

Redis

redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

Redis安装和基本使用　　

wget http://download.redis.io/releases/redis-3.0.6.tar.gz
tar xzf redis-3.0.6.tar.gz
cd redis-3.0.6
make

启动服务端　　

src/redis-server

启动客户端　　

src/redis-cli
redis> set foo bar
OK
redis> get foo
"bar"

Python操作Redis　　

sudo pip install redis
or
sudo easy_install redis
or
源码安装
 
详见：https://github.com/WoLpH/redis-py

API使用

redis-py 的API的使用可以分类为：

连接方式
连接池
操作
- String 操作
- Hash 操作
- List 操作
- Set 操作
- Sort Set 操作
管道
发布订阅

1、操作模式

redis-py提供两个类Redis和StrictRedis用于实现Redis的命令，StrictRedis用于实现大部分官方的命令，并使用官方的语法和命令，Redis是StrictRedis的子类，用于向后兼容旧版本的redis-py。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
 
import redis
 
r = redis.Redis(host='10.211.55.4', port=6379)
r.set('foo', 'Bar')
print r.get('foo')

2、连接池

redis-py使用connection pool来管理对一个redis server的所有连接，避免每次建立、释放连接的开销。默认，每个Redis实例都会维护一个自己的连接池。可以直接建立一个连接池，然后作为参数Redis，这样就可以实现多个Redis实例共享一个连接池。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
 
import redis
 
pool = redis.ConnectionPool(host='10.211.55.4', port=6379)
 
r = redis.Redis(connection_pool=pool)
r.set('foo', 'Bar')
print r.get('foo')

3、操作

String操作，redis中的String在在内存中按照一个name对应一个value来存储。如

name value

n1 -------> v1

n2 -------> v2

n3 -------> v3

set(name, value, ex=None, px=None, nx=False, xx=False)

在Redis中设置值，默认，不存在则创建，存在则修改
参数：
     ex，过期时间（秒）
     px，过期时间（毫秒）
     nx，如果设置为True，则只有name不存在时，当前set操作才执行
     xx，如果设置为True，则只有name存在时，岗前set操作才执行

setnx(name, value)　　

设置值，只有name不存在时，执行设置操作（添加）

setex(name, value, time)　　

# 设置值
# 参数：
    # time，过期时间（数字秒 或 timedelta对象）

psetex(name, time_ms, value)　　

# 设置值
# 参数：
    # time_ms，过期时间（数字毫秒 或 timedelta对象）

mset(*args, **kwargs)　　

批量设置值
如：
    mset(k1='v1', k2='v2')
    或
    mget({'k1': 'v1', 'k2': 'v2'})

get(name)

获取值　　

mget(keys, *args)

批量获取
如：
    mget('ylr', 'wupeiqi')
    或
    r.mget(['ylr', 'wupeiqi'])

getset(name, value)　　

设置新值并获取原来的值

getrange(key, start, end)　　

# 获取子序列（根据字节获取，非字符）
# 参数：
    # name，Redis 的 name
    # start，起始位置（字节）
    # end，结束位置（字节）
# 如： "武沛齐" ，0-3表示 "武"

setrange(name, offset, value)　　

# 修改字符串内容，从指定字符串索引开始向后替换（新值太长时，则向后添加）
# 参数：
    # offset，字符串的索引，字节（一个汉字三个字节）
    # value，要设置的值

setbit(name, offset, value)　　

# 对name对应值的二进制表示的位进行操作
 
# 参数：
    # name，redis的name
    # offset，位的索引（将值变换成二进制后再进行索引）
    # value，值只能是 1 或 0
 
# 注：如果在Redis中有一个对应： n1 = "foo"，
        那么字符串foo的二进制表示为：01100110 01101111 01101111
    所以，如果执行 setbit('n1', 7, 1)，则就会将第7位设置为1，
        那么最终二进制则变成 01100111 01101111 01101111，即："goo"
 
# 扩展，转换二进制表示：
 
    # source = "武沛齐"
    source = "foo"
 
    for i in source:
        num = ord(i)
        print bin(num).replace('b','')
 
    特别的，如果source是汉字 "武沛齐"怎么办？
    答：对于utf-8，每一个汉字占 3 个字节，那么 "武沛齐" 则有 9个字节
       对于汉字，for循环时候会按照 字节 迭代，那么在迭代时，将每一个字节转换 十进制数，然后再将十进制数转换成二进制
        11100110 10101101 10100110 11100110 10110010 10011011 11101001 10111101 10010000
        -------------------------- ----------------------------- -----------------------------
                    武                         沛                           齐

getbit(name, offset)　

# 获取name对应的值的二进制表示中的某位的值 （0或1）

bitcount(key, start=None, end=None)　　

# 获取name对应的值的二进制表示中 1 的个数
# 参数：
    # key，Redis的name
    # start，位起始位置
    # end，位结束位置

bitop(operation, dest, *keys)　　

# 获取多个值，并将值做位运算，将最后的结果保存至新的name对应的值
 
# 参数：
    # operation,AND（并） 、 OR（或） 、 NOT（非） 、 XOR（异或）
    # dest, 新的Redis的name
    # *keys,要查找的Redis的name
 
# 如：
    bitop("AND", 'new_name', 'n1', 'n2', 'n3')
    # 获取Redis中n1,n2,n3对应的值，然后讲所有的值做位运算（求并集），然后将结果保存 new_name 对应的值中

strlen(name)　　

# 返回name对应值的字节长度（一个汉字3个字节）

incr(self, name, amount=1)　　

# 自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
 
# 参数：
    # name,Redis的name
    # amount,自增数（必须是整数）
# 注：同incrby

incrbyfloat(self, name, amount=1.0)　

# 自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
 
# 参数：
    # name,Redis的name
    # amount,自增数（浮点型）

decr(self, name, amount=1)

# 自减 name对应的值，当name不存在时，则创建name＝amount，否则，则自减。
 
# 参数：
    # name,Redis的name
    # amount,自减数（整数）

append(key, value)　　

# 在redis name对应的值后面追加内容
 
# 参数：
    key, redis的name
    value, 要追加的字符串

Hash操作，redis中Hash在内存中的存储格式如下图：

name hash

　　　　　　k1--->v1

n1————>k2--->v2

　　　　　 k3--->v3

　　　　　　k9--->v99

n2————>kx--->vx

hset(name, key, value)　

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

posted on 2016-07-19 17:33 QinLing 阅读(222) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部