并发编程之并发和线程（threading、进程）

1. 并发

1.1 并发的基本概念

1.1.1 并发和并行的区别

并行，parallel
同时做某些事，可以互不干扰的同一时刻做几件事。
并发，concurrency
也是同时做某些事，但是强调，一个时段内有事情要处理。

1.1.2 并发的解决

食堂打饭模型：

队列、缓冲区（buffering）

争抢

预处理（缓存）

并行（水平扩展思想）

提速（垂直扩展思想）

提高单个CPU性能，或单个服务器安装更多的CPU

消息中间件

  常见的消息中间件有RabbitMQ、ActiveMQ（Apache）、RocketMQ（阿里Apache）、kafka（Apache）等

2. 进程和线程

  在实现了线程的操作系统中，线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一个程序的执行实例就是一个进程。
  进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。Linux进程有父进程、子进程，Windows的进程是平等关系。

2.1 进程和程序的关系

  程序是源代码编译后的文件，而这些文件存放在磁盘上。当程序被操作系统加载到内存中，就是进程，进程中存放着指令和数据（资源），它也是线程的容器。
  线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。在许多系统中，创建一个线程比创建一个进程快10-100倍。

2.1.1 进程与线程的理解

现代操作系统提出进程的概念，每一个进程都认为自己独占所有的计算机硬件资源。
进程就是独立的国家，进程间不可以随便的共享数据。
线程就是省份，同一个进程内线程可以共享进程的资源，每一个线程拥有自己独立的堆栈。（线程之间的数据也是不能共享的）

2.2 线程的状态

2.2.1 python中的进程和线程

进程会启动一个解释器进程，线程共享一个解释器进程。

2.3 python的线程开发

python的线程开发使用标准库threading

2.3.1 Thread类

def __init__(self, group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)

import threading


# 最简单的线程程序
def worker():
	print("I'm working")
	print('Fineshed')


t = threading.Thread(target=worker, name='worker') # 线程对象
t.start() # 启动

  通过threading.Thread创建一个线程对象，target是目标函数，name可以指定名称。但是线程没有启动，需要调用start方法。线程之所以执行函数，是因为线程中就是执行代码的，而最简单的封装就是函数，所以还是函数调用。函数执行完，线程也就退出了。
那么，如果不让线程退出，或者让线程一直工作怎么办呢？

import threading
import time


def worker():
	while True:
		time.sleep(1)
		print("I'm working")
		print('Fineshed')


t = threading.Thread(target=worker, name='worker') # 线程对象
t.start() # 启动

线程退出： python没有提供线程退出的方法，线程在下面情况时退出

1. 线程函数内的语句执行完毕
2. 线程函数中抛出未处理的异常
   python的线程没有优先级、没有线程组的概念，也不能被销毁、停止、挂起，那也就没有恢复、中断了。

线程传参:

import threading
import time


def add(x, y):
	print('{} + {} = {}'.format(x, y, x + y, threading.current_thread().ident))


thread1 = threading.Thread(target=add, name='add', args=(4, 5)) # 线程对象
thread1.start() # 启动
time.sleep(2)
thread2 = threading.Thread(target=add, name='add', args=(5,), kwargs={'y': 4}) # 线程对象
thread2.start() # 启动
time.sleep(2)
thread3 = threading.Thread(target=add, name='add', kwargs={'x': 4, 'y': 5}) # 线程对象
thread3.start() # 启动

线程传参和函数传参没什么区别，本质上就是函数传参。

threading的属性和方法:

active_count、enumerate()方法返回的值还包括主线程。

import threading
import time


def show_thread_info():
    print("current_thread = {}".format(threading.current_thread()))
    print("main thread = {}".format(threading.main_thread()))
    print("active_count = {}".format(threading.active_count()))


def worker():
    count = 0
    show_thread_info()
    while True:
        if count > 3:
            break
        time.sleep(1)
        print("I'm working")
        count += 1


