python multiprocessing 和tcp

#用类方法  服务端

from socket import *
from multiprocessing import Process
import os


class Myprocess(Process):
    def __init__(self, conn):
        self.conn = conn
        super().__init__()

    def run(self):
        conn = self.conn
        start = True
        while start:
            try:
                print('启动子线程:%s' % os.getpid(), end='')
                data = conn.recv(1024)

                conn.send(data)
                print('线程编号:%s,data=%s' % (os.getpid(), data.decode('utf-8')))
            except Exception as e:
                conn.close()
                start = False
                print('关闭了')
                conn.close()


if __name__ == '__main__':
    # p=Myprocess('这是测试文件')
    # p.start()

    st = socket(AF_INET, SOCK_STREAM)
    host = '127.0.0.1'
    port = 8080
    listen_number = 5
    st.bind((host, port))
    st.listen(listen_number)
    transcript = None
    while True:
        print('等待连接')
        conn, _ = st.accept()
        if conn != transcript:
            transcript = conn
            p = Myprocess(conn)
            p.start()
            print('连接成功')
        else:
            print('不知道:%s' % conn)

    st.close()


#用函数方法 服务端

from multiprocessing import Process
from socket import *
import json, struct

import os


def process_communication(conn):
    while True:
        try:
            print('启动子线程:%s' % os.getpid(), end='')
            data = conn.recv(1024)
            conn.send(data)
            print('线程编号:%s,data=%s' % (os.getpid(), data.decode('utf-8')))
        except Exception:
            conn.close()
            print('关闭了')
            break


if __name__ == '__main__':

    st = socket(AF_INET, SOCK_STREAM)
    host = '127.0.0.1'
    port = 8080
    listen_number = 5
    st.bind((host, port))
    st.listen(listen_number)
    transcript = None
    while True:
        print('等待连接')
        conn, _ = st.accept()
        if conn != transcript:
            transcript = conn
            p = Process(target=process_communication, args=(conn,))
            p.start()
            #p.join()
            print('连接成功')
        else:
            print('不知道:%s' % conn)

    st.close()


#客户端

from socket import *

st = socket(AF_INET, SOCK_STREAM)
host = '127.0.0.1'
port = 8080
st.connect((host, port))
while True:

    msg = input('请输入:').strip()
    if not len(msg):
        continue

    st.send(msg.encode(encoding = 'utf-8'))
    data=st.recv(1024)
    print(data.decode(encoding='utf-8'))

st.close()

(现代操作系统)书 egon老师推荐


开启线程方式一：
import multiprocessing
from multiprocesssing import Process



def task(name):
    print('%s is runings'%name)
    time.sleep(3)
    print('%s is done'%name)
group#保留参数 无用
target#任务名




#如果只有一个参数一定记住加 逗号(，)
#Process(target=task,kwargs={'name':'子进程'})

if __name__=='__main__':
    p=Process(target=task,args=('子进程'，))
    p.start()#windows系统倒模块的方式，把父进程加载进去
             #linux 其实不用放入main下面的，
             #但是为了兼容liunx和windows系统 所以全部加吧
    #可以自定义函数名

    #主进程会等待子进程结束后才会结束


    p.start()#只是在操作系统发送一个开启子进程的信号
    #p.start只是发送信号(这步速度非常快)
    #申请内存空间，开辟个名称空间，在将父进程的数据复制一份到这个内存空间中
    #至于开启的时间，开启的方式都是操作系统说的算





class Myprocess(Process):
    def __init__(self,x):
        super().__init__()
        self.name=x
    def run(self):
        self.name#进程名称


if __name__=='__main__':
    p=Myprocess('测试')
    p.start()#等同于p.run()#自定义类必须实现run()方法

import time
x='tiankong'
def task():
    global x
    x=0
    print('done')
    print(x)


if __name__ == '__main__':
    p=Process(target=task)
    p.start()
    time.sleep(5)#让父进程等待5秒，让子进程运行完闭后，才执行下一行代码
    print(x)       #但是子进程不一定5秒就能运行完。、


    #进程间内存隔离

from multiprocessing import  Process
import time,os
def task(name,n):
    print('name is :%s'%name)
    time.sleep(3)
    print('子进程pid%s'%os.getpid())
    print(n)
    print('end')


if __name__ == '__main__':
    p=Process(target=task,args=('子进程',('这里可以给子进程传参')))
    p.start()
    p.pid#父进程查看 子进程的pid方式

    p.join()#让父进程在原地等待，等到子进程运行完毕后，才执行下一行代码
    #本质和time.sleep()一样但是等待时间不用手动输入了
    print('主进程')



def walk():
    print('walk:%s'%os.getpid())
    time.sleep(12)

if __name__ == '__main__':
    p=Process(target=walk)
    p.start()
    p.is_alive()#只要信号发出，就认为这个子线程是活着
    print('父进程:%s'%os.getpid())
    p.join()#自动回收僵尸进程
　　　　　　　#让父进程进入等待状态
    p.terminate()#给操作系统发送信号，杀死这个子进程


#杀死进程taskkill /F /PID  进程号
#liunx 中孤儿进程 父进程会变成 init

转载于:https://www.cnblogs.com/yanxiatingyu/p/9295187.html