并发和线程

基本概念

并发和并行区别

并行，parallel
同时做某些事，可以互不干扰的同一个时刻做几件事

并发，concurrency
也是同时做某些事，但是强调，一个时段内有事情要处理

举例
乡村公路一条车道，半幅路面出现了坑，交警指挥交通
众多车辆在这一时段要通过路面的事件，这就是并发
交警指挥，车辆排队通过另外半幅路面，一个方向放行3分钟，停止该方向通行，换另一个方向放行

高速公路的车道，双向4车道，所有车辆（数据）可以互不干扰的在自己的车道上奔跑（传输）
在同一时刻，每条车道上可能同时有车辆在跑，是同时发生的概念，这是并行

并发的解决

食堂打饭模型
中午12点，开饭啦，大家都涌向食堂，这就是并发。如果人很多，就是高并发

1. 队列、缓冲区

假设只有一个窗口，陆续涌入食堂的人，排队打菜是比较好的方式
所以，排队（队列）是一种天然解决并发的办法
排队就是把人排成队列，先进先出，解决资源使用的问题
排成的队列，其实就是一个缓冲地带，就是缓冲区

假设女生优先，那么这个窗口就得是两队，只要有女生来就可以先打饭，男士队列等着，女生队伍就是一个优先队列

例如queue模块的类Queue、LifoQueue、PriorityQueue

2. 争抢

只开一个窗口，有可能没有秩序，也就是谁挤进去就给谁打饭
挤到窗口的人占据窗口，直到打到饭菜离开
其他人继续争抢，会有一个人占据着窗口，可以视为锁定窗口，窗口就不能为其他人提供服务了。这是一种锁机制
谁抢到资源就上锁，排他性的锁，其他人只能等候

争抢也是一种高并发解决方案，但是，这样不好，因为有可能有人很长时间抢不到

3. 预处理

如果排长队的原因，是由于每个人打菜等候时间长，因为要吃的菜没有，需要现做，没打着饭不走开，锁定着窗口
食堂可以提前统计大多数人最爱吃的菜品，将最爱吃的80%的热门菜，提前做好，保证供应，20%的冷门菜，现做
这样大多数人，就算锁定窗口，也很快就释放窗口了

一种提前加载用户需要的数据思路，预处理思想，缓存常用

4. 并行

成百上千同时来吃饭，一个队伍搞不定的，多开打饭窗口形成多个队列，如同开多个车道一样，并行打菜

开窗口就得扩大食堂，得多雇人在每一个窗口提供服务，造成成本上升

日常可以通过购买更多服务器，或多开进程、线程实现并行处理，来解决并发问题
注意这些都是水平扩展思想

注：
如果线程在单CPU上处理，就不是并行了
但是多数服务器都是多CPU的，服务的部署往往是多机的、分布式的，这都是并行处理

5. 提速

提高单个窗口的打饭速度，也是解决并发的方式
打饭人员提高工作技能，或为单个窗口配备更多的服务人员，都是提速的办法
提高单个CPU性能，或单个服务器安装更多的CPU
这是一种垂直扩展思想

6. 消息中间件

地铁站外的九曲回肠的走廊，缓冲人流，进去之后再多口安检进站
常见的消息中间件有RabbitMQ、ActiveMQ（Apache）、RocketMQ（阿里Apache）、Kafka（Apache）等

当然还有其他手段解决并发问题，但是已经理据除了最常用的解决方案，一般来说不同并发场景用不同的策略，而策略可能是多种方式的优化组合

例如多开食堂（多地），也可以把食堂建设到宿舍生活区（就近），所以说，技术就来源于生活

并发和线程

在实现了线程的操作系统中，线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一个程序的执行实例就是一个进程

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础

进程和程序的关系
程序是源代码编译后的文件，而这些文件存放在磁盘上。当程序被操作系统加载到内存中，就是进程，进程中存放着指令和数据（资源），它也是线程的容器

Linux进程有父进程、子进程，Windows进程是平等关系

线程，有时被称为轻量级进程（Lightweight Process, LWP），是程序中执行流的最小单元。一个标准的线程由线程ID，当前指令指针（PC），寄存器集合和堆栈组成。
在许多系统中，创建一个线程比创建一个进程快10-100倍

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

线程的状态

状态	含义
就绪（Ready）	线程能够运行，但在等待被调度。可能线程刚刚创建启动，或刚刚从阻塞中恢复，或者被其他线程抢占
运行（Running）	线程正在运行
阻塞（Blocked）	线程等待外部事件发生而无法运行，如I/O操作
终止（Terminated）	线程完成，或退出，或被取消

python中的进程和线程

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

python的线程开发

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

Thread类

# 签名
def __init__(self, group=None, target=None, name=None, args=(), kwargs=None, *, daemon=None)

参数名	含义
target	线程调用的对象，就是目标函数
name	为线程起个名字
args	为目标函数传递实参，元组
kwargs	为目标函数关键字传参，字典

线程启动

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、线程函数中抛出未处理的异常

