python第二十二次课 2018.05.22

python线程

threading多线程

threading用于提供线程相关的操作，线程是应用程序中工作的最小单元。python当前版本的多线程库没有实现优先级、线程组，线程也不能被停止、暂停、恢复、中断。


threading模块提供的类：  
　　Thread, Lock, Rlock, Condition, [Bounded]Semaphore, Event, Timer, local。


threading 模块提供的常用方法： 
　　threading.currentThread(): 返回当前的线程变量。 
　　threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。 
　　threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。


threading 模块提供的常量：

　　threading.TIMEOUT_MAX 设置threading全局超时时间。

构造方法： 
Thread(group=None, target=None, name=None, args=(), kwargs={}) 


　　group: 线程组，目前还没有实现，库引用中提示必须是None； 
　　target: 要执行的方法； 
　　name: 线程名； 
　　args/kwargs: 要传入方法的参数。


实例方法： 
　　isAlive(): 返回线程是否在运行。正在运行指启动后、终止前。 
　　get/setName(name): 获取/设置线程名。 


　　start():  线程准备就绪，等待CPU调度
　　is/setDaemon(bool): 获取/设置是后台线程（默认前台线程（False））。（在start之前设置）


　　　　如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，主线程和后台线程均停止
       　　如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止
　　start(): 启动线程。 

　　join([timeout]): 阻塞当前上下文环境的线程，直到调用此方法的线程终止或到达指定的timeout（可选参数）。

Lock、Rlock类
 


　　由于线程之间随机调度：某线程可能在执行n条后，CPU接着执行其他线程。为了多个线程同时操作一个内存中的资源时不产生混乱，我们使用锁。


Lock（指令锁）是可用的最低级的同步指令。Lock处于锁定状态时，不被特定的线程拥有。Lock包含两种状态——锁定和非锁定，以及两个基本的方法。


可以认为Lock有一个锁定池，当线程请求锁定时，将线程至于池中，直到获得锁定后出池。池中的线程处于状态图中的同步阻塞状态。


RLock（可重入锁）是一个可以被同一个线程请求多次的同步指令。RLock使用了“拥有的线程”和“递归等级”的概念，处于锁定状态时，RLock被某个线程拥有。拥有RLock的线程可以再次调用acquire()，释放锁时需要调用release()相同次数。


可以认为RLock包含一个锁定池和一个初始值为0的计数器，每次成功调用 acquire()/release()，计数器将+1/-1，为0时锁处于未锁定状态。


简言之：Lock属于全局，Rlock属于线程。


构造方法： 
Lock()，Rlock（）,推荐使用Rlock()


实例方法： 
　　acquire([timeout]): 尝试获得锁定。使线程进入同步阻塞状态。 
　　release(): 释放锁。使用前线程必须已获得锁定，否则将抛出异常。

'''

强大Manage
'''
from multiprocessing import Manager, Process




def worker(dt, lt):
    for i in range(10):
        dt[i] = i*i


    lt += [x for x in range(11, 16)]








if __name__ == '__main__':
    manager = Manager()
    dt = manager.dict()
    lt = manager.list()
    p = Process(target=worker, args=(dt, lt))
    p.start()
    p.join(timeout=3)
    print(dt)
    print(lt)
    
    
def worker(dt, lt):
    for i in range(10):
        key = "args" + str(i)
        dt[key] = i*i
    print(dt)


    lt += [x for x in range(10)]
    print(lt)




worker(dict(), list())




import time


import multiprocessing




def fun(msg):
    print("#########start#### {0}".format(msg))
    time.sleep(3)
    print("#########end###### {0}".format(msg))




if __name__ == '__main__':
    print("start main")
    pool = multiprocessing.Pool(processes=3)
    for i in range(1, 7):
        msg = "hello {0}".format(i)
        pool.apply_async(fun, (msg,))# 执行时间6s+
        # pool.apply(fun, (msg,))   6*3=18+#执行时间
    pool.close()#在调用join之前，要先调用close，否则会报错，close执行完不会有新的进程加入到pool
    pool.join()#join 是等待所有的子进程结束
    print("end main")


# pool.apply_async   非阻塞，定义的进程池最大数的同时执行
# pool.apply    一个进程结束，释放回进程池，开始下一个进程




'''
多线程    密集型io
多线程的实现有两种方法：
方法1：
和多进程类似
方法2：
通过继承的方式
'''


import threading


def worker(args):
    print("开始子进程 {0}".format(args))
    print("结束子进程 {0}".format(args))


if __name__ == '__main__':


    print("start main")
    t1 = threading.Thread(target=worker, args=(1,))
    t2 = threading.Thread(target=worker, args=(2,))
    t1.start()
    t2.start()
    print("end main")
    
    
'''
多线程    密集型io
多线程的实现有两种方法：
方法1：
和多进程类似
方法2：
通过继承的方式
'''


import threading


import time




class Hello(threading.Thread):
    def __init__(self, args):
        super(Hello, self).__init__()
        self.args = args
        global a
        print("a = {0}".format(a))
        a += 1


    def run(self):
        print("开始子进程 {0}".format(self.args))
        print("结束子进程 {0}".format(self.args))


if __name__ == '__main__':
    a = 1
    print("start main")
    t1 = Hello(5)
    time.sleep(3)
    t2 = Hello(5)
    t1.start()
    t2.start()
    print("#####a = {0}####".format(a))
    print("end main")
    
import threading
lock = threading.Lock()


lock.acquire()#获取锁
lock.release()#释放锁
# with lock:
#     time.sleep(3)
# with open("1.txt", "w") as f:
#     f.close






'''
pip install threadpool
from threadpool import *
pool = ThreadPool(size)
requests = makeRequests()
'''
import threadpool




def hello(m, n, o):
    print("m = {0}  n={1}  o={2}".format(m, n, o))


if __name__ == '__main__':
    # 方法1
    lst_vars_1 = ['1', '2', '3']
    lst_vars_2 = ['4', '5', '6']
    func_var = [(lst_vars_1, None), (lst_vars_2, None)]
    # 方法2
    # dict_vars_1 = {'m': '1', 'n': '2', 'o': '3'}
    # dict_vars_2 = {'m': '4', 'n': '5', 'o': '6'}
    # func_var = [(None, dict_vars_1), (None, dict_vars_2)]


    pool = threadpool.ThreadPool(2)
    requests = threadpool.makeRequests(hello, func_var)
    [pool.putRequest(req) for req in requests]
    pool.wait()