python异步线程

⑴ python异步和多进程有什么区别

1. 异步本质还是由多线程来实现，但是是者运行环境/sdk/语言层面帮你隐藏了细节

2. 异步一般和多线程比较，至于和多进程比的一般也是多线程

3. 多进程那就是内存等资源完全隔离开的，开销比较大
   

⑵ python异步协程跟多进程多线程哪个效率高

线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。

一个程序的执行实例就是一个进程。每一个进程提供执行程序所需的所有资源。

PS：上面都是摘抄自网页链接这里的，具体的可以看看这里，你的答案在图片的最后一点。因为线程和进程是不能层面的定义，一个进程可以包括多个线程，所以没有可比性~

⑶ python 异步需要子线程吗

异步：一种通讯方式，对设备需求简单。我们的PC机提供的标准通信接口都是异步的。
异步双方不需要共同的时钟，也就是接收方不知道发送方什么时候发送，所以在发送的信息中就要有提示接收方开始接收的信息，如开始位，同时在结束时有停止位。
异步的另外一种含义是计算机多线程的异步处理。与同步处理相对，异步处理不用阻塞当前线程来等待处理完成，而是允许后续操作，直至其它线程将处理完成，并回调通知此线程。
但此处需要明确的是:异步与多线程与并行不是同一个概念.
不需要

⑷ 如何理解python的多线程编程

线程是程序员必须掌握的知识，多线程对于代码的并发执行、提升代码效率和运行都至关重要。今天就分享一个黑马程序员Python多线程编程的教程，从0开始学习python多任务编程，想了解python高并发实现，从基础到实践，通过知识点 + 案例教学法帮助你想你想迅速掌握python多任务。

课程内容：

1.掌握多任务实现的并行和并发

2.掌握多进程实现多任务

3.掌握多线程实现多任务

4.掌握合理搭配多进程和线程

适用人群：

1、对python多任务编程感兴趣的在校生及应届毕业生。

2、对目前职业有进一步提升要求，希望从事python人工智能行业高薪工作的在职人员。

3、对python人工智能行业感兴趣的相关人员。

基础课程主讲内容包括：

1.python多任务编程

基础班课程大纲：

00-课程介绍

01-多任务介绍

02-进程介绍

03-使用多进程来完成多任务

04-多进程执行带有参数的任务

05-获取进程的编号

06-进程注意点

07-案例-多进程实现传智视频文件夹多任务拷贝器

08-线程介绍

09-使用多线程执行多任务

10-线程执行带有参数的任务

11-主线程和子线程的结束顺序

12-线程之间的执行顺序是无序

13-线程和进程的对比

14-案例-多线程实现传智视频文件夹多任务拷贝器

15-课程总结

⑸ Python中进程与线程的区别是什么

Num01–>线程

线程是操作系统中能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。

一个线程指的是进程中一个单一顺序的控制流。

一个进程中可以并发多条线程，每条线程并行执行不同的任务。

Num02–>进程

进程就是一个程序在一个数据集上的一次动态执行过程。

进程有以下三部分组成：

1，程序：我们编写的程序用来描述进程要完成哪些功能以及如何完成。
2，数据集：数据集则是程序在执行过程中需要的资源，比如图片、音视频、文件等。
3，进程控制块：进程控制块是用来记录进程的外部特征，描述进程的执行变化过程，系统可以用它来控制和管理进程，它是系统感知进程存在的唯一标记。

Num03–>进程和线程的区别：

1、运行方式不同：

进程不能单独执行，它只是资源的集合。

进程要操作CPU，必须要先创建一个线程。

所有在同一个进程里的线程，是同享同一块进程所占的内存空间。

2，关系

进程中第一个线程是主线程，主线程可以创建其他线程；其他线程也可以创建线程；线程之间是平等的。

进程有父进程和子进程，独立的内存空间，唯一的标识符：pid。

3，速度

启动线程比启动进程快。

运行线程和运行进程速度上是一样的，没有可比性。

线程共享内存空间，进程的内存是独立的。

4，创建

父进程生成子进程，相当于复制一份内存空间，进程之间不能直接访问

创建新线程很简单，创建新进程需要对父进程进行一次复制。

一个线程可以控制和操作同级线程里的其他线程，但是进程只能操作子进程。

5，交互

同一个进程里的线程之间可以直接访问。

两个进程想通信必须通过一个中间代理来实现。

相关推荐：《Python视频教程》

Num04–>几个常见的概念

1，什么的并发和并行？

并发：微观上CPU轮流执行，宏观上用户看到同时执行。因为cpu切换任务非常快。

并行：是指系统真正具有同时处理多个任务（动作）的能力。

2，同步、异步和轮询的区别？

同步任务：B一直等着A，等A完成之后，B再执行任务。(打电话案例)

轮询任务：B没有一直等待A，B过一会来问一下A，过一会问下A

异步任务：B不需要一直等着A, B先做其他事情，等A完成后A通知B。（发短信案例）

Num05–>进程和线程的优缺点比较

