线程

前言： 进程，线程傻傻分不清

========= 储备知识 ========
细说背景：CPU+RAM+各种资源（比如显卡，光驱，键盘，GPS, 等等外设）构成我们的电脑，但是电脑的运行，实际就是CPU和相关寄存器以及RAM之间的事情。

一个最最基础的事实：CPU太快，太快，太快了，寄存器仅仅能够追的上他的脚步，RAM和别的挂在各总线上的设备完全是望其项背。那当多个任务要执行的时候怎么办呢？轮流着来?或者谁优先级高谁来？不管怎么样的策略，一句话就是在CPU看来就是轮流着来。

一个必须知道的事实：执行一段程序代码，实现一个功能的过程介绍 ，当得到CPU的时候，相关的资源必须也已经就位，就是显卡啊，GPS啊什么的必须就位，然后CPU开始执行。这里除了CPU以外所有的就构成了这个程序的执行环境，也就是我们所定义的程序上下文。

当这个程序执行完了，或者分配给他的CPU执行时间用完了，那它就要被切换出去，等待下一次CPU的临幸。在被切换出去的最后一步工作就是保存程序上下文，因为这个是下次他被CPU临幸的运行环境，必须保存。

串联起来的事实：前面讲过在CPU看来所有的任务都是一个一个的轮流执行的，具体的轮流方法就是：先加载程序A的上下文，然后开始执行A，保存程序A的上下文，调入下一个要执行的程序B的程序上下文，然后开始执行B,保存程序B的上下文。。。。

========= 结论 ========
进程和线程就是这样的背景出来的，两个名词不过是对应的CPU时间段的描述，名词就是这样的功能。

进程就是包换上下文切换的程序执行时间总和 = CPU加载上下文+CPU执行+CPU保存上下文

线程是什么呢？进程的颗粒度太大，每次都要有上下的调入，保存，调出。
如果我们把进程比喻为一个运行在电脑上的软件，那么一个软件的执行不可能是一条逻辑执行的，必定有多个分支和多个程序段，就好比要实现程序A，实际分成 a，b，c等多个块组合而成。
那么这里具体的执行就可能变成：程序A得到CPU =》CPU加载上下文，开始执行程序A的a小段，然后执行A的b小段，然后再执行A的c小段，最后CPU保存A的上下文。
这里a，b，c的执行是共享了A的上下文，CPU在执行的时候没有进行上下文切换的。
这里的a，b，c就是线程，也就是说线程是共享了进程的上下文环境，的更为细小的CPU时间段。

总结：进程和线程都是一个时间段的描述，是CPU工作时间段的描述，不过是颗粒大小不同。

开启线程

两种方式

# 方式一：
# def task(name):
#     print('%s is running' % name)
#     time.sleep(3)
#
# if __name__ == '__main__':
#     t = Thread(target=task,args=('lmj',))
#
#     # t = Process(target=task,args=('lmj',))
#
#     t.start()
#     print('主线程') # 主线程代码运行完，等待其他子线程
#

# # 方式二：
# class Mytask(Thread):
#
#     def run(self):
#         print('%s is running' % self.name)
#         time.sleep(3)
#
# if __name__ == '__main__':
#     t = Mytask()
#
#     # t = Process(target=task,args=('lmj',))
#
#     t.start()
#     print('主线程') # 主线程代码运行完，等待其他子线程

查看主线程，“子线程”的pid

# # 查看pid：
# import os
# class Mytask(Thread):
#
#     def run(self):
#         print('%s is running' % os.getpid())
#         time.sleep(3)
#
# if __name__ == '__main__':
#     t = Mytask()
#
#     # t = Process(target=task,args=('lmj',))
#
#     t.start()
#     print('主线程',os.getpid()) # 主线程代码运行完，等待其他子线程

线程的方法

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

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

守护线程

无论是进程还是线程，都遵循：守护xxx会等待主xxx运行完毕后被销毁
需要强调的是：运行完毕并非终止运行

#1.对主进程来说，运行完毕指的是主进程代码运行完毕

#2.对主线程来说，运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕，主线程才算运行完毕

详细解释：

#1 主进程在其代码结束后就已经算运行完毕了（守护进程在此时就被回收）,然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)，才会结束，

#2 主线程在其他非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。因为主线程的结束意味着进程的结束，进程整体的资源都将被回收，而进程必须保证非守护线程都运行完毕后才能结束。

from threading import Thread
import time
def foo():
    print(123)
    time.sleep(1)
    print("end123")

def bar():
    print(456)
    time.sleep(3)
    print("end456")

if __name__ == '__main__':

    t1=Thread(target=foo)
    t2=Thread(target=bar)

    t1.daemon=True
    t1.start()
    t2.start()
    print("main---")

