Concurrencia en Java primer acercamiento a Swing

En la clase de ayer nos incentivaron a diseñar un programa que funcionara de la misma manera que el Pong, yo cuando me senté en mi PC, empecé a escribirlo pero a medida que lo hacia fui cambiando el objetivo, el resultado fue un programita sencillo con JButton de colores que se mueven rebotando por la pantalla y hay que hacerles clic para que se paren, se mueven a X pixeles cada 10 milésimas de segundo.
Fue solamente para practicar un poco el tema de concurrencia así que no esperen que solucione todos los problemas que tiene. Tarde 1 hora.
Esencialmente el programa son tres clases una es un Boolean para control, hay clases que cumplen los requisitos actuales, no uso otra clase por la idea es que mas adelante esa clase cumpla con otros tipos de controles como el tiempo o las coordenadas.
La segunda clase es el Thread que mueve a los botones por la pantalla, para ello recibe en el constructor varias cosas: La referencia al JButton, un objeto Control, un par de coordenadas y la velocidad de movimiento del botón.
La ultima es una clase visual donde están instanciados los botones, los elementos Control y los Threads.
Lo que ocurre si presionamos varias veces el botón Play es que varios manejadores de botones toman el control del mismo entonces el botón empieza a saltar por la pantalla.
Probé lanzar hasta 500 Threads y no se colgó nada, además los últimos ya funcionaban a 100 pixeles cada 10 milésimas de segundo.
Este .jar esta desarrollado en Easy Eclipse y con sus plugins visuales, además las dos primeras clases se ubicaran en el paquete modelo y la visual en visual.
La primera Clase es Control y de ella creo que no hace falta explicar mucho:

package modelo;
public class Control {    
boolean control;    
public Control()
    {
        control=true;
    }    
public void setControl(boolean x)
    {
        control=x;
    }    
public boolean getControl()
    {
        return control;
    }    
public void rotate()
    {
        if(control)
        control=false;
        else
        control=true;
    }
}

La funcion rotate() por ahora no la utilizo para nada, La segunda clase es Pelota, la idea era desarrollar un Pong no?, eta es la que extiende de Thread así que será la mas importante me parece a mi:

package modelo;
import javax.swing.JButton;
public class Pelota extends Thread {
    JButton pelota;
    int x;
    int y;
    Control activo;
    boolean arriba, derecha;
    int aceleracion;
    public Pelota(int x, int y,JButton pelota ,Control activo, int acele)
    {
        this.x=x;
        this.y=y;
        this.pelota=pelota;
        this.activo=activo;
        arriba=false;
        derecha=true;
        this.aceleracion=acele;
    }
    public void run()
    {
        while(activo.getControl())
        {
            pelota.setLocation(x, y);
            if(arriba)
            {
                y=y-aceleracion;
            }
            else
            {
                y=y+aceleracion;
            }
            if(derecha)
            {
                x=x+aceleracion;
            }
            else
            {
                x=x-aceleracion;
            }
            if(x<3)
            {
                derecha=true;
            }
            if(x>700)
            {
                derecha=false;
            }
            if(y>300)
            {
                arriba=true;
            }
            if(y<3)
            {
                arriba=false;
            }
            try{
                sleep(10);
            }
            catch(Exception e)
            {
            }
        }
    }
}

Las claves de esta clase son solamente mover el objeto JButton que nos viene por parámetro mientras el otro objeto Control sea verdadero, este se cambiara desde otra clase así que no nos importa, ponemos un while que realice el movimiento.
Para ello definimos una velocidad-> aceleración(interpretando muy mal un concepto de física le he puesto aceleración como nombre cuando debería ser velocidad) que será el ++ o – – correspondiente para cada movimiento, las otras variables son derecha y arriba, ellas son booleanas y se cambian cuando el tercer grupo de variable las coordenadas sobrepasan ciertos limites.
Los objetos JButton se moverán en un rectángulo aproximado de 700 X 300 pixeles de la ventana, luego en la siguiente clase es donde diseñamos la parte visual.
Alli hay que crear una clase visual a partir de JFrame, deshabilitar el Layout y poner 5 botones de distintos tamaños y colores recordando colocar un nombre comprensible  a cada uno.
Por otro lado y llendo hacia el código debemos importar lo siguiente para no tener problemas, recordemos que esta clase estará en el paquete visual mientras que las dos primeras están en modelo.

import modelo.Control;
import modelo.Pelota;

Luego las variables que debemos crear en esta clase, además de las que el editor visual nos genera son:

private Control z1;
private Control z2;
private Control z3;
private Control z4;
private Control z5;
private Pelota j1;
private Pelota j2;
private Pelota j3;
private Pelota j4;
private Pelota j5;
private JButton JB1 = null;
private JButton JB2 = null;
private JButton JB3 = null;
private JButton JB4 = null;
private JButton JB5 = null;
private JLabel jLabel = null;
private JLabel Nivel = null;
private JLabel JLnivel = null;
private int nivel;

La variable nivel será la que nos proveerá la velocidad de cada botón en los distintos niveles, además hacemos un JLabel para indicar al jugador cual es el actual.
JB1, JB2, JB3, JB4, JB5 son lo botones creados por el editor visual, los objetos Control y Pelota son las banderas de movimiento y los manejadores de cada botón, además hay un botón Play que desencadenara todo el movimiento.
En el initialize de la ventana hay que agregar:

nivel = 0;

El botón Play: en ese botón debemos seleccionar un ActionPerformed que hará lo siguiente:

nivel++;
z1=new Control();
z2=new Control();
z3=new Control();
z4=new Control();
z5=new Control();
j1 = new Pelota(JB1.getX(),JB1.getY(),JB1, z1,nivel);
j2 = new Pelota(JB2.getX(),JB2.getY(),JB2, z2,nivel);
j3 = new Pelota(JB3.getX(),JB3.getY(),JB3, z3,nivel);
j4 = new Pelota(JB4.getX(),JB4.getY(),JB4, z4,nivel);
j5 = new Pelota(JB5.getX(),JB5.getY(),JB5, z5,nivel);
j1.start();
j2.start();
j3.start();
j4.start();
j5.start();
Nivel.setText(String.valueOf(nivel));

Al inicializar los objetos zX del tipo Control se inicializan todos en true Luego construimos los “Pelota” pasándole como parámetro las posiciones actuales de los botones, los botones, el objeto de Control correspondiente y el nivel que es compartido por todos.
Luego se da start a cada Thread(nunca run()) y todos los botones comienzan a moverse por la pantalla, por ultimo seteamos nuestra label de nivel que informara que llegamos al nivel 1 la primera vez.
Como para los botones?
Fácil, lo que hacemos es establece un ActionPerfomed para cada uno de los 5 botones BJ1, JB2 JBN y adentro la clase de escucha paramos el objeto de Control, o sea el zX correspondiente: para JB1 seria así:

z1.setControl(false);

Con ello ya tenemos el juego funcionando discretamente, como les comente arriba se pueden iniciar muchos manejadores del mismo botón y crea una especie de lluvia de colores en pantalla.
Si están empezando a programar en Java como yo les va a gustar jugar con esto.