深层次的进程线程的并发操作

基于socket实现的线程并发

实现方式一：

　　实现socket模块的的服务器并发效果，类似于服务器一直处于监听状态，有数据过来我就不停的接收，通过socketserver模块就可以实现。(自行了解该模块)

实现方式二：

　　利用线程。

# 服务端
# 导入相关的模块
from threading import Thread
import socket


server = socket.socket()
server.blind(('127.0.0.1'. 8080))
server.listen(5)

# 定义执行线程的函数
def task(conn):
    while True:
            try:
                 data = conn.recv(1024)
                 print(data.decode('utf-8'))
            
                 conn.send(data.upper())
            except ConnenctResetError:
                  break
    conn.close()


 
while True:
        conn,addr = server.accept()
        print(addr)
        t = Thread(target=task, args=(conn,))
        t.start()

 

# 客户端
import socket

cilent = socket.socket()
cilent.connect(('127.0.0.1', 8080))


while True:
    cmd = input('>>>>>>')
    if len(cmd) == 0:continue
    cilent.send(cmd.encode('utf-8'))

    data = cilent.recv(1024)
    print(data.decode('utf-8'))
    cilent.close()

进程池和线程池

　　首先什么是池？

　　　　池，就是池塘。装载数据的容器。

　　　　进程池：相当于在池糖里固定的有若干个水坑，并且这个水坑就是在池塘创建好的时候规定好有若干个坑。

　　　　线程池：池子里有五个线程，来几个就是执行几个。

　　使用池的优点：

　　　　1.为了减缓计算机硬件的压力，避免计算机硬件设备崩溃

　　　　2.虽然减轻了计算机硬件的压力，但是一定程度上降低了持续的效率

　　使用进程池和线程池的目的：为了开设限定个数的进程和线程数，从而保证计算机的硬件安全。

 

# 实现进程池和线程池
# 进程池和线程池抖存在相同的模块下 concurrent.futures
from concurrent.futures  import ThreadPoolExecutor, ProcessPoolExecutor 

import time


# 这里以开设线程为例，进程一样
# 开设一个池,最大数目为：5，默认最大为cpu的5倍
pool = ThreadPoolExecutor(5)


def task(n):
    print(n)
    time.sleep(3)
    return n**2


# 接收回调函数的值，并处理的函数
def answer(obj):
    print('answer is %s' %obj.result()) 


if __name__ =="__main__":
    # 创建10个线程
    for i in range(10):
         pool.submit(task,i).add_done_callback(answer)

   # 等待线程结束调用
    pool.stutdown()
    print('主')

 

协程

　　协程的由来：为了实现单线程并发的效果。

    协程:完全是我们高技术的人自己编出来的名词
         通过代码层面自己监测io自己实现切换，让操作系统误认为你这个线程没有io
    切换+保存状态就一定能够提升你程序的效率吗？不一定
         当你的任务是计算密集型，反而会降低效率
         如果你的任务是IO密集型，会提升效率

# 基于单线程实现的并发（socket）服务端
from gevent import monkey;monkey.patch_all()
from gevent import spawn
import socket


def commuciate(conn):
    while True:
        try:
            data = conn.recv(1024)
            if len(data) ==0 :break
            print(data.decode('utf-8'))

            conn.send(data.upper())
        except ConnectionResetError:
            break
    conn.close()


def server():
    server = socket.socket()
    server.bind(('127.0.0.1', 8080))
    server.listen(5)

    while True:
        conn, addr = server.accept()
        spawn(commuciate, conn)


if __name__ == '__main__':
    s1 = spawn(server)
    s1.join()

# 基于单线程实现的并发（socket）客户端
# 实现500个线程的协程
from threading import Thread
import socket

cilent = socket.socket()
cilent.connect(('127.0.0.1', 8080))


def task():
    while True:
        cilent.send(b'hello')

        data = cilent.recv(1024)
        print(data.decode('utf-8'))


if __name__ == '__main__':
    for i in range(500):
        t = Thread(target=task)
        t.start()