"""
123
456
main---
end123
end456
"""

from threading import Thread
import time
def foo():
    print(123)
    time.sleep(5)
    print("end123")

def bar():
    print(456)
    time.sleep(3)
    print("end456")

if __name__ == '__main__':

    t1=Thread(target=foo)
    t2=Thread(target=bar)

    t1.daemon=True
    t1.start()
    t2.start()
    print("main---")

"""
123
456
main---
end456
"""

 线程互斥锁

牺牲效率，保证数据安全性

import time
from threading import Thread,Lock

mutex = Lock()

x = 10
def task():
    global x
    mutex.acquire()
    temp = x
    time.sleep(0.1)
    x = temp - 1
    mutex.release()

if __name__ == '__main__':
    start_time = time.time()
    t_l = []
    for i in range(10):
        t = Thread(target=task)
        t_l.append(t)
        t.start()

    for t in t_l:
        t.join()

    print('主',x)
    print('运行时长',time.time()-start_time)

"""
主 0
运行时长 1.0055220127105713
"""

死锁现象与递归锁RLock()

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2018/04/26 11:53
# @Author  : MJay_Lee
# @File    : 死锁现象与递归锁.py
# @Contact : limengjiejj@hotmail.com

import time
from threading import Thread,RLock

mutexA = mutexB = RLock()


class MyThread(Thread):
    def run(self):
        self.f1()
        self.f2()

    def f1(self):
        mutexA.acquire()
        print('%s 拿到了A锁 ' % self.name)

        mutexB.acquire()
        print('%s 拿到了B锁 ' % self.name)

        mutexB.release()
        mutexA.release()

    def f2(self):
        mutexB.acquire()
        print('%s 拿到了B锁 ' % self.name)
        time.sleep(0.1)

        mutexA.acquire()
        print('%s 拿到了A锁 ' % self.name)
        mutexA.release()
        mutexB.release()

if __name__ == '__main__':
    for i in range(10):
        p = MyThread()
        p.start()

    print('主')

 信号量Semaphore

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2018/04/26 12:20
# @Author  : MJay_Lee
# @File    : 信号量.py
# @Contact : limengjiejj@hotmail.com

import threading
import time
from threading import Thread,Semaphore


def task():
    sm.acquire()
    time.sleep(2)
    print('%s is running' % threading.current_thread().name)
    sm.release()

if __name__ == '__main__':
    sm = Semaphore(5)
    for i in range(20):
        t = Thread(target=task)
        t.start()

"""
效果是5个打印结果一起出现屏幕上
Thread-1 is running
Thread-3 is running
Thread-2 is running
Thread-5 is running
Thread-4 is running
Thread-8 is running
Thread-6 is running
Thread-7 is running
Thread-9 is running
Thread-10 is running
Thread-11 is running
Thread-12 is running
Thread-13 is running
Thread-15 is running
Thread-14 is running
Thread-16 is running
Thread-17 is running
Thread-18 is running
Thread-19 is running
Thread-20 is running

"""

线程queue 

# queue队列 ：使用import queue，用法与进程Queue一样
# 
# queue is especially useful in threaded programming when information must be exchanged safely between multiple threads.
# 
# class queue.Queue(maxsize=0) #先进先出

import queue

q=queue.Queue()
q.put('first')
q.put('second')
q.put('third')

print(q.get())
print(q.get())
print(q.get())
'''
结果(先进先出):
first
second
third
'''

class queue.LifoQueue(maxsize=0) #last in fisrt out 
import queue

q=queue.LifoQueue()
q.put('first')
q.put('second')
q.put('third')

print(q.get())
print(q.get())
print(q.get())
'''
结果(后进先出):
third
second
first
'''

class queue.PriorityQueue(maxsize=0) #存储数据时可设置优先级的队列
import queue

q=queue.PriorityQueue()
#put进入一个元组,元组的第一个元素是优先级(通常是数字,也可以是非数字之间的比较),数字越小优先级越高
q.put((20,'a'))
q.put((10,'b'))
q.put((30,'c'))

print(q.get())
print(q.get())
print(q.get())
'''
结果(数字越小优先级越高,优先级高的优先出队):
(10, 'b')
(20, 'a')
(30, 'c')
'''

线程Event

import time
from threading import Event,current_thread,Thread

# success = False
event = Event()

def check():
    print('%s 正在检测服务是否正常' % current_thread().name)
    time.sleep(5)

    # global success
    # success = True
    event.set()

def connect():
    count = 1
    while not event.is_set():
        if count == 4:
            print('尝试次数过多，请检查网络再重试！')
            return
        print('%s 尝试第 %s 次链接。。。' % (current_thread().name,count))
        # while True:
            # if not success:
            #     time.sleep(2)
            #
        event.wait(1)
        count += 1
    print('%s 开始链接。。。' % current_thread().name)


