多进程、多线程、协程实现并发

多线程并发

# -*- coding:utf-8 -*-
# 实现理由：不让客户端去等待连接
import socket
from multiprocessing import Process


def talk(sock):
    while True:        # 写while True 的原因，可以让客户端多次发消息
        msg_IP = sock.getpeername()
        receive_msg = sock.recv(1024)
        print("from%s:%s" % (msg_IP, receive_msg.decode("gbk")))
        # send_msg = input(">>")   # 用process产生的进程不能进行输入操作
        # sock.send(send_msg.encode("gbk"))
        if len(receive_msg) == 0:
           break
    sock.close()


def main():
    # 创建监听套接字
    listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 可以重复使用端口
    listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    # 绑定地址
    address = ("192.168.133.60", 10000)
    listen_socket.bind(address)
    # 监听客户端
    listen_socket.listen(100)
    while True:
        new_socket, peer_ip = listen_socket.accept()
        # 创建一个进程
        send_msg = Process(target=talk, args=(new_socket,))
        send_msg.start()
        new_socket.close()

if __name__ == "__main__":
    main()

创建进程池解决并发

# -*- coding:utf-8 -*-
# 实现理由：不让客户端去等待连接
import socket
from multiprocessing import Process
from multiprocessing.pool import Pool


def talk(sock):
    while True:        # 写while True 的原因，可以让客户端多次发消息
        msg_IP = sock.getpeername()
        receive_msg = sock.recv(1024)
        print("from%s:%s" % (msg_IP, receive_msg.decode("gbk")))
        # send_msg = input(">>")   # 用process产生的进程不能进行输入操作
        # sock.send(send_msg.encode("gbk"))
        if len(receive_msg) == 0:
            print("%s" % (msg_IP,))
            break
    sock.close()


def main():
    # 创建监听套接字
    listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 可以重复使用端口
    listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    # 绑定地址
    address = ("192.168.133.60", 8000)
    listen_socket.bind(address)
    # 监听客户端
    listen_socket.listen(100)
    while True:
        new_socket, peer_ip = listen_socket.accept()
        # 创建一个进程
        # send_msg = Process(target=talk, args=(new_socket,))
        # send_msg.start()
        pool = Pool(1)
        pool.apply(talk, args=(new_socket,))
        new_socket.close()


# 有问题，为什么异步连不上

if __name__ == "__main__":
    main()

非阻塞单进程服务器

# -*- coding:utf-8 -*-
import socket

import time


def main():
    # 创建监听套接字
    listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 设置属性
    listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    # 将套接字设置为非堵塞
    listen_socket.setblocking(False)  # 默认为True，即为堵塞
    # 绑定地址
    address = ("192.168.133.60", 8080)
    listen_socket.bind(address)
    # 监听服务器
    listen_socket.listen(100)
    while True:
        # 循环等待客户端连接，用try捕获异常，不让报错
        try:
            new_sock, peer_name = listen_socket.accept()
        except Exception as e:
            pass
        else:
            # 需要将新的套接字保存起来
            # time.sleep(5)                        # 不写time.sleep(),会报错无法立即完成一个非阻止性套接字
            receive_msg = new_sock.recv(1024)
            print("%s:%s" % (peer_name, receive_msg.decode("gbk")))
            send_msg = input(">>")
            new_sock.send(send_msg)
if __name__ == "__main__":
    main()

多线程服务器并发

# -*- coding:utf-8 -*-
import socket
import threading
from threading import Thread


def receive(sock):
    while True:
        peer_name = sock.getpeername()
        msg = sock.recv(1024)
        print("from%s:%s" % (str(peer_name), msg.decode("gbk")))


def send_demo(sock):
    while True:
        msg = input(">>")
        sock.send(msg.encode("gbk"))


def send_msg(sock):
    recive_msg = Thread(target=receive, args=(sock,))
    send = Thread(target=send_demo, args=(sock,))
    recive_msg.start()
    send.start()


def main():
    # 创建套接字
    listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 可以重复使用端口
    listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    address = ("192.168.133.60", 10000)
    listen_socket.bind(address)
    # 监听客户端
    listen_socket.listen(100)
    while True:
        new_socket, peer_ip = listen_socket.accept()
        # 创建线程执行接收消息
        receive = Thread(target=send_msg, args=(new_socket,))
        receive.start()


