Force method to finish before continuing

Question

I'm working on some sensitive LWJGL code and need to make sure that I create my display, and therefore GL context before executing any other code.

To give a clear example of my current predicament, take the following:

public static void main(String[] args) {
    GLDisplay display = new GLDisplay();
    display.start();

    GLShader shader = new StaticShader();
}

The beginning of my GL creation happens in display.start(), where a separate thread is created, and within the separate thread, my Display is created.

Except this is where the problem lies, I have it in a separate thread. So then my program goes on and starts prematurely executing the new StaticShader() which calls even more GL code, breaking the program. (Can't execute before display is created).

What I'm trying to do, is achieve two threads simultaneously which I already have, but make sure that start() method is called completely before anything else is.

Here is how the start method works:

public synchronized void start() {
    Threader.createThread(this, "GLDisplay");
}

@Override  // public class GLDisplay extends Runnable
public void run() {
    // GL code goes here.
}

And here is Threader:

public static void createThread(Runnable behaviour, String name) {
    new Thread(behaviour, name + behaviour.hashCode()).start();
}

Now you may notice the synchronized keyword in the start method, well thats just one attempt I've had to no avail. I've also tried the following (which I actually grabbed from another StackOverflow answer):

@Override
public void run() {
    synchronized(this) {
        // GL code
    }
}

I've checked other StackOverflow answers but either don't understand them or don't help me in my case. With the first code block I give in the main method, that is how I want my code to look to the person using it. I'm trying to put the thread-creation inside GlDisplay to hide it.
Any ideas?

Edit:

I can't simply wait for GLDisplay to close either (with Thread.join()) because there lies a while-loop that updates the display for the entirety of the program.
This is the entire reason I multi-threaded it. To allow this forever-ending loop to run while I do other things in the program. By closing the thread, I close the loop, cleanup the display and free the GL context from memory, once again making the shader code fail for lack of an existing context.

Answer 1

You can use java.util.concurrent.CountDownLatch to achieve it which aids in making a thread(s) wait till the operations on other threads is complete. Please see the reference on on what and how to use it.

Example:

public static void main(String[] args) {

    CountDownLatch cdl = new CountDownLatch(1);

    // pass the CountDownLatch into display
    GLDisplay display = new GLDisplay(cdl);
    display.start();

    // wait for the latch to have been counted down in the disp thread
    try
    {
        cdl.await();
    }
    catch (InterruptedException e)
    {
        e.printStackTrace();
    }

    GLShader shader = new StaticShader();
}

In your GLDisplay thread, call the countDown method of CountDownLatch

Answer 2

I might be misunderstanding something, but try the following:

public static void createThread(Runnable behaviour, String name) {
    Thread t = new Thread(behaviour, name + behaviour.hashCode()).start();
    t.join();
}

By calling join() the program should wait for the thread to complete.

Answer 3

Well I remember now that I can't have GL code against two separate threads anyway, but thats besides the point.

I don't actually need to use any thread-lock classes or anything, but rather can just do something as simple as this:

private Boolean threadLock = true;
public void start() {
    Threader.createThread(this, "GLDisplay");
    while (true) {
        synchronized(threadLock) {
            if (!threadLock) break;
        }
    }
}

@Runnable
public void run() {
    // Do GL code.
    synchronized(threadLock) { threadLock = false; }
    // Do the rest of whatever I'm doing.
}

When the threadlock is reached in the second thread and is released, the first thread continues doing it's activity. It's that simple!