t = threading.Thread(target=worker, name='worker')  # 线程对象
show_thread_info()
t.start()  # 启动
print('==End==')

"""\
current_thread = <_MainThread(MainThread, started 1744)>
main thread = <_MainThread(MainThread, started 1744)>
active_count = 1
current_thread = <Thread(worker, started 8888)>
==End==
main thread = <_MainThread(MainThread, started 1744)>
active_count = 2
I'm working
I'm working
I'm working
I'm working
"""

Thread实例的属性和方法:

注意：线程的name这是一个名称，可以重复；ID必须唯一，但可以在线程退出后再利用

注意：每一个线程必须且只能执行start()方法一次

2.4 多线程

  顾名思义，多个线程，一个进程中如果有多个线程，就是多线程，实现一种并发。一个进程中至少有一个线程，并作为程序的入口，这个线程就是主线程。一个进程至少有一个主线程，其他线程称为工作线程。

2.4.1 线程安全

线程安全
线程执行一段代码，不会产生不确定的结果，那这段代码就是线程安全的。

import threading


def worker():
    for x in range(100):
        print('{} is running'.format(threading.current_thread().name))


for i in range(5):
    name = 'worker{}'.format(i + 1)
    t = threading.Thread(target=worker, name=name)
    t.start()
    

注意：IPython中演示、python命令行、pycharm都不能演示出效果
看代码，应该是一行行打印，但是很多字符串打在了一起，为什么？
  说明，print函数被打断了，被线程切换打断了。print函数分两步，第一步打印字符串，第二步换行，就在这之间，发生了线程的切换。这说明print函数是线程不安全的。
那么问题来了，多线程编程的时候，print输出日志，不能保证一个输出一定后面立即换行了，怎么办？

1. 不让print打印换行，直接将end设置为空

import threading


def worker():
    for x in range(100):
        print('{} is running'.format(threading.current_thread().name), end='')


for i in range(5):
    name = 'worker{}'.format(i + 1)
    t = threading.Thread(target=worker, name=name)
    t.start()
    

2. 使用logging
     标准库里面的logging模块，日志处理模块，线程安全，生成环境代码都使用logging

import threading
import logging


FORMAT = '%(asctime)s %(threadName)s %(thread)d %(message)s'  # 注意%后不能有空格，C语言风格
logging.basicConfig(format=FORMAT, level=logging.INFO)


def worker():
    for x in range(100):
        logging.info('{} is running'.format(threading.current_thread().name), end='')


for i in range(5):
    name = 'worker{}'.format(i + 1)
    t = threading.Thread(target=worker, name=name)
    t.start()
    

2.4.2 daemon线程和non-daemon线程

注意：这里的daemon不是linux中的守护线程
  进程靠线程执行代码，至少有一个主线程，其它线程是工作线程。主线程是第一个启动的线程。父线程：如果线程A中启动了一个线程B，A就是B的父线程。子线程：B就是A的子线程。Python中，构造线程的时候，可以设置daemon属性，这个属性必须在start方法前设置好。
  线程daemon属性，如果设定就是用户的设置，否则就取当前线程的daemon值。主线程是non-daemon线程，即daemon = False。

import time
import threading


def foo():
    time.sleep(2)
    for i in range(3):
        print(i)


# 主线程是non-daemon线程
t = threading.Thread(target=foo, daemon=False)
t.start()
print('Main Thread Exiting')
"""\
Main Thread Exiting
0
1
2
"""

  发现线程t依然执行，主线程已经执行完，但是一直等着线程t。修改为 t = threading.Thread(target=foo, daemon=True) 试一试?程序立即结束了，根本没有等线程t。
总结
  线程具有一个daemon属性，可以显示设置为True或False，也可以不设置，则取默认值None。如果不设置daemon，就取当前线程daemon来设置它。主线程是non-daemon线程，即daemon = False。从主线程创建的所有线程的不设置daemon属性，则默认都是daemon = False，也就是non-daemon线程。Python程序在没有活着的non-daemon线程运行时退出，也就是剩下的只能是daemon线程，主线程才能退出，否则主线程就只能等待。

