day10--异步IO\数据库\队列\缓存

上节回顾:

线程  vs  进程

  https://www.cnblogs.com/alex3714/articles/5230609.html

  threading.get_ident()获取线程号

线程:操作系统调度的最小单位;进程是一簇线程的集合,本身不能操作,进程至少包含一个线程;

线程同时修改同一份数据时必须加锁,mutex互斥锁。

递归锁。

join()是结束上一个线程,让下一个进程能够执行。等待上一个线程执行完毕。

守护线程(slave):服务于非守护线程(master),

queue(队列):1、解耦,使程序直接首先松耦合;2、提高处理效率;

queue.Queue()  FIFO=first in first out

  queue.LifoQueue()   LIFO=last in first out

PriorityQueue(maxsize=0)    优先级队列。

python中的多线程是伪多线程,其实是CPU的上下文切换,本质是单线程。

io 操作不占用CPU,比如从网上读取;

  计算占用CPU,如1+1占用CPU;

Python的多线程,不适合CPU密集操作型的任务,适合io密集型的任务。

Python的进程也是使用操作系统的原生进程。进程之间是相互独立的。进程之间的数据是独立的,不能共享,进程也能解决操作系统多核的使用。

进程在python模块是multiprocessing,下面来生成一个进程实例:

import multiprocessing
import time

def f(name):
    time.sleep(2)
    print(‘hello‘, name)

if __name__ == ‘__main__‘:
    p = multiprocessing.Process(target=f, args=(‘bob‘,))     #生成一个线程实例
    p.start()
    p.join()    

上面代码生成了一个进程,可以看出,进程与线程的语法几乎一样。

启用多个进程:

import multiprocessing
import time

def f(name):
    time.sleep(1)
    print(‘hello‘, name)

if __name__ == ‘__main__‘:
    for i in range(10):
        p = multiprocessing.Process(target=f, args=(‘bob‘,))     #生成一个线程实例
        p.start()
        # p.join()     

运行结果如下:

hello bob
hello bob
hello bob
hello bob
hello bob
hello bob
hello bob
hello bob
hello bob
hello bob

每一个进程都是由父进程启动的。

from multiprocessing import Process
import os

def info(title):
    print(title)
    print(‘module name:‘, __name__)
    print(‘parent process:‘, os.getppid())     #父进程的ID,每一个进程都是由父进程启动的
    print(‘process id:‘, os.getpid())          #子进程ID
    print("\n\n")

