线程

一、线程的理解

开启一个word，就是一个进程，
但是可以在这个进程里实现多任务。

通俗的将：开启一个word应用程序，可以在任务管理器查看到它的进程ID，但是
在word里面的其他功能，比如：复制，打印等功能，系统在调用这些功能的时候，并没有
开启新的进程，那他们是怎么执行的呢？答案就是  线程

在一个进程的内部，要同时干多件事，就需要同时运行多个'子任务'，我们
把进程内的这些'子任务'叫做线程

线程通常叫做轻型的进程，线程是共享内存空间的并发执行的多任务，
每一个线程都共享一个进程的资源。
线程是没有独立的堆栈的，他们共享的是进程的资源
线程是最小的执行单元，而进程由至少一个线程组成，如何
调度进程和线程，完全由操作系统决定，程序自己不能决定什么时候
执行，执行多长时间。

模块
1、_thread模块  低级模块（所谓低级，是指它接近底层，用C语言写的，不是功能低级）
2、threading模块 高级模块， 对_thread进行了封装

二、启动一个线程

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import threading
import time

a = 10


def run(num):
    print('子线程(%s)开始' % (threading.current_thread().name))

    # 实现线程的功能
    print('打印')
    time.sleep(2)

    print('子线程(%s)结束' % (threading.current_thread().name))
    time.sleep(2)
    print(a, num)


if __name__ == '__main__':
    # 任何进程默认就会启动一个线程，这个线程成为主线程，
    # 主线程可以启动新的子线程（他和进程一样）

    # current_thread():返回当前线程的实例
    print('主线程(%s)启动' % (threading.current_thread().name))  #打印线程的名称

    # 创建子进程
    # name: 线程的名称
    t = threading.Thread(target=run, name='runThread', args=(1,))
    t.start()

    # 等待线程结束
    t.join()

    print('主线程(%s)结束' % (threading.current_thread().name))

三、线程间共享数据

多线程和多进程之间最大的不同在于，多进程中，同一个变量，各自有一份拷贝存在每一个进程当中，
互不影响，（进程间不共享全局变量），
而多线程之间，所有变量都由所有线程共享。所以，任何一个变量都可以被任意一个线程修改，因此，
线程之间，共享数据最大的危险在于多个线程同时修改一个变量，容易把内容该乱了。

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import threading

NUM = 100

def run1(n):
    global NUM
    for i in range(10000000):
        NUM = NUM + n
        NUM = NUM - n
    print(threading.current_thread().name, NUM)

def run2(n):
    global NUM
    for i in range(10000000):
        NUM = NUM + n
        NUM = NUM - n

    print(threading.current_thread().name, NUM)


if __name__ == '__main__':
    t1 = threading.Thread(target=run1, args=(6,))

    t2 = threading.Thread(target=run2, args=(9,))

    t1.start()
    t2.start()
    t1.join()
    t2.join()

    print('NUM = ' + str(NUM))

四、使用线程锁解决数据混乱

　　由于线程之间存在数据共享，容易出现错误数据的问题。看一下例子：

两个线程同时工作，一个存钱，一个取钱

100  两个任务：1、先取出20
             2、再往里面存10

线程一开启：
        A    B    C
操作一：100 - 20 = 80
操作二：A = C   # C赋值给A   CPU被抢占，操作二等待中

此时，线程二抢占到CPU，执行操作三

线程二开启：
        A    D   E
操作三：100 + 10 = 110
操作四：A = E  # 线程二完成赋值操作  此时A=110

线程二执行完毕，线程一才抢到CPU，继续执行未执行的操作二，（赋值操作）
操作二：A = C    # 此时，A = 80


这样出现的数据的混乱，少了10元。也可能出现110元。

解决方法：加锁！！！

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import threading

# 锁对象
lock1 = threading.Lock()
NUM = 100


def run1(n):
    global NUM
    for i in range(1000000):
        # 在这里加一把锁
        # 确保了这段代码只能由一个线程从头到尾的完整执行
        # 阻止了多线程的并发执行，包含锁的某段代码实际上只能
        # 以单线程模式执行，所以效率大大滴降低了

        # 由于它可以存在多个锁，不同线程可以持有不同的锁，并试图获取其他的锁，这样
        # 锁来锁去的，可能造成死锁，导致多个线程挂起。只能靠操作系统强制终止。
        # 解决方法，使用 try 和 finally
        lock1.acquire()
        try:
            NUM = NUM + n
            NUM = NUM - n
        finally:
            # 修改完一定要释放锁
            lock1.release()
    # print(threading.current_thread().name, NUM)

        '''
        与上面的代码功能相同，with lock可以自动上锁和解锁
        with lock:
            num = num + n
            num = num - n
        '''


if __name__ == '__main__':
    t1 = threading.Thread(target=run1, args=(6,))
    t2 = threading.Thread(target=run1, args=(9,))
    t1.start()
    t2.start()
    t1.join()
    t2.join()

    print('NUM = ' + str(NUM))

五、ThreadLocal

　　关于多线程的数据混乱，除了加锁，还可以使用 ThreadLocal 

