animated rocks not spawning correctly

Question

I have no issue with getting the pool of rocks to empty and then waiting for them to disapear, but I have plenty of other issues...

Lets start with...

nextRock().start(rise, run);

This will potentially return a null object, which will cause a NullPointerException

As I stated before, you shouldn't need to mix Thread and Timer, here's my simple take on the rock..

public class Rock extends JLabel {

    Timer timer;
    private volatile boolean hasBeenUsed = false;

    public Rock() {
        super();
        setIcon(new ImageIcon(Rock.class.getResource("/Rock.png")));
        setBounds(415, 840, getPreferredSize().width, getPreferredSize().height);
        setVisible(false);
    }

    public void start(final int rise, final int run) {
        hasBeenUsed = true;
        setVisible(true);
        timer = new Timer(30, new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent ae) {
                setBounds(getBounds().x + run / 20, getBounds().y
                                + -rise / 20, getBounds().width,
                                getBounds().height);

                if (getBounds().x < 0 || getBounds().y < 0
                                || getBounds().y > 1000) {
                    timer.stop();
                    hasBeenUsed = false;
                    setBounds(415, 840, getPreferredSize().width, getPreferredSize().height);
                }
            }
        });
        timer.start();
    }
}

Your rock pool contains 10,000 rocks!! I don't think you can click fast enough to exhaust this pile.

Try reducing it down to something like 2 or 3 for testing...

Side note

This is a very expensive call...

public Rock nextRock() {
    for (int counter = 0; counter < rocks.length; counter++) {
        if (!rocks[counter].hasBeenUsed) {
            return rocks[counter];
        }
    }
    return null;
}

If you have 9, 999 rocks in the air, it's going to take a noticeable amount of time to get to the last one as you must iterate through all the rocks that are currently unavailable.

It might be easier to add all the rocks to a java.util.List (lets call it the rockPile). As rocks are thrown, you could check this list to see if there are any available rocks, if not, return, otherwise, remove the first rock from the list and place into a "inFlight" list. This will make it faster to check the rock pile (using something like List#isEmpty and List#get(0) are much faster).

When a rock becomes "available" again, you would remove it from the "inFlight" list and place back into the rockPile list.

This would also mean you could potentially get down to one Timer that would be responsible for iterating through the inFlight list and updating there positions...

UPDATE using a List

Basically, you need some kind of "manager" that maintain all the required information and can be shared between the interested parties...

public class RockManager {

    private List<Rock> rockPile;
    private List<Rock> inFlight;
    public static final int MAX_ROCKS = 2;

    public RockManager() {
        rockPile = new ArrayList<Rock>(MAX_ROCKS);
        inFlight = new ArrayList<Rock>(MAX_ROCKS);
        for (int index = 0; index < MAX_ROCKS; index++) {
            rockPile.add(new Rock(this));
        }
    }

    public Rock[] getRocksOnPile() {
        return rockPile.toArray(new Rock[rockPile.size()]);
    }

    public Rock[] getRocksInFlight() {
        return inFlight.toArray(new Rock[inFlight.size()]);
    }

    public Rock pickRockOfPile() {
        Rock rock = null;
        if (!rockPile.isEmpty()) {
            rock = rockPile.remove(0);
            inFlight.add(rock);
        }
        return rock;
    }

    public void putRockBackOnPile(Rock rock) {
        if (inFlight.contains(rock)) {
            inFlight.remove(rock);
            rockPile.add(rock);
        }
    }
}

NB: Technically, you probably don't "need" inFlight, but I'm using as a trap to ensure that rocks can't be added to the pile that aren't in flight ;). You could also use a Set for the rockPile as this will ensure that only unique references are contained within the list...

Next, I added a instance field of RockManager to the Start class.

In the initComp method of your Start class, you need to change the way you construct your rocks...

So, instead of

for(int counter =0; counter < rocks.length; counter++){
    rocks[counter] = new Rock();
    getContentPane().add(rocks[counter]);
}

You would now have...

rockManager = new RockManager();
for (Rock rock : rockManager.getRocksOnPile()) {
    getContentPane().add(rock);
}

You're nextRock method would become...

public Rock nextRock() {
    return rockManager.pickRockOfPile();
}

And finally, your Rock class would require a reference to the RockManager, basically, I pass a reference in via the constructor...

private RockManager manager;

public Rock(RockManager manager) {
    super();
    this.manager = manager;

Then, when the rock leaves the playing field, you can add it back to the pile via the RockManager...

manager.putRockBackOnPile(Rock.this);