import time
import threading


def foo(n):
    for i in range(n):
        print(i)
        time.sleep(1)


t1 = threading.Thread(target=foo, args=(2,), daemon=True)  # 调换10和20看看效果
t1.start()

t2 = threading.Thread(target=foo, args=(5,), daemon=False)  # 主线程会等到此线程结束再退出
t2.start()
time.sleep(2)  # 主线程睡2秒钟

print('Main Thread Exiting')
"""\
0
0
1
1
Main Thread Exiting
2
3
4
"""

  上例说明，如果有non-daemon线程的时候，主线程退出时，也不会杀掉所有daemon线程，直到所有nondaemon线程全部结束，如果还有daemon线程，主线程需要退出，会结束所有daemon线程，退出。

2.4.3 join方法

先来看一个简单的例子

import time
import threading


def foo(n):
    for i in range(n):
        print(i)
        time.sleep(1)
        
        
t1 = threading.Thread(target=foo, args=(10,), daemon=True)
t1.start()
t1.join()  # 会让主线程等t1这个工作线程，主线程会卡在这里，直到t1工作线程结束
print('Main Thread Exiting')  # 有了join方法后，此语句会最后打印

  使用了join方法后，daemon线程执行完了，主线程才退出了。join(timeout=None)，是线程的标准方法之一。一个线程中调用另一个线程的join方法，调用者将被阻塞，直到被调用线程终止。一个线程可以被join多次。timeout参数指定调用者等待多久，没有设置超时，就一直等到被调用线程结束。调用谁的join方法，就是join谁，就要等谁。

2.4.4 daemon线程应用场景

  简单来说就是，本来并没有 daemon thread，为了简化程序员的工作，让他们不用去记录和管理那些后台线程，
创造了一个 daemon thread 的概念。这个概念唯一的作用就是，当你把一个线程设置为 daemon，它会随主线程的退出而退出。
主要应用场景有：
1、后台任务。如发送心跳包、监控，这种场景最多。
2、主线程工作才有用的线程。如主线程中维护这公共的资源，主线程已经清理了，准备退出，而工作线程使用这
些资源工作也没有意义了，一起退出最合适。
3、随时可以被终止的线程
  如果主线程退出，想所有其它工作线程一起退出，就使用daemon=True来创建工作线程。比如，开启一个线程定时判断WEB服务是否正常工作，主线程退出，工作线程也没有必须存在了，应该随着主线程退出一起退出。这种daemon线程一旦创建，就可以忘记它了，只用关心主线程什么时候退出就行了。daemon线程，简化了程序员手动关闭线程的工作。
  如果在non-daemon线程A中，对另一个daemon线程B使用了join方法，这个线程B设置成daemon就没有什么意义了，因为non-daemon线程A总是要等待B。
  如果在一个daemon线程C中，对另一个daemon线程D使用了join方法，只能说明C要等待D，主线程退出，C和D不管是否结束，也不管它们谁等谁，都要被杀掉。

import time
import threading


def bar():
    while True:
        time.sleep(1)
        print('bar')


def foo():
    print("t1's daemon = {}".format(threading.current_thread().isDaemon()))
    t2 = threading.Thread(target=bar)  # 默认取t1线程设置的daemon值，即True,但是有join方法,所以t1线程会等待t2线程
    t2.start()
    print("t2's daemon = {}".format(t2.isDaemon()))
    t2.join(2)  # 会死循环，因为t1线程一直要等t2线程，而t2线程函数是死循环，可以设置等待时间


t1 = threading.Thread(target=foo, daemon=True)
t1.start()
t1.join()  # 主线程会卡在这里
time.sleep(3)  # 会让主线程沉睡3秒，会继续执行线程t2
print('Main Thread Exiting')

