线程

##########################线程#################################
进程是自愿分配的最小单位,线程是CPU调度的最小单位,每一个进程中至少有一个线程
线程属于进程,进程负责获取操作系统分配给我的资源,线程负责执行代码

进程的弊端:
      开启和关闭 以及 切换 都会带来很大的时间开销
      过多的进程还会造成操作系统调度的压力

进程和线程有什么关系?
  1)地址空间和其他自愿(如打开文件):进程间相互独立,同一进程的各线程间共享.某进程内的线程在其他进程不可见
  2)通信: 进程间通信IPC,线程间可以直接读写进程数据段(如全局变量)来进行通信---需要进程同步和互斥手段的辅助
          以保证数据的一致性
  3)调度和切换:线程上下文切换比进程上下文切换要快得多
  4)在多线程操作系统中,进程不是一个可执行的实体

线程的概念
    进程是操作系统中最小的资源分配单位
    线程是CPU调度的最小单位
    线程进程之间的对比
        线程不能独立存在,必须在一个进程里
        线程的开启 关闭以及切换的开销要远远小于进程
    同一个进程之间的多个线程之间数据共享
    全局解释器锁GIL
        使得一个进程中的多个线程不能充分的利用多核


从代码的角度上来看
    多进程
        开启和结束 时间开销大
        切换的效率低
        内存隔离
    多线程
        开启和结束 时间开销非常小
        切换效率高
        内存不隔离

线程的特点:
      1)轻型实体   2) 独立调度和分派的基本单位   3)共享进程资源    4)可并发执行

Cputhon解释器下的全局解释器锁
    在同一进程中的多个线程在同一时刻只能有一个线程访问CPU
    多线程无法形成并行
    锁的线程

Jpython 解释器就没有全局解释器锁

什么时候才会有到CPU
    程序计算的时候

IO阻塞
    是不会用到CPU的

在多个进程线程同时访问一个数据的时候就会产生数据不安全的现象
多进程 访问文件
多线程
    同时去访问一个数据
GIL 全局解释器锁
    在同一个进程里的每一个线程同一时间只能有一个线程访问cpu
尽量不要设置全局变量
只要在多线程/进程之间用到全局变量 就加上锁

from threading import Lock,Thread
死锁
lock = Lock()
lock.acquire()
lock.acquire()
noodle = 100
def func(name,lock):
    global noodle
    lock.acquire()
    noodle -= 1
    lock.release()
    print('%s吃到面了'%name)

if __name__ == '__main__':
    lock = Lock()  # 线程锁 互斥锁
    t_lst = []
    for i in range(10):
        t = Thread(target=func,args=(i,lock))
        t.start()
        t_lst.append(t)
    for t in t_lst:
        t.join()
    print(noodle)

科学家吃面问题
import time
from threading import Thread,Lock
lock = Lock()
noodle_lock = Lock()
fork_lock = Lock()
def eat1(name):
    noodle_lock.acquire()
    print('%s拿到了面' % name)
    fork_lock.acquire()
    print('%s拿到了叉子' % name)
    print('%s在吃面'%name)
    time.sleep(0.5)
    fork_lock.release()  # 0.01
    noodle_lock.release() # 0.01

def eat2(name):
    fork_lock.acquire()  # 0.01
    print('%s拿到了叉子' % name) # 0.01
    noodle_lock.acquire()
    print('%s拿到了面' % name)
    print('%s在吃面'%name)
    time.sleep(0.5)
    noodle_lock.release()
    fork_lock.release()

eat_lst = ['alex','wusir','太白','yuan']
for name in eat_lst:  # 8个子线程 7个线程 3个线程eat1,4个线程eat2
    Thread(target=eat1,args=(name,)).start()
    Thread(target=eat2,args=(name,)).start()


递归锁
from threading import RLock
rlock = RLock()
rlock.acquire()
print(1)
rlock.acquire()
print(2)
rlock.acquire()
print(3)

递归锁解决死锁问题
import time
from threading import Thread,RLock
lock = RLock()
def eat1(name):
    lock.acquire()
    print('%s拿到了面' % name)
    lock.acquire()
    print('%s拿到了叉子' % name)
    print('%s在吃面'%name)
    time.sleep(0.5)
    lock.release()  # 0.01
    lock.release() # 0.01

