線程不能同時運行。 （蟒蛇）

Question

在使用線程模塊的Python中，我的程序不會同時運行我創建的2個線程。 我正在嘗試使用P2P創建即時消息程序，但我不知道問題是否出在套接字模塊上，或者我做錯了什么。 碼：

import socket
import threading

class Receiver:
    def __init__(self):

        # Create socket that supports IPv4, TCP Protocol
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        print "Socket created."
        # Requests for IP of host (DNS)
        dns = "localhost"
        HOST = ''
        PORT = 57492
        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        s.bind((HOST, PORT)) # Listens on all interfaces...
        print 'Listening on port 25565'
        s.listen(True) # Listen on the newly created socket... 
        conn, addr = s.accept()
        print 'Connected in port 25565'
        global data
        while 1:
            data = conn.recv(1024)
            print data
        s.close()

    def Sender(self):

        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        dns = "localhost"
        HOST = socket.gethostbyname(dns)
        PORT = 57492    
        # Connect to server
        s.connect((HOST, PORT))

        print "Socket connected to " + dns + " on IP " + HOST

        while 1:

            # Assign message to be sent to server to a variable
            message = raw_input("Message to be sent to server: ")

            #Send the actual message to server
            s.sendall(message)
        print "Message sent successfully"
        s.close()
    def go(self):

        th1 = threading.Thread()
        th2 = threading.Thread(target=self.Sender)
        th1.start()
        th2.start()

t = Receiver()
t.go()

Answer 1

這里有兩個問題。 首先，永遠不會為th1提供執行方法，因此，當您對其調用start時，線程將不執行任何操作並立即退出。 第二個問題是您正在Receiver類的構造函數中執行永久性工作（無限while循環）。 這意味着t = Receiver()行將（基本上）永遠不會返回，並且您永遠也不會調用go() 。

這是一個示例，其中刪除了所有套接字內容，介紹了如何在已設置的基本框架中啟動兩個線程：

#!/usr/bin/python

import threading
import time
import signal

class Communicator:
    def __init__(self):
        self.__stop = False

    def __runSender(self):
        # setup sender here
        while not self.__stop:
            # run sender loop here
            print "in sender"
            time.sleep(1)
        print "stopped sender"

    def __runReceiver(self):
        # setup receiver here
        while not self.__stop:
            # run recevier loop here
            print "in receiver"
            time.sleep(1)
        print "stopped receiver"

    def start(self):
        senderThread = threading.Thread(target=self.__runSender)
        receiverThread = threading.Thread(target=self.__runReceiver)
        senderThread.start()
        receiverThread.start()
    def stop(self):
        self.__stop = True


c = Communicator()

def handleKill(n, frame):
    print "HANDLING SIGNAL"
    c.stop()

signal.signal(signal.SIGINT, handleKill)
print "Starting communication, hit CTRL-c to stop"
c.start()
signal.pause()

Answer 2

Sender和go方法沒有縮進，因此不是Receiver的一部分，這意味着當您定義th2 ，沒有self.Sender 。

Answer 3

這些行：

th1 = threading.Thread()
th2 = threading.Thread(target=self.Sender)

th1沒有要運行的操作。

另一個值得關注的問題是，您有一個全局變量data ，並且如果您確實打算多次運行整個類，則您的多個線程可能會破壞該變量並給您帶來垃圾結果。 或者，您是否打算同時運行Sender和Receiver ？ 您所擁有的答案可能是傳遞th1作為target=self的參數，但這似乎是運行線程化應用程序（線程內的線程？）的一種糟糕方法。

如果是后者，則最好將Sender和Receiver分成單獨的方法，並設置線程以將這些單獨的方法作為目標：

class Conversation:
    def __init__(self):
        pass

    def receiver(self):
        ...code code code...

    def sender(self):
        ...code code code...

    def go(self):

        th1 = threading.Thread(target=self.receiver)
        th2 = threading.Thread(target=self.render)
        th1.start()
        th2.start()

我不知道這是否可以完全解決您的問題，但這只是一個開始：它可以使th1有所作為。

我還認為您還需要一些線程安全的方法來告知循環結束。

最后，請記住，您將無法使用當前的代碼安全地在這些線程之間來回傳遞數據（如果這是您的意圖）。