9）网络并发 编程、进程、线程和协程

并发网络

Server：

#!/usr/bin/env python
#-*-conding:utf-8-*-
import socket
sk = socket.socket()
sk.bind(('127.0.0.1',9009))
sk.listen()
conn,addr = sk.accept()
conn.send(b'heooo')
msg = conn.recv(1024)
print(msg)
conn.close()
sk.close()

Client：

#!/usr/bin/env python
#-*-conding:utf-8-*-
import socket
sk = socket.socket()
sk.connect(('127.0.0.1',9009))
print(sk.recv(1024))
sk.send(b'busdf')
sk.close()

socketserver并发的模块

模块：

#!/usr/bin/env python
#-*-conding:utf-8-*-
import socketserver
class Myserver(socketserver.BaseRequestHandler):
    def handle(self):
        conn = self.request
        print(conn)
myserver = socketserver.ThreadingTCPServer(('127.0.0.1',9988),Myserver)
myserver.serve_forever()

Server端：

Client端：

 

 

并发编程：

一个程序在同一时刻做多件事情

基于多道批处理系统和分时系统

解决程序中IO操作影响程序的效率问题

多个程序、作业在遇到IO操作的时候，操作系统会帮助你进行切换

让cpu的利用率得到最大的提高

操作系统 只负责管理调度进程

什么叫进程：

运行中的程序：

进程：是操作系统总资源分配的最小单位

每一个运行中的程序都需要有自己的内存、资源

都分配给进程  纪录执行的状态 管理自己的内存资源

import os,time
print(os.getpid())
time.sleep(1000)

Multiprocess模块（包）异步执行，就是两个程序一起执行

import os

import time
from  multiprocessing import Process
def lxf(*args):
    print(args,os.getpid())
    time.sleep(2)

if __name__=='__main__':
    print(os.getpid())
    p = Process(target=lxf,args=(12,10,))
    p.start()
    print(os.getpid())

import os
import time
from  multiprocessing import Process
def func(num):
    print(num,os.getpid())
    time.sleep(10)
if __name__=='__main__':
    print(os.getpid())
    p = Process(target=func,args=(10,))
    p.start()
    print(os.getpid())

import os
import time
from multiprocessing import Process
def func(num):
    print(num,os.getpid())
    time.sleep(0.5)
    print(num,os.getpid())
    time.sleep(0.5)
    print(num,os.getpid())
    time.sleep(0.5)
    print(num,os.getpid())

if __name__ =='__main__':
    print(os.getpid())
    p = Process(target=func,args=(10,))
    p.start()
    print(os.getpid())
    time.sleep(1)
    print(os.getpid(),1)
    time.sleep(1)
    print(os.getpid(),2)

什么是进程： 运行中的程序，计算机中最小的资源分配单位

程序开始执行就会产生一个主进程

Python中可以主进程中用代码启动一个进程----------------子进程

同时主进程也呗称为父进程

父子进程之间的代码执行是一步的，各自执行自己的

父子进程之间的数据是不可以共享

from  multiprocessing import Process
import time
n = 100
def func():
    global n
    n = 0
    print('&&&&')

if __name__ =='__main__':
    Process(target=func).start()
    time.sleep(1)
    print(n)

开启多个子进程：

from multiprocessing import Process
import time
def func(n):
    time.sleep(1)
    print('_&*'*n)

if __name__=='__main__':
    Process(target=func,args=(1,)).start()
    Process(target=func, args=(2,)).start()
    Process(target=func, args=(3,)).start()

开启10个进程去发邮件：

from multiprocessing import Process
import time
def func(n):
    time.sleep(1)
    print('-' * n)
if __name__ == '__main__':
    for i in range(10):
        p = Process(target=func, args=(1,))
        p.start()
    print('子进程开始了')
    p.join()
    print('十条信息发送完了')

完善10条短信发送：

import os
import time
from  multiprocessing import Process
def func(n):
    time.sleep(1)
    print('&'*n)

if __name__=='__main__':
    l = []
    for i in range(10):
        p = Process(target=func,args=(i,))
        p.start()
        l.append(p)
    for p in l:
        p.join()
    print('发完了10条短信')

守护进程：也是一个子进程

当主进程的代码执行完毕之后会自动结束的子进程交做守护进程

import time
from multiprocessing import Process
def deamon_func():
    while True:
        print('活着真好')
        time.sleep(0.5)

if __name__=='__main__':
    p = Process(target=deamon_func)
    p.daemon = True
    p.start()
    for i in range(3):
        print(i*'*')
        time.sleep(1)

、

守护进程

守护进程也是一个子进程

当主进程的代码执行完毕之后自动结束的子进程叫做守护进程

如果要在主进程当中要等待子进程结束之后在执行某段代码：join方法

如果有多个子进程，不能在start一个进程之后就立刻join，吧所有的进程放到列表中，等待所有进程都start之后在逐一join

import os
import time
from  multiprocessing import Process
def daemon_func():
    while True:
        print('活着真好呀')
        time.sleep(0.5)

