python_day10 多线程 协程 IO模型

多线程
协程
IO模型

多线程

#线程的PID与主进程PID一致
from threading import Thread
from multiprocessing import Process
import os
def task():
    print(‘%s is running‘ %os.getpid())
if __name__ == ‘__main__‘:
    t1=Thread(target=task,)
    t2=Thread(target=task,)
    # t1=Process(target=task,)
    # t2=Process(target=task,)
    t1.start()
    t2.start()
    print(‘主‘,os.getpid())
#多线程共享一个进程内的资源
from threading import Thread
from multiprocessing import Process
n=100
def work():
    global n
    n=0
if __name__ == ‘__main__‘:
    # p=Process(target=work,)
    # p.start()
    # p.join()
    # print(‘主‘,n)
    t=Thread(target=work,)
    t.start()
    t.join()
    print(‘主‘,n)
#开启线程的两种方式
#开启线程的方式一:使用替换threading模块提供的Thread
from threading import Thread
from multiprocessing import Process
def task():
    print(‘is running‘)
if __name__ == ‘__main__‘:
    t=Thread(target=task,)
    # t=Process(target=task,)
    t.start()
    print(‘主‘)
#开启线程的方式二:自定义类,继承Thread
from threading import Thread
from multiprocessing import Process
class MyThread(Thread):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        print(‘%s is running‘ %self.name)
if __name__ == ‘__main__‘:
    t=MyThread(‘egon‘)
    # t=Process(target=task,)
    t.start()
    print(‘主‘)
#多线程共享同一进程内地址空间的练习
#三个任务,一个接收用户输入,一个将用户输入的内容格式化成大写,一个将格式化后的结果存入文件
from threading import Thread
msg_l=[]
format_l=[]
def talk():
    while True:
        msg=input(‘>>: ‘).strip()
        msg_l.append(msg)
def format():
    while True:
        if msg_l:
            data=msg_l.pop()
            format_l.append(data.upper())
def save():
    while True:
        if format_l:
            data=format_l.pop()
            with open(‘db.txt‘,‘a‘) as f:
                f.write(‘%s\n‘ %data)
if __name__ == ‘__main__‘:
    t1=Thread(target=talk)
    t2=Thread(target=format)
    t3=Thread(target=save)
    t1.start()
    t2.start()
    t3.start()
#Thread对象其他相关的属性或方法
from threading import Thread,activeCount,enumerate,current_thread
import time
def task():
    print(‘%s is running‘ %current_thread().getName())
    time.sleep(2)
if __name__ == ‘__main__‘:
    t=Thread(target=task,)
    t.start()
    t.join()
    print(t.is_alive())
    print(t.getName())
    print(enumerate())
    print(‘主‘)
    print(activeCount())

协程
IO模型

时间: 2024-10-13 00:28:33

python_day10 多线程 协程 IO模型的相关文章

Http协议和IO模型

HTTP 协议和IO模型 一:HTTP协议 http协议:HyperText Transfer Procotol超文本传输协议,http协议是无状态的,监听在80端口,TCP协议上.HTTP协议的特点有以下几点: 1.支持客户/服务器模式.2.简单快速:客户向服务器请求服务时,只需传送请求方法和路径.请求方法常用的有GET.HEAD.POST.每种方法规定了客户与服务器联系的类型不同.由于HTTP协议简单,使得HTTP服务器的程序规模小,因而通信速度很快.3.灵活:HTTP允许传输任意类型的数据

一个简单的多进程+多线程+协程的例子

因为一个朋友最近想搞接口压力测试,推荐了jmeter,因为jmeter开源,且有命令行启动模式,方便封装.兴起时,自己也简单实现了一下高并发的脚本. 采用的是多进程+多线程+协程.想法是这样的,多进程是为了有效利用多核,理论上最好一个核对应一个进程比较好:那我为什么还要用多线程呢?不怕GIL全局锁吗?这是因为我用了gevent处理,请求采用requests,但requests是阻塞的方法,所以我把requests操作丢到协程做,就没啥问题了.接下来看看脚本,实现了一个2000并发量的脚本(写的比

协程/IO多路复用

一.协程: 概念:是一个比线程更加轻量级的单位,是组成线程的各个函数 为什么要有协程: 想要在单线程内实现并发的效果.但因为Cpython有GIL锁,限制了在同一时间点,CPU只能执行一个线程,所以想要在执行一个线程的期间,充分利用cpu的性能,所以才有了想在单线程内实现并发的效果 cpu 为什么要切换: 1.因为某个程序阻塞 2.因为某个程序用完了时间片 很明显,解决1 这个问题才能提高效率 所以想要实现单线程的并发,就要解决在单线程中,多个任务函数中,某个任务函数遇见IO操作,马上自动切换到

# 进程/线程/协程 # 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.什么是进程?进程和程序之间有什么

day10-python并发编程之多线程协程及MySQL

第1章 python并发编程之多线程 1.1 死锁现象与递归锁 1.1.1 死锁概念 进程也有死锁与递归锁,在进程那里忘记说了,放到这里一切说了额 所谓死锁: 是指两个或两个以上的进程或线程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去.此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程,如下就是死锁 1.1.2 博客实例 from threading import Thread,Lock import time mutexA=L

python开发concurent.furtrue模块:concurent.furtrue的多进程与多线程&协程

一,concurent.furtrue进程池和线程池 1.1 concurent.furtrue 开启进程,多进程&线程,多线程 1 # concurrent.futures创建并行的任务 2 # 进程池 ProcessPoolExecutor,ThreadPoolExecutor 3 # 下面例子是Io密集型,所以时间上比叫多 4 from concurrent.futures import ProcessPoolExecutor 5 import os,time,random 6 def t

python 多进程/多线程/协程 同步异步

这篇主要是对概念的理解: 1.异步和多线程区别:二者不是一个同等关系,异步是最终目的,多线程只是我们实现异步的一种手段.异步是当一个调用请求发送给被调用者,而调用者不用等待其结果的返回而可以做其它的事情.实现异步可以采用多线程技术或则交给另外的进程来处理.多线程的好处,比较容易的实现了 异步切换的思想, 因为异步的程序很难写的.多线程本身程还是以同步完成,但是应该说比效率是比不上异步的. 而且多线很容易写, 相对效率也高. 2.异步和同步的区别:  在io等待的时候,同步不会切走,浪费了时间.异

多线程--协程

---恢复内容开始--- 迭代器: 常用的可以迭代的类型: 1 from collections import Iterable 2 print(issubclass(int,Iterable)) #False 3 print(issubclass(float,Iterable)) #False 4 print(issubclass(list,Iterable)) #True 5 print(issubclass(tuple,Iterable)) #True 6 print(issubclass

python协程io自动切换--gevent

1.gevent执行 import gevent def func1(): print('func1 start') gevent.sleep(2) print('func1 end') def func2(): print('func2 start') gevent.sleep(1) print('func2 end') def func3(): print('func3 start') gevent.sleep(0) print('func3 end') if __name__=='__ma