"""\
t1's daemon = True
t2's daemon = True
bar
bar
bar
bar
bar
Main Thread Exiting
"""

2.4.5 threading.local类

import threading
import time


# 局部变量实现
def worker():
    x = 0
    for i in range(100):
        time.sleep(0.0001)
        x += 1
    print(threading.current_thread(), x)


for _ in range(10):
    threading.Thread(target=worker).start()
    

  上例使用多线程，每个线程完成不同的计算任务。x是局部变量，可以看出每一个线程的x是独立的，互不干扰的，为什么？每个线程函数都需要压栈，并且都是独立的，x为局部变量就是说每个线程函数都使用局部的x，所以会互不干扰
那么问题来了，能否改造成使用全局变量完成？
  因为多线程之间相互干扰，会导致出现不期望的结果。那么能不能使用全局对象，还能保持每个线程使用不同的数据呢？python提供了threading.local类，将这个类实例化得到一个 全局对象，但是不同的线程使用这个对象存储的数据其他线程看不到。

import threading
import time

# 全局对象
global_data = threading.local()


def worker():
    global_data.x = 0
    for i in range(100):
        time.sleep(0.0001)
        global_data.x += 1
    print(threading.current_thread(), global_data.x)


for _ in range(5):
    threading.Thread(target=worker).start()

"""\
<Thread(Thread-5, started 4904)> 100
<Thread(Thread-1, started 8232)> 100
<Thread(Thread-2, started 8564)> 100
<Thread(Thread-3, started 8360)> 100
<Thread(Thread-4, started 5360)> 100
"""

再来看一个threading.local的例子

import threading


X = 'abc'
ctx = threading.local()
ctx.x = 123
print(ctx, type(ctx), ctx.x)


def worker():
    print(X)
    print(ctx)
    print(ctx.x)
    print('working')


worker()  # 普通函数调用，注意此时是在主线程中
print()
threading.Thread(target=worker).start()
# 开启一个新的线程,此时线程函数worker中的ctx.x就会报错，因为此线程看不到主线程中ctx.x的值
# AttributeError: '_thread._local' object has no attribute 'x'

  从运行结果来看，另起一个线程打印ctx.x出错了。AttributeError: ‘_thread._local’ object has no attribute ‘x’，但是，ctx打印没有出错，说明看到ctx，但是ctx中的x看不到，这个x不能跨线程。
threading.local类构建了一个大字典，存放所有线程相关的字典，定义如下：
{ id(Thread) -> (ref(Thread), thread-local dict) }
  每一线程实例的id为key，元组为value。value中2部分为，线程对象引用，每个线程自己的字典。

2.4.6 定时器Timer/延迟执行

threading.Timer继承自Thread，这个类用来定义延迟多久后执行一个函数。
class threading.Timer(interval, function, args=None, kwargs=None)
start方法执行之后，Timer对象会处于等待状态，等待了interval秒之后，开始执行function函数的。

import threading
import logging
import time


FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"
logging.basicConfig(level=logging.INFO, format=FORMAT)


def worker():
    logging.info('in worker')
    time.sleep(2)  # 2秒之后当前线程接结束，主线程也结束了


count = 0
t = threading.Timer(4, worker)
t.setName('timer')
# t.cancel()  # 此位置会取消线程，线程timer都没有机会启动
t.start()
# t.cancel()  # 此位置会取消线程函数的执行，注意线程timer已经启动了
while count < 3:
    print(threading.enumerate())  # 列出当前活着的线程
    time.sleep(1)
    count += 1
    

  Timer提供了cancel方法，用来取消一个未执行的函数，如果上面例子中worker函数已经开始执行，cancel就没有任何效果了。
总结:
  Timer是线程Thread的子类，就是线程类，具有线程的能力和特征。它的实例是能够延时执行目标函数的线程，在真正执行目标函数之前，都可以cancel它。cancel方法本质使用Event类实现。这并不是说，线程提供了取消的方法。