Swing i kolorowanie JPanel w wątku

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Shape;
import java.awt.geom.Ellipse2D;
import java.util.ArrayList;
import java.util.Random;

import javax.swing.JPanel;

public class EdenPanel extends JPanel implements Runnable {
	/**
	 * 
	 */
	private static final long serialVersionUID = -1418394043622693890L;
	int width;
	int height;
	int size;
	Color c;
	Thread th;

	Point startPoint;
	Point top;
	Point right;
	Point bottom;
	Point left;
	Point newPoint;

	public Point getStartPoint() {
		return startPoint;
	}

	public void setStartPoint(Point startPoint) {
		this.startPoint = startPoint;
	}

	public Point getTop() {
		return top;
	}

	public void setTop(Point top) {
		this.top = top;
	}

	public Point getRight() {
		return right;
	}

	public void setRight(Point right) {
		this.right = right;
	}

	public Point getBottom() {
		return bottom;
	}

	public void setBottom(Point bottom) {
		this.bottom = bottom;
	}

	public Point getLeft() {
		return left;
	}

	public void setLeft(Point left) {
		this.left = left;
	}

	public Point getNewPoint() {
		return newPoint;
	}

	public void setNewPoint(Point newPoint) {
		this.newPoint = newPoint;
	}

	public ArrayList<Point> emptyPoints = new ArrayList<Point>();
	public ArrayList<Point> coloredPoints = new ArrayList<Point>();

	public ArrayList<Point> getEmptyPoints() {
		return emptyPoints;
	}

	public void setEmptyPoints(ArrayList<Point> emptyPoints) {
		this.emptyPoints = emptyPoints;
	}

	public ArrayList<Point> getColoredPoints() {
		return coloredPoints;
	}

	public void setColoredPoints(ArrayList<Point> coloredPoints) {
		this.coloredPoints = coloredPoints;
	}

	public EdenPanel(int sizeX, int sizeY) {
		this.width = sizeX;
		this.height = sizeY;

		c = Color.BLUE;
		setBackground(Color.BLACK);
		setPreferredSize(new Dimension(width * 3 / 4, height));
	}

	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
		Graphics2D g2 = (Graphics2D) g;
		c = Color.BLUE;
		g2.setColor(c);
		if (getRight() != null) {
			g2.fill(new Ellipse2D.Float.Float(startPoint.x, startPoint.y, size, size));
		}
		c = new Color(155, 38, 38);
		g2.setColor(c);
		if (getRight() != null) {
			g2.fill(new Ellipse2D.Float.Float(getRight().x, getRight().y, size, size));
		}
		if (getBottom() != null) {
			g2.fill(new Ellipse2D.Float.Float(getBottom().x, getBottom().y, size, size));
		}
		if (getLeft() != null) {
			g2.fill(new Ellipse2D.Float.Float(getLeft().x, getLeft().y, size, size));
		}
		if (getTop() != null) {
			g2.fill(new Ellipse2D.Float.Float(getTop().x, getTop().y, size, size));
		}
		c = new Color(74, 208, 17);
		g2.setColor(c);
		if (getNewPoint() != null) {
			g2.fill(new Ellipse2D.Float.Float(getNewPoint().x, getNewPoint().y, size, size));
		}
	}

	public void update(Graphics g) {
		paint(g);
	}

	public void paintFirstCell(int size) {
		this.size = size;
		startPoint = createStartPoint(width * 3 / 4, height);
		left = createLeftPoint(startPoint);
		right = createRightPoint(startPoint);
		top = createTopPoint(startPoint);
		bottom = createBottomPoint(startPoint);
		revalidate();
		repaint();

	}

	public Point createStartPoint(int windowSizeX, int windowSizeY) {
		startPoint = new Point();
		startPoint.x = windowSizeX / 2;
		startPoint.y = windowSizeY / 2;
		setStartPoint(startPoint);

		coloredPoints.add(startPoint);
		setColoredPoints(coloredPoints);

		return startPoint;
	}

	private Point createLeftPoint(Point p) {
		left = new Point();
		left.x = p.x - size;
		left.y = p.y;

		if (!emptyPoints.contains(left) && !coloredPoints.contains(left) && left.x > size) {
			emptyPoints.add(left);
			setLeft(left);
			return left;
		} else {
			return null;
		}
	}

	private Point createRightPoint(Point p) {
		right = new Point();
		right.x = p.x + size;
		right.y = p.y;

		if (!emptyPoints.contains(right) && !coloredPoints.contains(right) && right.x < width - size) {
			emptyPoints.add(right);
			setRight(right);
			return right;
		} else {
			return null;
		}
	}

	private Point createTopPoint(Point p) {
		top = new Point();
		top.x = p.x;
		top.y = p.y + size;

		if (!emptyPoints.contains(top) && !coloredPoints.contains(top) && top.y < height - size) {
			emptyPoints.add(top);
			setTop(top);
			return top;
		} else {
			return null;
		}
	}

	private Point createBottomPoint(Point p) {
		bottom = new Point();
		bottom.x = p.x;
		bottom.y = p.y + this.size;

		if (!emptyPoints.contains(bottom) && !coloredPoints.contains(bottom) && bottom.y > this.size) {
			emptyPoints.add(bottom);
			setBottom(bottom);
			return bottom;
		} else {
			return null;
		}
	}

	@Override
	public void run() {
		while (true) {
			createNewPoint(getStartPoint());
			left = createLeftPoint(getNewPoint());
			right = createRightPoint(getNewPoint());
			top = createTopPoint(getNewPoint());
			bottom = createBottomPoint(getNewPoint());
		}
	}

	private void createNewPoint(Point p) {
		// TODO Auto-generated method stub
		Random r = new Random();
		int index = r.nextInt(getEmptyPoints().size());
		setNewPoint(getEmptyPoints().get(index));
		getColoredPoints().add(getNewPoint());
		setColoredPoints(coloredPoints);
	}

	public void stopPainting() {
		//th.interrupt();
	}
}