if __name__ == '__main__':
    t1 = Thread(target=connect)
    t2 = Thread(target=connect)
    t3 = Thread(target=connect)

    c1 = Thread(target=check)

    c1.start()
    t1.start()
    t2.start()
    t3.start()

"""
结果：
Thread-4 正在检测服务是否正常
Thread-1 尝试第 1 次链接。。。
Thread-2 尝试第 1 次链接。。。
Thread-3 尝试第 1 次链接。。。
Thread-1 尝试第 2 次链接。。。
Thread-2 尝试第 2 次链接。。。
Thread-3 尝试第 2 次链接。。。
Thread-2 尝试第 3 次链接。。。
Thread-1 尝试第 3 次链接。。。
Thread-3 尝试第 3 次链接。。。
尝试次数过多，请检查网络再重试！
尝试次数过多，请检查网络再重试！
尝试次数过多，请检查网络再重试！

"""

 协程

1、单线程下实现并发

　　并发指的是，多个任务看起来是同时运行

　　并发实现的本质：切换 + 保存状态

 协程：是单线程下的并发，又称微线程，纤程。英文名Coroutine。一句话说明什么是线程：协程是一种用户态的轻量级线程，即协程是由用户程序自己控制调度的。

主题是基于单线程来实现并发，即只用一个主线程（很明显可利用的cpu只有一个）情况下实现并发，为此我们需要先回顾下并发的本质：切换+保存状态

cpu正在运行一个任务，会在两种情况下切走去执行其他的任务（切换由操作系统强制控制），一种情况是该任务发生了阻塞，另外一种情况是该任务计算的时间过长或有一个优先级更高的程序替代了它

ps：在介绍进程理论时，提及进程的三种执行状态，而线程才是执行单位，所以也可以将下图理解为线程的三种状态 

关键理论：

对于单线程下，我们不可避免程序中出现io操作，但如果我们能在自己的程序中（即用户程序级别，而非操作系统级别）控制单线程下的多个任务能在一个任务遇到io阻塞时就切换到另外一个任务去计算，这样就保证了该线程能够最大限度地处于就绪态，即随时都可以被cpu执行的状态，相当于我们在用户程序级别将自己的io操作最大限度地隐藏起来，从而可以迷惑操作系统，让其看到：该线程好像是一直在计算，io比较少，从而更多的将cpu的执行权限分配给我们的线程。

故此，协程只有在遇到I/O情况才能提升效率，而不是说协程一定能提升效率。

优点：

#1. 协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
#2. 单线程内就可以实现并发的效果，最大限度地利用cpu

缺点：

#1. 协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程
#2. 协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程

一个示例：

import time
def consumer():
    '''任务1:接收数据,处理数据'''
    while True:
        x=yield

def producer():
    '''任务2:生产数据'''
    g=consumer()
    next(g)
    for i in range(10000000):
        g.send(i)
        time.sleep(2)

start=time.time()
producer() #并发执行,但是任务producer遇到io就会阻塞住,并不会切到该线程内的其他任务去执行

stop=time.time()
print(stop-start)

那么，遇到I/O情况，如何实现：（Greenlet）

 如果我们在单个线程内有20个任务，要想实现在多个任务之间切换，使用yield生成器的方式过于麻烦（需要先得到初始化一次的生成器，然后再调用send。。。非常麻烦），而使用greenlet模块可以非常简单地实现这20个任务直接的切换

from greenlet import greenlet

def eat(name):
    print('%s eat 1' %name)
    g2.switch('cly')
    print('%s eat 2' %name)
    g2.switch()
def play(name):
    print('%s play 1' %name)
    g1.switch()
    print('%s play 2' %name)

g1=greenlet(eat)
g2=greenlet(play)

g1.switch('lmj')#可以在第一次switch时传入参数，以后都不需要

此处会有问题，当在eat方法中有遇到I/O，并不会切换，那么如何实现：gevent

from gevent import monkey;monkey.patch_all() # 此步就是给程序中所有I/O打上标记，让gevent能识别
import gevent
import time

def eat(name):
    print('%s eat 1' % name)
    # gevent.sleep(5)
    time.sleep(5)
    print('%s eat 2' % name)

def play(name):
    print('%s play 1' % name)
    # gevent.sleep(3)
    time.sleep(3)
    print('%s play 2' % name)


g1 = gevent.spawn(eat,'lmj')
g2 = gevent.spawn(play,'cly')

# gevent.sleep(6)
gevent.joinall([g1,g2])
"""
lmj eat 1
cly play 1
cly play 2
lmj eat 2
"""