import threading
import time

def worker():
    count = 0
    while True:
        if count > 5:
            # raise RuntimeError(count)
            # return
            break
        time.sleep(1)
        print("I'm working")
        count += 1

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

print('==End==')

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的属性和方法

名称	含义
current_thread()	返回当前线程对象
main_thread()	返回主线程对象
active_count()	当前处于alive状态的线程个数
enumerate()	返回所有活着的线程列表，不包括已经终止的线程何未开始的线程
get_ident()	返回当前线程的ID，非0整数

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

import threading
import time

def showthreadinfo():
    print()
    print()
    print()

def worker():
    count = 0
    showthreadinfo()
    while True:
        if count > 5:
            break
            count += 1
            print("I'm working")

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

print('==End==')

Thread实例的属性和方法

名称	含义
name	只是一个名字，只是个标识，名称可以重名。getName()、setName()获取、设置这个名词
ident	线程ID，它是非0整数。线程启动后才会有ID，否则为None。线程退出，此ID依旧可以访问。此ID可以重复使用
is_alive()	返回线程是否活着

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

名称	含义
start()	启动线程。每一个线程必须且只能执行该方法一次
run()	运行线程函数

start

import threading
import time

def worker():
    count = 0
    while True:
        if count > 5:
            break
        time.sleep(1)
        count += 1
        print("worker running")

class MyThread(threading.Thread):
    def start(self):
        print('start~~~~~')
        super().start()

    def run(self):
        print('run~~~~~')
        super().run()

t = MyThread(name='worker', target=worker)
t.start()
# 运行结果
start~~~~~
run~~~~~
worker running

run方法

import threading
import time

def worker():
    count = 0
    while True:
        if count > 5:
            break
        time.sleep(1)
        count += 1
        print("worker running")

class MyThread(threading.Thread):
    def start(self):
        print('start~~~~~')
        super().start()

    def run(self):
        print('run~~~~~')
        super().run()

t = MyThread(name='worker', target=worker)
# t.start()
t.run()
# 运行结果
run~~~~~
worker running

start()方法会调用run()方法，而run()方法可以运行函数
这两个方法看似功能重复了，这么看来留一个方法就可以了

start和run的区别

在线程函数中，增加打印线程的名字和语句，看看能看到什么信息

import threading
import time

def worker():
    count = 0
    while True:
        if count > 5:
            break
        time.sleep(1)
        count += 1
        print("worker running")

class MyThread(threading.Thread):
    def start(self):
        print('start~~~~~')
        super().start()

    def run(self):
        print('run~~~~~')
        super().run()

t = MyThread(name='worker', target=worker)
t.start()
# t.run()  # 分别执行start或者run方法

使用start方法启动线程，启动了一个新的线程，名字叫做worker运行。但是使用run方法的，并没有启动新的线程，就是在主线程中调用了一个普通的函数而已
因此，启动线程请使用start方法，才能启动多个线程

多线程

顾名思义，多个线程，一个进程中如果有个线程，就是多个线程，实现一种并发

import threading
import time

def worker():
    count = 0
    while True:
        if count > 5:
            break
        time.sleep(5)
        count += 1
        print("worker running")
        print(threading.current_thread().name, threading.current_thread().ident)

class MyThread(threading.Thread):
    def start(self):
        print('start~~~~~')
        super().start()

    def run(self):
        print('run~~~~~')
        super().run()  # 看看父类再做什么

t1 = MyThread(name='worker1', target=worker)
t2 = MyThread(name='worker2', target=worker)

t1.start()
t2.start()

可以看到worker1和work2交替执行
改成run方法试试看

import threading
import time

def worker():
    count = 0
    while True:
        if count > 5:
            break
        time.sleep(0.5)
        count += 1
        print("worker running")
        print(threading.current_thread().name, threading.current_thread().ident)

class MyThread(threading.Thread):
    def start(self):
        print('start~~~~~')
        super().start()

    def run(self):
        print('run~~~~~')
        super().run()

t1 = MyThread(name='worker1', target=worker)
t2 = MyThread(name='worker2', target=worker)

# t1.start()
# t2.start()
t1.run()
t2.run()

没有开新的线程，这就是普通函数调用，所以执行完t1.run()，然后执行t2.run()，这里就不是多线程
当使用start方法启动线程后，进程内有多个活动的线程并行的工作，就是多线程
一个进程中至少有一个线程，并作为程序的入口，这个现场就是主线程，一个进程至少有一个主线程
其他线程称为工作线程

文章作者: gloo

文章连结:

微信扫一扫

Gloo

并发和线程

基本概念

并发和并行区别

并发的解决

1. 队列、缓冲区

2. 争抢

3. 预处理

4. 并行

5. 提速

6. 消息中间件

并发和线程

线程的状态

python中的进程和线程

python的线程开发

Thread类

线程启动

线程退出

线程的传参

threading的属性和方法

Thread实例的属性和方法

start

run方法

start和run的区别

多线程