micropython多线程关闭调度_Python中并发、多线程等

1、基本概念

并发和并行的区别：

1)并行，parallel

同时做某些事，可以互不干扰的同一时刻做几件事。(解决并发的一种方法)

高速公路多个车道，车辆都在跑。同一时刻。

2)并发 concurrency

同时做某些事，一个时段内有事情要处理。(遇到的问题)

高并发，同一时刻内，有很多事情要处理。

2、并发的解决

1)队列、缓冲区

排队就是把人排成队列，先进先出，解决了资源使用的问题。

排成的队列，其实就是一个缓冲地带，就是缓冲区。

Queue模块的类queue、lifoqueue、priorityqueue。

2)争抢的

会有一个人占据窗口，其他人会继续争抢，可以锁定窗口，窗口不在为其他人服务，这就是锁机制。(锁的概念，排他性锁，非排他性锁)。

3)预处理

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

4)并行

日常可以通过购买更多的服务器，或者开多线程，实现并行处理，来解决并发问题。

水平扩展思想。

如果在但CPU上处理，就不是并行了。

但是多数服务都是多CPU的，服务的部署就是多机、分布式的，都是并行处理。

(串行比并行快)

5)提速

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

这就是一种垂直扩展思想。

6)消息中间件

例如地跌站外的九曲回肠的走廊，缓冲人流。

常见的消息中间件有RabbitMQ，ActiveMQ(Apache)、RocketMQ(Apache)。

3、进程和线程

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

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

(可执行，可运行的加载到内存中。程序是有一定格式的，Python解释器加载，所有进程都是有入口的。偏移多少位。主线程达不到要求，就会启用多线程。

多核。调度到不同的CPU上面去，虚拟的计算单元。)

资源争抢问题:锁，排他性锁。队列，不争抢的人排队。预加载，减少数据处理速度，提前加载到内存中。一变多。

进程和程序的关系

程序是源代码编译后的文件，而这些文件存放在磁盘上。当程序被操作系统加载到内存

中，就是进程，进程中存放着指令和数据(资源)，也是线程的容器。

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

线程，有时被称为轻量级进程，是程序执行流的最小单元，一个标准的线程由线程ID，当前指令指针(pc)，寄存器集合和堆栈组成。每个线程有自己独立的栈。

在许多系统中，创建一个线程比创建一个进程快10-100倍。

进程、线程的理解

现代操作系统提出的进程的概念，每一个进程都认为自己是独占所有的计算机硬件资源。

进程就是独立的王国，进程间不可以随便的共享数据。

线程就是省份，同一个进程内的线程可以共享进程的资源，每一个线程拥有自己独立的堆栈。

4、线程状态

状态

含义

就绪(ready)

线程能够运行，但在等待被调度，可能线程刚刚创建启动，或刚刚从阻塞恢复，或者被其他线程抢占。

运行(running)

线程正在运行

阻塞(Blocked)

线程等待外部事件发生而无法运行，如I/O操作。

终止(Terminated)

线程完成，或退出，或被取消。

5、Python中的线程和进程

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

1)Python的线程开发

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

2)Thread类

签名:

def __init__(self, group: None = ...,

target: Optional[Callable[..., None]] = ...,

name: Optional[str] = ...,

args: Iterable = ...,

kwargs: Mapping[str, Any] = ...,

*, daemon: Optional[bool] = ...) -> None: ...

参数名

含义

target

线程调用对象，就是目标函数

name

为线程起名字

args

为目标函数传递实参，元组

Kwargs

为目标函数关键词传参，字典

3)线程启动

import threading

import time

def worker():

print('before')

time.sleep(3)

print('finished')

t = threading.Thread(target=worker)  #线程对象

t.start()   #启动

通过threading.Thread创建一个线程对象，target是目标函数，name可以指定名称。

需要调用start方法启动函数。

线程之所以执行函数，是因为线程中就是用来执行代码的，所以还是函数调用。

函数执行完毕后，线程也就退出了。

如果想让一个线程一直工作，不让线程退出就要利用到while循环。

import threading

import time

def worker():

count = 0

while True:

count += 1

print('before')

time.sleep(3)

if count >5:

print('finished')

break

t = threading.Thread(target=worker)  #线程对象

t.start()   #启动

4)线程退出

Python中没有提供终止线程的方法。线程在下面情况下退出。

(1)线程函数内语句执行完毕

(2)线程函数中抛出未处理的异常。

import threading

import time

def worker():

count = 0

while True:

if count >5:

break

#return