def wahaha():
    for i in range(10):
        time.sleep(1)
        print(i * '#')
if __name__=='__main__':
    Process(target=wahaha).start()
    p = Process(target=daemon_func)
    p.daemon = True
    p.start()
    for i in range(3):
        print(i*'*')
        time.sleep(1)

锁：

例子：

import os
import time
import random
from  multiprocessing import Process

def work(n):
    print('%s:%s is runing' %(n,os.getpid()))
    time.sleep(random.random())
    print('%s:%s is done'%(n,os.getpid()))

if __name__=='__main__':
    for i in range(3):
        p = Process(target=work,args=(1,))
        p.start()

改进一下：使用锁：

import os
import time
import random
from  multiprocessing import Process,Lock

def work(n,lock):
    lock.acquire()
    print('%s:%s is runing' %(n,os.getpid()))
    time.sleep(random.random())
    print('%s:%s is done'%(n,os.getpid()))
    lock.release()
if __name__=='__main__':
    lock = Lock()
    for i in range(3):
        p = Process(target=work,args=(1,lock))
        p.start()

抢火车票：使用锁：牺牲效率，但是保证安全

from multiprocessing import Process,Lock
import time,json,random
def search():
    dic = json.load(open('db'))
    print('\033[43m剩余票数%s\033[0m'%dic['count'])
def get(num):
    dic=json.load(open('db'))
    time.sleep(random.random())
    if dic['count'] >0:
        dic['count']-=1
        time.sleep(0.2)
        json.dump(dic,open('db','w'))
        print('\033[43m%s购票成功\033[0m'%num)

def task(num,lock):
    search()
    lock.acquire()
    get(num)
    lock.release()

if __name__=='__main__':
    lock = Lock()
    for i in range(10):
        p = Process(target=task,args=(i,lock))
        p.start()

信号量：

#!/usr/bin/env python
#-*-conding:utf-8 -*-
from multiprocessing import Semaphore
sem = Semaphore(5)
sem.acquire()
print(1)
sem.acquire()
print(2)
sem.acquire()
print(3)
sem.acquire()
print(4)
sem.acquire()
print(5)  #到这里就卡住了
sem.acquire()
print(6)
sem.acquire()
print(7)

#!/usr/bin/env python
#-*-conding:utf-8 -*-
from multiprocessing import Process,Semaphore
import time,random
def go_ktv(sem,user):
    sem.acquire()
    print('%s 占到了一间KTV包间'%(user))
    time.sleep(random.randint(3,5))# 模拟每个人在里面呆的时间不同
    sem.release()
    print('%s 走出KTV包间' % (user))
if __name__=='__main__':
    sem = Semaphore(4)
    p_l=[]
    for i in range(13):
        p = Process(target=go_ktv,args=(sem,'user%s'%i,))
        p.start()
        p_l.append(p)
    for i in p_l:
        i.join()
    print('========>')

事件：

内部内置了一个标志

Wait 方法 如果这个标志是True 那么wait == pass

Wait 方法 如果这个标志是False 那么wait 会陷入阻塞，一直阻塞到标志从False变成True

一个时间在创建之初 内部的标志默认是False

红绿灯

队列：Queue：

自己人为的去传输的结果的东西

import os
import time
from  multiprocessing import Queue,Process
def func(n,q):
    q.put(n*n)

if __name__=='__main__':
    q = Queue()
    Process(target=func,args=(100,q,)).start()
    print(q.get())

管道+锁 ==队列

管道也是一个可以实现进程之间通信的模型

但是管道没有锁，数据不安全

数据共享：

 

线程：

启动线程：

import os
import time
from  threading import Thread
def func(i):
    print(os.getpid())
    time.sleep(1)
    print('thread%s'%i)

Thread(target=func,args=(1,)).start()
print(10*'*')
print('main:',os.getpid())

线程之间的数据是共享的：

实现线程之间并发：

GIL锁  全局解释器锁：

是cpython解释器的问题

在同一个进程中 同一时刻  只能有一个线程呗cpu执行

导致高计算型， 代码 不适合用python的多线程来解决

用多进程或者分布式来解决高计算型代码

 

 

守护线程：

 

线程锁

 

 

 

池的概念：

线程池：

import time
from concurrent.futures import ThreadPoolExecutor
def func(num):
    time.sleep(5)
    print(num)

t = ThreadPoolExecutor(20)
for i in range(100):
    t.submit(func,i)

t.shutdown()  #join 整个池子

print(3333335555)

协程：

原文地址：http://blog.51cto.com/xiaorenwutest/2130482

时间： 2024-08-02 09:41:39

9）网络并发 编程、进程、线程和协程的相关文章

帮你搞懂Python进程,线程与协程

本文参考原文-http://bjbsair.com/2020-03-22/tech-info/4425/在操作系统中,每一个独立运行的程序,都占有 操作系统 分配的资源,这些程序中间互不干涉,都只负责运行自己的程序代码,这就是进程. 但是当操作系统频繁的创建销毁进程时,大量的系统资源被浪费在创建和销毁的过程中.而随着多核心 cpu 的出现,线程也逐渐代替了进程,成为了操作系统 可以独立运行的基本单位. 当进程不是多线程程序时,存在于进程当中的唯一线程,便是进程本身运行的代码块. 而当多线程出现在