def f(name):
    info(‘\033[31;1mcalled from child process function f\033[0m‘)
    print(‘hello‘, name)

if __name__ == ‘__main__‘:
    info(‘\033[32;1mmain process line\033[0m‘)
    p = Process(target=f, args=(‘bob‘,))
    p.start()
    p.join()

从上面代码可以看出,任何一个进程都是有父进程启动的。Linux里面有一个超级父进程。

    进程间通讯

不同进程间内存是不共享的,要想实现两个进程间的数据交换,可以用以下方法:

Queues

使用方法跟threading里的queue差不多

两个进程之间的内存是独立的。q=queue.Queue()是线程queue,from multiprocessing import Queue是进程Queue。

from multiprocessing import Process, Queue
import os

def func():
    print("线程名字:",__name__)
    print("父线程:",os.getppid())
    print("当前进程:",os.getpid())

def f(q):
    q.put([42, None, ‘hello‘])

if __name__ == ‘__main__‘:
    q = Queue()                         #进程queue
    func()
    p = Process(target=f, args=(q,))    #子进程的,是不能访问父进程的内存的
    p.start()
    print(q.get())  # prints "[42, None, ‘hello‘]"
    p.join()运行结果如下:线程名字: __main__父线程: 2561当前进程: 32596[42, None, ‘hello‘]

进程Queue是两个Queue,不是共享Queue,是通过pickle进行转换,克隆一份,让进程看起来实现了相互通信。

时间: 2024-10-11 19:42:23

day10--异步IO\数据库\队列\缓存的相关文章

异步IO\数据库\队列\缓存

本节内容 Gevent协程 Select\Poll\Epoll异步IO与事件驱动 Python连接Mysql数据库操作 RabbitMQ队列 Redis\Memcached缓存 Paramiko SSH Twsited网络框架 引子 到目前为止,我们已经学了网络并发编程的2个套路, 多进程,多线程,这哥俩的优势和劣势都非常的明显,我们一起来回顾下 协程 协程,又称微线程,纤程.英文名Coroutine.一句话说明什么是线程:协程是一种用户态的轻量级线程. 协程拥有自己的寄存器上下文和栈.协程调度

python 异步IO\数据库\队列\缓存

协程 协程,又称微线程,纤程.英文名Coroutine.一句话说明什么是线程:协程是一种用户态的轻量级线程. 协程拥有自己的寄存器上下文和栈.协程调度切换时,将寄存器上下文和栈保存到其他地方,在切回来的时候,恢复先前保存的寄存器上下文和栈.因此: 协程能保留上一次调用时的状态(即所有局部状态的一个特定组合),每次过程重入时,就相当于进入上一次调用的状态,换种说法:进入上一次离开时所处逻辑流的位置. 协程的好处: 无需线程上下文切换的开销 无需原子操作锁定及同步的开销 方便切换控制流,简化编程模型

Python之路第一课Day10--随堂笔记(异步IO\数据库\队列\缓存之二)

一.RabbitMQ队列 1.安装: a.官网: 安装 http://www.rabbitmq.com/install-standalone-mac.html b.安装python rabbitMQ module pip install pika or easy_install pika or 源码 https://pypi.python.org/pypi/pika 2.实现最简单的队列通信 a.示意图 3.代码: a.send端 #!/usr/bin/env python import pik

arm驱动linux异步通知与异步IO【转】

转自:http://blog.csdn.net/chinazhangzhong123/article/details/51638793 <[ arm驱动] linux异步通知与 异步IO>涉及内核驱动函数二个,内核结构体一个,分析了内核驱动函数二个:可参考的相关应用程序模板或内核驱动模板二个,可参考的相关应用程序模板或内核驱动三个 描述:设备文件IO访问:阻塞与非阻塞io访问,poll函数提供较好的解决设备访问的机制,但是如果有了异步通知整套机制就更加完整了 一.阻塞 I/O,非阻塞IO,异步

8-3:协程、异步IO、数据库、rabbitMQ队列、redis缓存

https://www.cnblogs.com/alex3714/articles/5248247.html 本节内容 1.Gevent协程 2.Select\Poll\Epoll异步IO与事件驱动 3.Python连接Mysql数据库操作 4.RabbitMQ队列 5.Redis\Memcached缓存 6.Paramiko SSH 7.Twsited网络框架 原文地址:https://www.cnblogs.com/chenhuan123/p/12038657.html

SQLite剖析之异步IO模式、共享缓存模式和解锁通知

1.异步I/O模式    通常,当SQLite写一个数据库文件时,会等待,直到写操作完成,然后控制返回到调用程序.相比于CPU操作,写文件系统是非常耗时的,这是一个性能瓶颈.异步I/O后端是SQLite的一个扩展模块,允许SQLite使用一个独立的后台线程来执行所有的写请求.虽然这并不会减少整个系统的资源消耗(CPU,磁盘带宽等),但它允许SQLite在正在写数据库时立刻返回到调用者,从用户角度看,无疑提高了前端的响应速度.对异步I/O,写请求在一个独立的后台线程中被处理,这意味着启动数据库写操

ORACLE数据库异步IO介绍

异步IO概念 Linux 异步 I/O (AIO)是 Linux 内核中提供的一个增强的功能.它是Linux 2.6 版本内核的一个标准特性,当然我们在2.4 版本内核的补丁中也可以找到它.AIO 背后的基本思想是允许进程发起很多 I/O 操作,而不用阻塞或等待任何操作完成.稍后或在接收到 I/O 操作完成的通知时,进程就可以检索 I/O 操作的结果. Linux IO模型(I/O models)分同步IO模型(synchronous models)和异步IO模型(asynchronous mo

# 进程/线程/协程 # IO:同步/异步/阻塞/非阻塞 # greenlet gevent # 事件驱动与异步IO # Select\Poll\Epoll异步IO 以及selectors模块 # Python队列/RabbitMQ队列

1 # 进程/线程/协程 2 # IO:同步/异步/阻塞/非阻塞 3 # greenlet gevent 4 # 事件驱动与异步IO 5 # Select\Poll\Epoll异步IO 以及selectors模块 6 # Python队列/RabbitMQ队列 7 8 ############################################################################################## 9 1.什么是进程?进程和程序之间有什么

异步IO(协程,消息循环队列)

同步是CPU自己主动查看IO操作是否完成,异步是IO操作完成后发出信号通知CPU(CPU是被通知的) 阻塞与非阻塞的区别在于发起IO操作之后,CPU是等待IO操作完成再进行下一步操作,还是不等待去做其他的事直到IO操作完 成了再回来进行. 消息模型:当遇到IO操作时,代码只负责发出IO请求,不等待IO结果,然后直接结束本轮消息处理,进入下一轮 消息处理过程.当IO操作完成后,将收到一条"IO完成"的消息,处理该消息时就可以直接获取IO操作结果. 子程序调用总是一个入口,一次返回,调用顺