首先，要实现多任务，通常我们会设计Master-Worker模式，Master负责分配任务，Worker负责执行任务，因此，多任务环境下，通常是一个Master，多个Worker。

如果用多进程实现Master-Worker，主进程就是Master，其他进程就是Worker。

如果用多线程实现Master-Worker，主线程就是Master，其他线程就是Worker。

多进程模式最大的优点就是稳定性高，因为一个子进程崩溃了，不会影响主进程和其他子进程。（当然主进程挂了所有进程就全挂了，但是Master进程只负责分配任务，挂掉的概率低）着名的Apache最早就是采用多进程模式。

多进程模式的缺点是创建进程的代价大，在Unix/linux系统下，用fork调用还行，在Windows下创建进程开销巨大。另外，操作系统能同时运行的进程数也是有限的，在内存和CPU的限制下，如果有几千个进程同时运行，操作系统连调度都会成问题。

多线程模式通常比多进程快一点，但是也快不到哪去，而且，多线程模式致命的缺点就是任何一个线程挂掉都可能直接造成整个进程崩溃，因为所有线程共享进程的内存。在Windows上，如果一个线程执行的代码出了问题，你经常可以看到这样的提示：“该程序执行了非法操作，即将关闭”，其实往往是某个线程出了问题，但是操作系统会强制结束整个进程。

在Windows下，多线程的效率比多进程要高，所以微软的IIS服务器默认采用多线程模式。由于多线程存在稳定性的问题，IIS的稳定性就不如Apache。为了缓解这个问题，IIS和Apache现在又有多进程+多线程的混合模式，真是把问题越搞越复杂。

Num06–>计算密集型任务和IO密集型任务

是否采用多任务的第二个考虑是任务的类型。我们可以把任务分为计算密集型和IO密集型。

第一种：计算密集型任务的特点是要进行大量的计算，消耗CPU资源，比如计算圆周率、对视频进行高清解码等等，全靠CPU的运算能力。这种计算密集型任务虽然也可以用多任务完成，但是任务越多，花在任务切换的时间就越多，CPU执行任务的效率就越低，所以，要最高效地利用CPU，计算密集型任务同时进行的数量应当等于CPU的核心数。

计算密集型任务由于主要消耗CPU资源，因此，代码运行效率至关重要。Python这样的脚本语言运行效率很低，完全不适合计算密集型任务。对于计算密集型任务，最好用C语言编写。

第二种：任务的类型是IO密集型，涉及到网络、磁盘IO的任务都是IO密集型任务，这类任务的特点是CPU消耗很少，任务的大部分时间都在等待IO操作完成（因为IO的速度远远低于CPU和内存的速度）。对于IO密集型任务，任务越多，CPU效率越高，但也有一个限度。常见的大部分任务都是IO密集型任务，比如Web应用。

IO密集型任务执行期间，99%的时间都花在IO上，花在CPU上的时间很少，因此，用运行速度极快的C语言替换用Python这样运行速度极低的脚本语言，完全无法提升运行效率。对于IO密集型任务，最合适的语言就是开发效率最高（代码量最少）的语言，脚本语言是首选，C语言最差。

相关推荐：

Python中的进程是什么

⑹ python多线程的几种方法

Python进阶(二十六)-多线程实现同步的四种方式
临界资源即那些一次只能被一个线程访问的资源，典型例子就是打印机，它一次只能被一个程序用来执行打印功能，因为不能多个线程同时操作，而访问这部分资源的代码通常称之为临界区。
锁机制
threading的Lock类，用该类的acquire函数进行加锁，用realease函数进行解锁
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.lock = threading.Lock() def add(self):
self.lock.acquire()#加锁，锁住相应的资源
self.num += 1
num = self.num
self.lock.release()#解锁，离开该资源
return num

n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item def run(self):
time.sleep(2)
value = n.add()#将num加1，并输出原来的数据和+1之后的数据
print(self.item,value)for item in range(5):
t = jdThread(item)
t.start()
t.join()#使线程一个一个执行

当一个线程调用锁的acquire()方法获得锁时，锁就进入“locked”状态。每次只有一个线程可以获得锁。如果此时另一个线程试图获得这个锁，该线程就会变为“blocked”状态，称为“同步阻塞”（参见多线程的基本概念）。
直到拥有锁的线程调用锁的release()方法释放锁之后，锁进入“unlocked”状态。线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁，并使得该线程进入运行（running）状态。
信号量
信号量也提供acquire方法和release方法，每当调用acquire方法的时候，如果内部计数器大于0，则将其减1，如果内部计数器等于0，则会阻塞该线程，知道有线程调用了release方法将内部计数器更新到大于1位置。
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.sem = threading.Semaphore(value = 3) #允许最多三个线程同时访问资源

def add(self):
self.sem.acquire()#内部计数器减1
self.num += 1
num = self.num
self.sem.release()#内部计数器加1
return num

n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item def run(self):
time.sleep(2)
value = n.add()
print(self.item,value)for item in range(100):

⑺ 如何用python简单的设计开发异步任务调度队列