if __name__ == "__main__":
    # map = threading.local()
    main()

线程局部变量传递套接字

# -*- coding:utf-8 -*-
import socket
import threading
from threading import Thread


def receive():
    sock = thread_map.name
    while True:
        peer_name = sock.getpeername()
        msg = sock.recv(1024)
        print("from%s:%s" % (str(peer_name), msg.decode("gbk")))


def send_demo():
    sock = thread_map.name
    while True:
        msg = input(">>")
        sock.send(msg.encode("gbk"))


def send_msg(sock):
    thread_map.name = sock
    recive_msg = Thread(target=receive)
    send = Thread(target=send_demo)
    recive_msg.start()
    send.start()


def main():
    # 创建套接字
    listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 可以重复使用端口
    listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    address = ("192.168.133.60", 10000)
    listen_socket.bind(address)
    # 监听客户端
    listen_socket.listen(100)
    while True:
        new_socket, peer_ip = listen_socket.accept()
        # 创建线程执行接收消息
        receive = Thread(target=send_msg, args=(new_socket,))
        receive.start()


if __name__ == "__main__":
    thread_map = threading.local()  # threading.local()创建的实例用来传接套接字是不是只能在一个线程中传递
    main()

greenlet实现协程

# -*- coding:utf-8 -*-
from greenlet import greenlet

import time


def A():
    while True:
        print("----1----")
        time.sleep(1)
        # 切换协程2运行
        gre2.switch()


def B():
    while True:
        print("----2----")
        time.sleep(1)
        gre1.switch()


def main():
    # 切换协程运行
    gre1.switch()


if __name__ == "__main__":
    gre1 = greenlet(A)
    gre2 = greenlet(B)
    main()

协程服务器

# -*- coding:utf-8 -*-
import socket

import gevent
from gevent import monkey
monkey.patch_all()


def receive_msg(socket):
    print("1")
    while True:
        receive = socket.recv(1024)
        if len(receive) > 0:
            print("from%s:%s" % (socket.getpeername(), receive.decode("gbk")))
        else:
            break
    socket.close()


def main():
    # 创建套结字
    listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    address = ("192.168.133.86", 8080)
    listen_socket.bind(address)
    listen_socket.listen(100)
    while True:
        new_socket, peer_name = listen_socket.accept()
        print(peer_name)
        print(socket.socket)
        # 创建协程,进行消息接受
        gevent.spawn(receive_msg, new_socket)


if __name__ == "__main__":
    main()

epoll服务器

# -*- coding:utf-8 -*-
import socket

import select


def main():
    # 创建一个套结字
    listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 设置属性
    listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    # 绑定地址
    address = ("192.168.133.144", 8080)
    listen_socket.bind(address)
    # 监听客户端
    listen_socket.listen(100)
    # 找一个管家
    my_epoll = select.epoll()
    # 给监听套结字装上灯
    my_epoll.register(listen_socket.fileno(), select.EPOLLIN | select.EPOLLET)
    print(select.EPOLLIN)
    print(select.EPOLLET)
    print(help(select.EPOLLET))
    # 找个字典存储监听到的套结字
    socket_dic = {}
    while True:
        # 当灯亮,有写入时,返回poll方法返回的列表
        poll_list = my_epoll.poll()
        print(poll_list)
        for fd, event in poll_list:
            if fd == listen_socket.fileno():
                print(fd)
                new_socket, peer_name = listen_socket.accept()
                # 让管家给新的套结字安个灯
                my_epoll.register(new_socket.fileno(), select.EPOLLIN | select.EPOLLET)
                # 将产生的新套结字放到字典中,以新产生套结字的文件下标为KEy
                socket_dic[new_socket.fileno()] = new_socket
                # print(new_socket.fileno())
                print(poll_list)
            else:
                use_socket = socket_dic[fd]
                print(poll_list)
                recv_msg = use_socket.recv(1024)
                if len(recv_msg) > 0:
                    print("from %s :%s " % (use_socket.getpeername(), recv_msg.decode("gbk")))
                else:
                    # 注释掉灯
                    my_epoll.unregister(fd)
                    print(fd)
                    # 从子典中删掉这个套结字
                    del socket_dic[fd]
                    use_socket.close()




if __name__ == "__main__":
    main()