python主线程主动杀死子线程_Python：如何在多线程中发送数据包，然后线程杀死自己...

I have a question. I'd like to send a continuous streams of byte to some host for certain amount of time (let's say 1 minute) using python.

Here is my code so far:

#! /usr/bin/env python

import socket

import thread

import time

IP = "192.168.0.2"

PADDING = "a" * 1000 #assume the MTU is slighly above 1000

DATA = PADDING + "this is sentence number = "

PORT = 14444

killed = False

test_time = 60 #60 seconds of testing

def send_data():

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.connect((IP, PORT))

count = 1

starttime = time.clock()

while elapsed < test_time:

sent = s.send(DATA + str(count) + "\n")

if sent == 0: break # assume that if nothing is sent -> connection died

count = count+1

elapsed = time.clock() - starttime

if killed:

break

s.close()

print str(count) + " has been sent"

print "to quit type quit"

thread.start_new_thread(send_data, ())

while True:

var = raw_input("Enter something: ")

if var == "quit":

killed = True

Few question, is there a better way to let a thread die after 60 seconds other than polling the time.clock every time?

When I run this program, it sends the bytes correctly but when I typed quit the other thread won't die, even though I set the var killed = True. I wonder why is that? the scope of var Killed should reach the other thread right?

Thanks

解决方案

I recommned using threading module. Even more benefit is to use InterruptableThread for terminating the thread. You do not have to use flag for terminating your thread but exception will occur if you call terminate() on this thread from parent. You can handle exception or not.

import threading, ctypes

class InterruptableThread(threading.Thread):

@classmethod

def _async_raise(cls, tid, excobj):

res = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, ctypes.py_object(excobj))

if res == 0:

raise ValueError("nonexistent thread id")

elif res > 1:

ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, 0)

raise SystemError("PyThreadState_SetAsyncExc failed")

def raise_exc(self, excobj):

assert self.isAlive(), "thread must be started"

for tid, tobj in threading._active.items():

if tobj is self:

self._async_raise(tid, excobj)

return

def terminate(self):

self.raise_exc(SystemExit)

EDIT:

You can rewrite your code like this using another thread that is waiting 1 minute and then killing your other thread

def send_data:

IP = ...

# other vars

...

s = socket.socket(.....)

# no killed checking

# no time checking

# just do your work here

...

s.close()

my_thread = InterruptableThread(target=send_data)

my_thread.start()

def one_minute_kill(who):

time.sleep(60)

who.terminate()

killer_thread = InterruptableThread(target=one_minute_kill, args=[my_thread])

killer.start()

print "to quit type quit"

while my_thread.isAlive():

if raw_input("Enter something: ") == "quit":

my_thread.terminate()