　　创建一个全局的ThreadLocal对象

　　每个线程有独立的存储空间

　　每个线程对自己线程内部 ThreadLocal 对象都可以读写，但是与同一进程下的其他线程的ThreadLocal变量互不影响

import threading

NUM = 0

# 创建一个全局的ThreadLocal对象
# 每个线程有独立的存储空间
# 每个线程对自己线程内部 ThreadLocal 对象都可以读写，但是与同一进程下的其他线程的ThreadLocal变量互不影响
local = threading.local()


def run(x, n):
    x = x + n
    x = x - n

def func(n):
    # 每个线程走到这里都会创建一个loacl.x属性 它就是线程的局部变量
    # 给线程里增加一个x属性。
    # 把全局变量赋值给一个局部变量。
    '''
    也就是说，每一个线程在执行local.x属性值的计算的时候，它在自己的线程里都可以找到对应的
    loacl.x 所以它就不会在往外层代码寻找local.x来做计算。这样就不防止线程在自己线程内部找不到
    local.x 的情况下，往外层程序寻找变量，导致数据混乱。

    ThreadLocal 作用: 让线程有一个自己的空间，存储一些自己的局部变量。这些局部变量使我们
    线程自己独有的
    '''

    local.x = NUM
    for i in range(1000000):
        run(local.x, n)
    print('%s-%d' % (threading.current_thread().name, local.x))


if __name__ == '__main__':
    t1 = threading.Thread(target=func, args=(6,))
    t2 = threading.Thread(target=func, args=(9,))
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print('NUM = ', NUM)

# 作用：为每一个线程绑定一个数据库连接，或者是HTTP请求，或者用户信息等，
# 这样一个线程的所有调用到的处理函数都可以非常方便的访问着些资源。

六、信号量控制线程数量

　　threading.Semaphore(int)

　　控制一定线程数量一起执行，当数量不足时，剩下的一起执行。

import threading

import time

# semaphore: 臂板信号。
# 让3个线程一起执行  
sem = threading.Semaphore(3)


def run():
    # 让3个线程一起执行，当线程数量不足3个时，剩下的一起执行。
    with sem:
        for i in range(5):
            print('%s--%d' % (threading.current_thread().name, i))
            time.sleep(1)


if __name__ == '__main__':

    # 开启5个线程
    for i in range(5):
        threading.Thread(target=run).start()

七、凑够一定数量，才能一起执行

　　threading.Barrier(parties)

　　数量如果没有凑够，就一直等待……

import threading
import time

# 凑数量
bar = threading.Barrier(4)


def run():
    print('%s---start----%d' % (threading.current_thread().name, i))
    time.sleep(1)
    # 凑够一定数量，才会执行，凑不够就会等待
    bar.wait()
    print('%s----end----%d' % (threading.current_thread().name, i))


if __name__ == '__main__':
    # 开启5个线程
    for i in range(5):
        threading.Thread(target=run).start()

八、定时线程

　　threading.Timer(interval, function)

import threading


def run():
    print('sunck is a good man')


# 线程5秒钟后执行run方法
t = threading.Timer(5, run)
t.start()

t.join()   # 让父线程等待子线程执行结束，再结束父进程。
print('父线程结束')

九、线程通信

　　threading.Event()

import threading
import time


def func():
    # 线程之间的通信，可以用事件去实现
    # 创建一个事件对象
    event = threading.Event()

    def run():
        for i in range(5):
            # wait：阻塞，等待事件的触发
            event.wait()
            # clear(): 重置，使上面的wait重置到阻塞状态。
            event.clear()
            print('sunck is a good man! %d' % i)

    t = threading.Thread(target=run).start()
    return event


e = func()
# 触发事件
for i in range(5):
    time.sleep(2)
    e.set()

十、生产者与消费者　

import threading
import queue
import time
import random


# 生产者
def product(tid, q):
    while True:
        num = random.randint(0, 10000)
        q.put(num)
        print('生产者%d生产了%d数据放入了队列' % (tid, num))
        time.sleep(3)
    # 任务完成
    q.task_done()


# 消费者
def customer(tid, q):
    while True:
        item = q.get()
        if item is None:
            break
        print('消费者%d消费了%d数据' % (tid, item))
        time.sleep(2)
    # 任务完成
    q.task_done()
    
    
if __name__ == '__main__':
    # 消息队列
    q = queue.Queue()
    # 启动生产者
    for i in range(4):
        threading.Thread(target=product, args=(i, q)).start()
    # 启动消费者
        threading.Thread(target=customer, args=(i, q)).start()

十一、线程调度

import threading
import time


# 线程条件变量
cond = threading.Condition()


def run1():
    with cond:
        for i in range(0, 10, 2):
            print(threading.current_thread().name, i)
            time.sleep(1)
            cond.wait()
            cond.notify()


def run2():
    with cond:
        for i in range(1, 10, 2):
            print(threading.current_thread().name, i)
            time.sleep(1)
            cond.notify()
            cond.wait()


threading.Thread(target=run1).start()
threading.Thread(target=run2).start()