#raise RuntimeError(count)

time.sleep(3)

print('before')

count += 1

print('finished')

t = threading.Thread(target=worker)  #线程对象

t.start()   #启动

print('end')

线程没有优先级，没有线程组的概念。也不能被销毁、停止、挂起，那么就是没有恢复和中断了。

5)线程的传参

import threading

import time

def add(x,y):

print('{}+{}={}'.format(x,y,x+y))

t1 = threading.Thread(target=add,name='1',args=(4,5))

t1.start()

time.sleep(2)

t2 = threading.Thread(target=add,name = '2',args=(4,),kwargs={'y':6})

t2.start()

time.sleep(2)

t3 = threading.Thread(target=add,name='3',kwargs={'x':4,'y':7})

t3.start()

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

6)threading的属性和方法

名称

含义

current_thread()

返回当前主线程

main_thread()

返回主线程对象

active_count()

当前处于alive状态的线程个数

enumerate()

返回所有活着的线程的列表，不包括已经终止的线程和未开始的线程

git_ident()

返回当前线程的ID，非0整数。

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

import threading

import time

def showinfo():

print('currentthread = {}'.format(threading.current_thread()))

print('main thread = {}'.format(threading.main_thread()))

print('active count = {}'.format(threading.active_count()))

def worker():

count = 0

showinfo()

while True:

if count>5:

break

time.sleep(5)

count += 1

print('finsh')

t = threading.Thread(target=worker,name='work')

showinfo()

t.start()

print('end')

currentthread = <_mainthread started>

main thread = <_mainthread started>

active count = 1

currentthread =

end

main thread = <_mainthread stopped>

active count = 2

finsh

finsh

finsh

finsh

finsh

Finsh

名称

含义

Name

他只是一个名字，只是一个标识符，名字可以重名，getname()获取，setname()设置这个名词

Ident

线程id，是非0的整数，线程启动后才会有ID，否则为None，线程退出，此id依旧可以访问，此id可以重复访问。

Is_alive()

返回线程是否或者

线程的name只是一个名称，可以重复；id必须唯一，但可以在线程退出后在利用。

import threading

import time

def worker():

count = 0

while True:

if count > 5:

break

time.sleep(2)

count += 1

print(threading.current_thread().name)

t = threading.Thread(name='work',target=worker)

print(t.ident)

t.start()

while True:

time.sleep(1)

if t.is_alive():

print('{}{}alive'.format(t.name,t.ident))

else:

print('{}{}dead'.format(t.name,t.ident))

名称

含义

Start()

启动线程，每一个线程必须且只能执行该方法一次

Run()

运行线程函数

Start()启动线程，只能执行一次。操作系统。开辟新的线程。

Run()直接做的是主线程。函数调用。

(1)start()

import threading

import time

def worker():

count = 0

while True:

if count > 5:

break

time.sleep(3)

count += 1

print('running')

class Mythread(threading.Thread):

def start(self):

print('start----')

super().start()

def run(self):

print('run----')

super().run()

t = Mythread(target=worker,name='work')

t.start()

start方法运行结果是start----

run----

Running

按照线程进行执行。

(2)run()

import threading

import time

def worker():

count = 0

while True:

if count>3:

break

time.sleep(2)

count += 1

print('runing')

class Mythread(threading.Thread):

def start(self):

print('start----')

super().start()

def run(self):

print('run----')

super().run()

t = Mythread(target=worker,name='work1')

t.run()

# run----

# runing

总结：run()执行结果就是直接是函数，调用，调用run函数。

Start()方法会调用run()方法，而run()方法可以运行函数。

(3)start和run的区别

Start方法启动线程，启动了一个新的线程，名字叫做worker运行，但是run方法，并没有启动新的线程，只是在主线程内调用了一个普通的函数。

7)多线程

多线程，一个进程中如果有多个线程，就是多线程，是先一种并发。

import threading

import time

def worker():

count = 0

while True:

if count>3:

break

time.sleep(2)

count += 1

print('runing')

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(target=worker,name='work1')

t2 = Mythread(target=worker,name='work2')

# t1.run()

# t2.run()

####runing

# MainThread 1380

# runing

# MainThread 1380

# runing

# MainThread 1380

t1.start()

t2.start()

# start----

# run----

# start----

# run----

# runing

# work2 5048

# runing

# work1 9048

Start()方法work1和work2交替执行。启动线程后，进程内多个活动的线程并行工作，就是多线程。

Run()方法中没有开启新的线程，就是普通函数调用，所以执行完t1.