Несколько процессов в Python

import socket
import sys
import os
import time
import multiprocessing
 
 
class TcpFileTransfer(multiprocessing.Process):
 
        download_started = False
        download_finished = False
        filename = None
        connected = False
 
        def __init__(self, queue, value):
                super(TcpFileTransfer, self).__init__()
                self.queue = queue
                self.fullsize = 0
                self.sent = 0
                self.value = value
                self.conn = None
                self.interrupted = False
 
        def set_socket(self, conn, addr):
                print("There is a socket in #" + str(self.value))
                self.conn = conn
                self.address = addr
 
        def dispose(self):
                self.interrupted = False
                self.download_finished = True
                self.sent = 0
                self.fullsize = 0
                self.conn.close()
 
        def download(self, snddata = None):
                if not self.download_started:
                        if snddata.endswith("continue"):
                                list_of_params = snddata.split(" ")
                                self.filename = list_of_params[1].strip()
                                print(self.filename)
                                self.sent = int(list_of_params[2])
                                self.interrupted = True
                        else:
                                self.filename = snddata[8:].strip()
 
                        if os.path.exists(self.filename):
                                self.download_started = True
                                print("Start to download " + self.filename + " from server")
                                self.fullsize = os.path.getsize(self.filename)
                        else:
                                print("File doesn't exist")
                                return False
 
                with open(self.filename,'rb') as f:
                        self.conn.settimeout(2.0)
                        f.read(self.sent)
                        try:
                                bytes_to_send = f.read(1024)
                                if bytes_to_send:
                                        self.conn.send(bytes_to_send)
                                        self.sent += 1024
                                        return True
                                else:
                                        print("Downloaded " + self.filename)
                                        self.dispose()
                        except socket.error:
                                print("Error")
                                self.interrupted = True
                                self.conn.close()
                                return False
 
        def data_recieving(self):
                self.conn.setblocking(0)
                try:
                        data = self.conn.recv(1024).decode("utf-8")
                        self.conn.setblocking(1)
                        return data
                except socket.error:
                        return None
 
        def run(self):
                self.queue.put(self.tcp_loop())
 
        def tcp_loop(self):
                #global lock
                #lock.acquire()
                while True:
                        #print("In process #" + str(self.value))
                        if self.conn != None:
                                print("I'm trying to work #" + str(self.value))
                                if not self.download_started:
                                        data = self.data_recieving()
                                        if data:
                                                print(data)
                                                if data == "Quit":
                                                        self.conn.close()
                                                        return False
                                                elif data == "Time":
                                                        localtime = str(time.asctime(time.localtime(time.time())))
                                                        self.conn.send(localtime.encode("utf-8"))
                                                elif data.startswith("echo"):
                                                        data = data[4:]
                                                        print(data)
                                                        self.conn.send(data.strip().encode("utf-8"))
                                                elif data.startswith("download"):
                                                        self.download(data)
                                                else:
                                                        print("Unrecognised command")
                                elif self.download_finished:
                                                        return False
                                else:
                                        print("Resuming" + str(self.address))
                                        self.download()
 
 
def nonbloking_connection(s):
        s.setblocking(0)
        try:
                conn, addr = s.accept()
                print("Accepted")
                return conn, addr
        except (socket.timeout, BlockingIOError):
                return None, None
 
 
#Main
if __name__ == "__main__":
        if len(sys.argv) < 1:
                print("Error. Missing param")
                sys.exit(-1)
 
port = sys.argv[1]
 
s = socket.socket()
isCorrect = True
 
try:
        s.bind(("localhost", 4000))
        print("Bind done")
except:
        print("Bind Error")
        isCorrect = False
 
if isCorrect:
        threads = []
        q = multiprocessing.Queue()
        for i in range(5):
               proc = TcpFileTransfer(q, i)
               threads.append(proc)
               proc.start()
 
        number_of_clients = 0
        s.listen(5)
        while True:
                conn, addr = nonbloking_connection(s)
                #print("In main")
                if conn:
                       print("Added " + str(addr))
                       print("Accepted")
                       threads[number_of_clients].set_socket(conn, addr)
                       number_of_clients += 1