Python socket、multiprocessing和threading模块的使用

1.socket

Python用socket模块可以实现简单的网络通信

1.1创建客户端

import socket


def client_socket():
    # 定义客户端
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 设置服务端和ip
    client.connect(('localhost', 8888))
    # 设置发送到服务端数据
    msg = '我是客户端'
    client.send(msg.encode(encoding='utf-8'))
    # 接收服务端数据
    recv_data = client.recv(1024)
    print('收到服务端数据:', recv_data.decode(), '\n')

    client.close()


if __name__ == '__main__':
    # 运行客户端
    client_socket()

1.2创建服务端：

import socket


def server_socket():
    # 创建服务端
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 绑定客户端ip和端口
    server.bind(('localhost', 8888))
    # 设置监听大小
    server.listen(10)
    print('服务器开始监听')
    # 阻塞至客户端 取得消息
    conn, ip_port = server.accept()
    # 设置消息大小
    recv_data = conn.recv(1024)
    print(f'收到客户端{ip_port}', recv_data.decode(), '\n')
    # 发送到客户端消息
    msg = '我是服务端'
    conn.send(msg.encode())
    # 关闭资源
    conn.close()


if __name__ == '__main__':
    # 运行服务端
    server_socket()

1.3运行测试： 首先运行服务端：

再运行客户端，接收到已经运行的服务端数据：

最后查看服务端数据：

2.multiprocessing

Python可以用multiprocessing实现多进程

import multiprocessing
import time


def process_1():
    for i in range(5):
        print(f'进程1运行：{i}次；')
        time.sleep(0.1)  # 模拟进程运行时间


def process_2(name):
    for i in range(5):
        print(f'{name}进程2运行：{i}次；')
        time.sleep(0.1)  # 模拟进程运行时间


def process_3():
    for i in range(5):
        print(f'进程3运行：{i}次；')
        time.sleep(0.1)  # 模拟进程运行时间


if __name__ == '__main__':
    # 开启守护进程
    p1 = multiprocessing.Process(target=process_1, daemon=True)
    # 传参
    p2 = multiprocessing.Process(target=process_2, args=('小明',))
    # 不开启守护进程
    p3 = multiprocessing.Process(target=process_3)

    p1.start()
    p2.start()
    p3.start()

    time.sleep(0.3)
    print('主进程结束！进程1一起结束。')

注意： 1.target=函数名，而不是target=函数名(); 2.在子进程创建进程可能会导致无限创建进程，要在main进程中创建进程。 测试结果：

3.threading

Python可以用threading实现多线程

import threading
import time


def thread_1():
    for i in range(5):
        print(f'线程1运行：{i}次；')
        time.sleep(0.1)  # 模拟线程运行时间


def thread_2(name):
    for i in range(5):
        print(f'{name}线程2运行：{i}次；')
        time.sleep(0.1)  # 模拟线程运行时间


def thread_3():
    for i in range(5):
        print(f'线程3运行：{i}次；')
        time.sleep(0.1)  # 模拟线程运行时间


if __name__ == '__main__':
    # 开启守护线程
    p1 = threading.Thread(target=thread_1, daemon=True)
    # 传参
    p2 = threading.Thread(target=thread_2, args=('小明',))
    # 不开启守护线程
    p3 = threading.Thread(target=thread_3)

    p1.start()
    p2.start()
    p3.start()

    time.sleep(0.3)
    print('主线程结束！线程1一起结束。')

测试结果：

进程和线程的区别：

进程：

1. 进程占用内存相对多
2. 进程里默认有一个线程
3. 进程间数据不共享
4. 进程可以使用多个cpu运行

线程：

1. 线程占用资源相对少
2. 一个线程必须依赖一个进程运行
3. 线程间的全局变量共享
4. 线程只能用一个cpu来回切换运行