I believe I was able to make HTML loading be dictated by keyPressed() rather by keyReleased() .
Also, mouseClicked() works as well!  
This post has some insights about multi-threading as well:
is-this-a-multythreading-app

/**
 * Threaded DownloadHTML (v2.5)
 * by JeffThompson (2013/Jan)
 *
 * http://forum.processing.org/topic/help-with-updating-thread-when-key-is-pressed
 */

final  DownloadHTML html = new DownloadHTML();
String displayText;

void setup() {
    size(900, 600);
    noLoop();
    smooth();
    fill(0);

    html.start();
}

void draw() {
    if ( html.isAvailable() ) {
        String[] data = html.getData();
        displayText = "";

        for (String s: data)    displayText += s+"\n";
    }
    else    displayText = "Loading...";

    background(255);
    text(displayText, 10, 10);
}

void keyPressed() {
    if (key == ' ')    synchronized(g) {
        g.notify();
        redraw();
    }
}

void mouseClicked() {
    key = ' ';
    keyPressed();
}

class DownloadHTML extends Thread {
    boolean isRunning, isAvailable;
    String[] data;

    boolean isAvailable() {
        return isAvailable;
    }

    String[] getData() {
        isAvailable = false;
        return data;
    }

    void start() {
        isRunning = true;
        super.start();
    }

    void run() {
        while (isRunning) {
            data = loadStrings("http://www.Google.com");
            isAvailable = true;

            synchronized(g) {
                try {
                    g.wait();
                }
                catch (Exception e) {
                }
            }
        }
    }

    void quit() {
        isRunning = false;
        interrupt();
    }
}

Hey! What's up w/ my answer being flagged as SPAM?!  

Can any admin unSPAM my invisible answer, please?

Hey GoToLoop, thanks for the revisions (and weird about the spam)!  Your example works great for me, but using noLoop() means that nothing else can happen onscreen while the data is loading.  In this particular case it's not a problem, but for interactive projects that wouldn't work very well.  I imagine this could be extended a bit, but my efforts didn't seem to work

This leaves me with a few questions:

1. Any alternatives to the noLoop() method? Does this require a second thread for getting the status?
2. My quick research into the synchronized() code suggests that this locks two threads into each other - is this correct, and if so, what is the second thread in this example?  What is the argument 'g' doing?

Also, to see what was happening more easily, I am using this URL which is about 1MB and therefore takes more than a few ms to load:
  http://archive.org/stream/hungloumengbooki09603gut/8hlm110.txt

Thanks!

My previous version had some bugs.
I guess it was showing an already loaded URL after hitting <SPACE> key or mouse-clicking! 

My intention was to halt draw() until it'd be necessary again to refresh screen w/ new content requested!
No need to keep hammering 60 frames per second to show the very same static image, huh?
Nonetheless, program works w/ noLoop() or not! 

I'm no expert at all in Java concurrent threads. And I believe few are! It's very complicated!!!

Until recently, the argument used inside a synchronized() block was a mystery to me.
And still I'm far to grasp it entirely!

Seems like an arbitrary object can be chosen ( !?) for it.
In Processing, the simplest available object is variable g.
But if I had chosen System.out or created my own object, that would work the same way!
Just experiment yourself replacing g w/ System.out and you'll see it keeps on working normally! 

Although it's just 1 extra thread running in your program, I've decided to use a synchronized() block so I could put the the DownloadHTML to sleep indefinitely rather than stipulating a time as you did w/ -> sleep ((long)(1000));
For there's no need to keep pummeling a URL while the user hadn't still made any requests for reload contents!

Once a g.wait(); is issued, it is necessary for another thread inside a synchronized(g) block
(it can be the same block or another 1 somewhere else, as long as it's locked by the same object, in our case -> g)
to awake 1 or more sleeping thread(s).

So now I use:

1.     if ( key == ' ' && hasFinished)   synchronized(g) {
2.         g.notify();
3.     }

to get the extra thread outta its eternal sleep!

Once awaken, it reactivates the draw() callback w/ loop();

1.         try {
2.             g.wait ();
3.             isAvailable = false ;
4.             loop();
5.         }

Now, draw() keeps repeating until a content is finally loaded.
After that, it turns itself off by using -> noLoop();

It also locks keyPressed() from accepting more refresh requests by flagging boolean variable -> hasFinished = false.

...suggests that this locks two threads into each other...

I believe it has to do w/ the time notify() & notifyAll() make the threads to awake.
AFAIK, let's just say we have a synchronized() block w/ 10 statements.

It doesn't matter where notify() is placed within that block, threads are awaken only after that synchronized() block is completely finished!

Or perhaps it refers to the fact that only 1 thread can be inside a synchronized() block in a given moment.
Unless it's put to sleep w/ wait() !
Then another thread can enter that block and:

• Gets outta there;
• Try to awake 1 or more sleeping threads
• Or it is also put to sleep as well!

Again it was marked as SPAM!  

Perhaps it's the reference to the almighty omnipresent Google's URL inside the program source?!

I don't know if you really need all the synchronization stuff. Wouldn't something like this work?

boolean working;

void setup() {
  background(0);
}

void draw() {
  int pulse = round((1+sin(frameCount*.5))*64)+128;
  fill(pulse, 32);
  if(working) {
    fill(pulse,0,0);
  }
  rect(0,0,width,height);
}

void keyTyped() {
  if(!working) startLoading();
}

void startLoading() {
  new Thread(new Runnable() {
    long start;
    public void run() {
      start = millis();
      for(;;) {
        if(millis() - start > 5000) {
          done();
          return;
        }
      }
    }
  }).start();
  working = true;
}

void done() {
  working = false;
}