首先，客户端可以直接扔任务到一个web services的接口上 –》 web api接收到任务后，会根据客户端的ip和时间戳做task_id,返回给客户，紧接着在redis里面标记这任务的状态。 格式为 func,args,kwargs,timeout=xx,queue_level=xx,interval_time=xx
主服务端:
一个线程，会不停的扫描那个redis hash表，取出任务的interval_time后，进行取模，如果匹配成功，就会塞到 redis sorted set有续集和里面。
主线程，会不停的看看sorted set里面，有没有比自己实现小的任务，有的话，执行并删除。 这里的执行是用多进程，为毛用多进程，因为线程很多时候是不好控制强制干掉的。 每个任务都会用multiprocessing的方式去执行，去调用的时候，会多传进一个task_id，用来把相关的进度推送到redis里面。 另外，fork进程后，我会得到一个pid，我会把pid和timeout的信息，存放到kill_hash里面。 然后会不间断的查看，在指定的timeout内，这pid还在不在，如果还是存在，没有退出的话，说明他的任务不太正常，我们就可以在main()，里面干掉这些任务。
所谓的优先级就是个 High + middle +Low 的三合一链条而已，我每次都会坚持从高到低取任务，如果你的High级别的任务不断的话，那么我会一直干不了低级别的任务了。 代码的体现是在redis sorted set这边，设立三个有序集合，我的worker队列会从high开始做……
那么如果想干掉一个任务是如何操作的，首先我需要在 kill_hash 里面标记任务应该赶紧干掉，在就是在task_hash里面把那个task_id干掉，好让他不会被持续的加入待执行的队列里面。

⑻ 做网络爬虫，python 的多线程，异步和 node.js 的异步哪个好

项目初期，我仅仅实现了一个demo，最简单的多线程+requests库+beautiful soup

后来为了性能，重构为异步
IO，在tornado和gevent之间选择了一下，最后选择了gevent，倒不是因为技术原因，而是因为gevent更好写:)
而且还monkey patch了线程等库。此次重构还用自己写的正则匹配，替代了beautiful soup

再后来，爬虫抓取的目标增加了访问频率限制，不得不为爬虫增加了一个动态选择代理的功能，此次的重构耗时较多，也是此次重构为之后埋下了坑，动态选择的过程、代理的不稳定也成了耗时的原因。

为了进一步提速，但又需要绕过访问限制，而自己的服务器资源又不多（其实就一台爬虫服务器）。进行了又一次重构，此次重构可以说是业务上的进步，技术上的“倒退”，我发现如果进一步理解用户需求的话，其实用户需要的80%都是热点数据，而热点数据并不多。

于是改成了最简单的构架，多进程+requests库，用不到200行代码写了爬虫，把复杂的动态选择代理功能去了，仅仅用一个进程一个ip的原始策略抓取热点数据。多运行几个爬虫，问题就都解决了，而且稳定性，可维护性极大提升。

作为总结的废话是，如果楼主是打算做实际的项目，上线、盈利甚至以后会交给别人维护项目、代码，可以多分析一下用户需求，和自己的资源能力。写个爬虫做项目简单，解决自己埋下的坑很难。

⑼ python多线程的问题如何处理

在python里线程出问题，可能会导致主进程崩溃。 虽然python里的线程是操作系统的真实线程。

那么怎么解决呢？通过我们用进程方式。子进程崩溃后，会完全的释放所有的内存和错误状态。所以进程更安全。 另外通过进程，python可以很好的绕过GIL，这个全局锁问题。

但是进程也是有局限的。不要建立超过CPU总核数的进程，否则效率也不高。

简单的总结一下。
当我们想实现多任务处理时，首先要想到使用multiprocessing， 但是如果觉着进程太笨重，那么就要考虑使用线程。 如果多任务处理中需要处理的太多了，可以考虑多进程，每个进程再采用多线程。如果还处理不要，就要使用轮询模式，比如使用poll event, twisted等方式。如果是GUI方式，则要通过事件机制，或者是消息机制处理，GUI使用单线程。

所以在python里线程不要盲目用， 也不要滥用。 但是线程不安全是事实。如果仅仅是做几个后台任务，则可以考虑使用守护线程做。如果需要做一些危险操作，可能会崩溃的，就用子进程去做。 如果需要高度稳定性，同时并发数又不高的服务。则强烈建议用多进程的multiprocessing模块实现。

在linux或者是unix里，进程的使用代价没有windows高。还是可以接受的。

⑽ python 多线程 怎么改成异步

python使用multiprocessing模块实现带回调函数的异步调用方法。分享给大家供大家参考。具体分析如下：
multipressing模块是python 2.6版本加入的，通过这个模块可以轻松实现异步调用
from multiprocessing import Pool
def f(x):
return x*x
if __name__ == '__main__':
pool = Pool(processes=1)
# Start a worker processes.
result = pool.apply_async(f, [10], callback)
# Evaluate "f(10)" asynchronously calling callback when finished.
希望本文所述对大家的Python程序设计有所帮助。