pythontk多线程,使用Tkinter的多线程python

I'm drawing little circles on a canvas with these functions :

This is the function that will draw the circles :

class Fourmis:

def __init__(self, can, posx, posy, name, radius):

self.can = can

self.largeur_can = int(self.can.cget("width"))

self.hauteur_can = int(self.can.cget("height"))

self.posx = posx

self.posy = posy

self.name = name

self.radius = radius

self.ball1 = self.can.create_oval(self.posy, self.posx, self.posy+radius, self.posx+radius, outline=self.name, fill=self.name, width=2)

self.nx = randrange(-10,10,1)

self.nx /= 2.0

self.ny = randrange(-10,10,1)

self.ny /= 2.0

#self.can.bind("", self.destruction, add="+")

self.statut = True

self.move()

def move(self):

if self.statut == True :

self.pos_ball = self.can.coords(self.ball1)

self.posx_ball = self.pos_ball[0]

self.posy_ball = self.pos_ball[1]

if self.posx_ball < 0 or (self.posx_ball + self.radius) > self.largeur_can:

self.nx = -self.nx

if self.posy_ball < 0 or (self.posy_ball + self.radius) > self.hauteur_can:

self.ny = -self.ny

self.can.move(self.ball1, self.nx, self.ny)

self.can.after(10, self.move)

this one creates the canvas and the circles :

class App(Frame):

def __init__(self):

self.root=Tk()

self.can=Canvas(self.root,width=800,height=600,bg="black")

self.can.pack()

self.create(50, "green")

self.create(50, "purple")

def mainloop(self):

self.root.mainloop()

def create(self, i, name):

for x in range(i):

self.x=Fourmis(self.can,100,400, name,0)

I call these lines to run the project :

jeu = App()

jeu.mainloop()

What is the correct way to execute self.create(50, "green") and self.create(50, "purple") in different threads?

I have tried the following, but could not get it to work.:

class FuncThread(threading.Thread):

def __init__(self, i, name):

self.i = i

self.name = name

threading.Thread.__init__(self)

def run(self):

App.create(self, self.i, self.name)

Is someone able to tell me how to run these threads?

解决方案

When this functionality is needed, what you do is schedule the events you wish to perform by putting them in a queue shared by the threads. This way, in a given thread you specify that you want to run "create(50, ...)" by queueing it, and the main thread dequeue the event and perform it.

Here is a basic example for creating moving balls in a second thread:

import threading

import Queue

import random

import math

import time

import Tkinter

random.seed(0)

class App:

def __init__(self, queue, width=400, height=300):

self.width, self.height = width, height

self.canvas = Tkinter.Canvas(width=width, height=height, bg='black')

self.canvas.pack(fill='none', expand=False)

self._oid = []

self.canvas.after(10, self.move)

self.queue = queue

self.canvas.after(50, self.check_queue)

def check_queue(self):

try:

x, y, rad, outline = self.queue.get(block=False)

except Queue.Empty:

pass

else:

self.create_moving_ball(x, y, rad, outline)

self.canvas.after(50, self.check_queue)

def move(self):

width, height = self.width, self.height

for i, (oid, r, angle, speed, (x, y)) in enumerate(self._oid):

sx, sy = speed

dx = sx * math.cos(angle)

dy = sy * math.sin(angle)

if y + dy + r> height or y + dy - r < 0:

sy = -sy

self._oid[i][3] = (sx, sy)

if x + dx + r > width or x + dx - r < 0:

sx = -sx

self._oid[i][3] = (sx, sy)

nx, ny = x + dx, y + dy

self._oid[i][-1] = (nx, ny)

self.canvas.move(oid, dx, dy)

self.canvas.update_idletasks()

self.canvas.after(10, self.move)

def create_moving_ball(self, x=100, y=100, rad=20, outline='white'):

oid = self.canvas.create_oval(x - rad, y - rad, x + rad, y + rad,

outline=outline)

oid_angle = math.radians(random.randint(1, 360))

oid_speed = random.randint(2, 5)

self._oid.append([oid, rad, oid_angle, (oid_speed, oid_speed), (x, y)])

def queue_create(queue, running):

while running:

if random.random() < 1e-6:

print "Create a new moving ball please"

x, y = random.randint(100, 150), random.randint(100, 150)

color = random.choice(['green', 'white', 'yellow', 'blue'])

queue.put((x, y, random.randint(10, 30), color))

time.sleep(0) # Effectively yield this thread.

root = Tkinter.Tk()

running = [True]

queue = Queue.Queue()

app = App(queue)

app.create_moving_ball()

app.canvas.bind('', lambda x: (running.pop(), x.widget.destroy()))

thread = threading.Thread(target=queue_create, args=(queue, running))

thread.start()

root.mainloop()