Python并发编程-进程 线程 协程

一.进程 进程:就是一个程序在一个数据集上的一次动态执行过程. 进程由三部分组成: 1.程序:我们编写的程序用来描述进程要完成哪些功能以及如何完成 2.数据集:数据集则是程序在执行过程中所需要使用的资源 3.进程控制块:进程控制块用来记录进程的外部特征,描述进程的执行变化过程,系统可以利用它来控制和管理进程,它是系统感 知进程存在的唯一标志. 二.线程                                                                        

python 并发编程 基于gevent模块 协程池 实现并发的套接字通信

基于协程池 实现并发的套接字通信 客户端: from socket import * client = socket(AF_INET, SOCK_STREAM) client.connect(('127.0.0.1', 8080)) while True: msg = input(">>>:").strip() if not msg:break client.send(msg.encode("utf-8")) data = client.recv(

Python并发编程(线程队列,协程,Greenlet,Gevent)

线程队列 线程之间的通信我们列表行不行呢,当然行,那么队列和列表有什么区别呢? queue队列 :使用import queue,用法与进程Queue一样 queue is especially useful in threaded programming when information must be exchanged safely between multiple threads. class queue.Queue(maxsize=0) #先进先出 import queue #不需要通过

Python 中的进程、线程、协程、同步、异步、回调

进程和线程究竟是什么东西?传统网络服务模型是如何工作的?协程和线程的关系和区别有哪些?IO过程在什么时间发生? 在刚刚结束的 PyCon2014 上海站,来自七牛云存储的 Python 高级工程师许智翔带来了关于 Python 的分享<Python中的进程.线程.协程.同步.异步.回调>. 一.上下文切换技术 简述 在进一步之前,让我们先回顾一下各种上下文切换技术. 不过首先说明一点术语.当我们说"上下文"的时候,指的是程序在执行中的一个状态.通常我们会用调用栈来表示这个状

进程、线程和协程的理解-自己随笔

1. IO 操作不占用CPU(从硬盘读数据,从网络读数据,从内存读取数据) 计算占用CPU,例如1+1=2的计算就是占用CPU的. python 多线程,不适合CPU密集操作系统的任务,适合IO操作密集型的任务. 2. 进程.线程和协程之间的关系和区别也困扰我一阵子了,最近有一些心得,写一下. 进程拥有自己独立的堆和栈,既不共享堆,亦不共享栈,进程由操作系统调度. 线程拥有自己独立的栈和共享的堆,共享堆,不共享栈,线程亦由操作系统调度(标准线程是的). 协程和线程一样共享堆,不共享栈,协程由程序

Python之进程、线程、协程篇

本章内容: 线程(线程锁.threading.Event.queue 队列.生产者消费者模型.自定义线程池) 进程(数据共享.进程池) 协程 线程 Threading用于提供线程相关的操作.线程是应用程序中工作的最小单元,它被包含在进程之中,是进程中的实际运作单位.一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务. threading 模块建立在 _thread 模块之上.thread 模块以低级.原始的方式来处理和控制线程,而 threading

Python（八）进程、线程、协程篇

本章内容: 线程(线程锁.threading.Event.queue 队列.生产者消费者模型.自定义线程池) 进程(数据共享.进程池) 协程 线程 Threading用于提供线程相关的操作.线程是应用程序中工作的最小单元,它被包含在进程之中,是进程中的实际运作单位.一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务. threading 模块建立在 _thread 模块之上.thread 模块以低级.原始的方式来处理和控制线程,而 threading

Day9 - 进程、线程、协程篇（二）

本节内容 Gevent协程 Select\Poll\Epoll异步IO与事件驱动 Python连接Mysql数据库操作 RabbitMQ队列 Redis\Memcached缓存 Paramiko SSH Twsited网络框架 协程(单线程下实现多并发的效果) 协程,又称微线程,纤程.英文名Coroutine.一句话说明什么是线程:协程是一种用户态的轻量级线程.(CPU不认识协程,是用户自己操作的) 协程拥有自己的寄存器上下文和栈.协程调度切换时,将寄存器上下文和栈保存到其他地方,在切回来的时候

Python之路（十八）：进程，线程，协程

python基础之进程.线程.协程 引子 进程 线程(优先阅读) 协程 进程 概念:就是一个程序在一个数据集上的一次动态执行过程(本质上来讲,就是运行中的程序(代指运行过程),程序不运行就不是进程)    抽象概念 组成:  1.程序:我们编写的程序用来描述进程要完成哪些功能以及如何完成  2.数据集:数据集则是程序在执行过程中所需要使用的资源  3.进程控制块:进程控制块用来记录进程的外部特征,描述进程的执行变化过程,系统可以利用它来控制和管理进程,它是系统感知进程存在的唯一标志. 阐释:进程