def eat2(name):
    lock.acquire()  # 0.01
    print('%s拿到了叉子' % name) # 0.01
    lock.acquire()
    print('%s拿到了面' % name)
    print('%s在吃面'%name)
    time.sleep(0.5)
    lock.release()
    lock.release()

eat_lst = ['alex','wusir','太白','yuan']
for name in eat_lst:  # 8个子线程 7个线程 3个线程eat1,4个线程eat2
    Thread(target=eat1,args=(name,)).start()
    Thread(target=eat2,args=(name,)).start()

互斥锁解决死锁问题
import time
from threading import Thread,Lock
lock = Lock()
def eat1(name):
    lock.acquire()
    print('%s拿到了面' % name)
    print('%s拿到了叉子' % name)
    print('%s在吃面'%name)
    time.sleep(0.5)
    lock.release() # 0.01

def eat2(name):
    lock.acquire()  # 0.01
    print('%s拿到了叉子' % name) # 0.01
    print('%s拿到了面' % name)
    print('%s在吃面'%name)
    time.sleep(0.5)
    lock.release()

eat_lst = ['alex','wusir','太白','yuan']
for name in eat_lst:  # 8个子线程 7个线程 3个线程eat1,4个线程eat2
    Thread(target=eat1,args=(name,)).start()
    Thread(target=eat2,args=(name,)).start()

死锁
    多把锁同时应用在多个线程中
互斥锁和递归锁哪个好
    递归锁 快速恢复服务
    死锁问题的出现 是程序的设计或者逻辑的问题
    还应该进一步的排除和重构逻辑来保证使用互斥锁也不会发生死锁
互斥锁和递归锁的区别
    互斥锁 就是在一个线程中不能连续多次ACQUIRE
    递归锁 可以在同一个线程中acquire任意次,注意acquire多少次就需要release多少次

#####################threading模块 thread类###############
Thread类的其他方法

Thread实例对象的方法
    # isAlive(): 返回线程是否活动的
    # getName(): 返回线程名
    #setName() :  设置线程名

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

##信号量###
锁+计时器
和进程的一样, Semaphore 管理一个内置的计数器,
每当调用acquire()时 内置计数器 -1;
调用release()时 内置计数器+1;
计数器不能小于0;当计数器为0时,acquire()将阻塞线程直到其他线程调用release()

池和信号量
import time
from multiprocessing import Semaphore,Process,Pool
def ktv1(sem,i):
    sem.acquire()
    i +=1
    sem.release()

def ktv2(i):
    i +=1

if __name__=='__main__':
    sem = Semaphore(5)
    start = time.time()
    p_1 =[]
    for i in range(100):
        p = Process(target=ktv1,args=(sem,i))
        p.start()
        p_1.append(p)
    for p in p_1:p.join()
    print('###信号量',time.time() - start)


    start = time.time()
    p = Pool(5)
    p_1 = []
    for i in range(100):
        ret = p.apply_async(func = ktv2,args=(sem,i))
        p_1.append(ret)
    p.close()
    p.join()
    print('***池',time.time() - start)

池  效率高
  池子里面有几个一共就起几个
  不管多少任务,池子的个数是固定的
  开启进程和关闭进程这些事都是需要固定的开销
  就不产生额外的时间开销
  且进程池中的进程数控制的好,name操作系统的压力也小

信号量
  有多少个任务就起多少进程/线程
  可以帮助你减少操作系统切换的负担
  但是并不能帮助你减少进/线程开启和关闭的时间


#####事件
和进程一样
wait
  等 到时间内部的信号变成True就不阻塞了
set
  设置信号变成True
clear
  设置信号变成False
is_get
  查看信号是否为True

#数据库连接
import time
import random
from threading import Event,Thread
def check(e):
    """检测一下数据库的网络和我的网络是否通"""
    print('正在检测两台机器之间的网络情况....')
    time.sleep(random.randint(1,3))
    e.set()

def connet_db(e):
    e.wait()
    print('连接数据库...')
    print('连接数据库成功~~~')

e = Event()
Thread(target=connet_db,args=(e,)).start()
Thread(target=check,args=(e,)).start()

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

Python提供的Condition对象提供了对复杂线程同步问题的支持。Condition被称为条件变量，
除了提供与Lock类似的acquire和
release方法外，还提供了wait和notify方法。线程首先acquire一个条件变量，然后判断一些条件。
如果条件不满足则wait；如果
条件满足，进行一些处理改变条件后，通过notify方法通知其他线程，其他处于wait状态的线程接到通知后
会重新判断条件。不断的重
复这一过程，从而解决复杂的同步问题。

import threading

def run(n):
    con.acquire()
    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()
        print('****')

##定时器
定时器,指定n秒后执行某个操作

from threading import Timer
def func():
    print('执行我啦')

interval 时间间隔
Timer(0.2,func).start()  # 定时器
创建线程的时候,就规定它多久之后去执行

 ####线程队列

from multiprocessing import Queue,JoinableQueue       #进程IPC队列
from queue import Queue        #线程队列,先进先出的
from queue import LifoQueue    #后进先出的

队列Queue
  先进先出
  自带锁, 数据安全
栈 LifoQueue
  后进先出
  自带锁,数据安全
lq = LifoQueue()    ##里面如果带有数字, lq里面的值的数量不能超过这个数字,否则它会一直等着
lq.put(123)
lq.put(456)
lq.put('abc')
lq.put('cba')
lq.put('ccc')
lq.put('aaa')
print(lq)
print(lq.get())
print(lq.get())
print(lq.get())
print(lq.get())
print(lq.get())


from queue import PriorityQueue      # 优先级队列
pq = PriorityQueue()
pq.put((10,'aaa'))      ##里面是元组(不是必须),判断优先级,如果是字母根据ACCII码来判断大小
pq.put((5,'zzz'))
print(pq.get())
print(pq.get())

# #python标准模块--concurrent.futures

#1 介绍
concurrent.futures  模块提供了高度封装的异步调用接口(高度封装:省事)
        #进程池/线程池的同一使用方式
ThreadPoolExecutor: 线程池,提供异步调用
ProcessPoolExecutor: 进程池,提供异步调用


#2,基本方法
#submit(fn,*args,**kwargs)
异步提交任务

#map(func,*iterables,timeout = None ,chunksize = 1)
取代for 循环 submit的操作

#shutdown(wait = True)
相当于进程池的 pool.close()+pool.join()操作
wait = True , 等待池内所有任务执行完毕回收完资源后才继续
wait = False, 立即返回,并不会等待池内的任务执行完毕
但不管wait参数为何值,整个程序都会等到所有任务执行完毕
submit和map必须在shutdown之前

#result(timeout = None)
取得结果

#add_done_callback(fn)
回调函数

import time
from threading import currentThread,get_ident
from concurrent.futures import ThreadPoolExecutor     #帮助你启动线程池的类
from concurrent.futures import ProcessPoolExecutor    #帮助你启动线程池的类
def func(i):
    time.sleep(1)
    print('in %s %s'%(i,currentThread()))
    return i**2
t = ThreadPoolExecutor(5)
t.map(func,range(20))
for i in range(20):
        t.submit((func,i))

import time
from threading import currentThread,get_ident
from concurrent.futures import ThreadPoolExecutor     #帮助你启动线程池的类
from concurrent.futures import ProcessPoolExecutor    #帮助你启动线程池的类
def func(i):
    time.sleep(1)
    print('in %s %s'%(i,currentThread()))
    return i**2

def back(fn):
    print(fn.result(),currentThread())


获取任务结果
t = ThreadPoolExecutor(20)
ret_l = []
for i in range(20):
    ret = t.submit(func,i)
    ret_l.append(ret)
t.shutdown()
for ret in ret_l:
    print(ret.result())
print('main : ',currentThread())

import os
import time
from concurrent.futures import ProcessPoolExecutor  # 帮助你启动线程池的类

def func(i):
    time.sleep(1)
    print('in %s %s'%(i,os.getpid()))
    return i**2

def back(fn):
    print(fn.result(),os.getpid())
if __name__ == '__main__':
    print('main : ',os.getpid())
    t = ProcessPoolExecutor(20)
    for i in range(100):
        t.submit(func,i).add_done_callback(back)