"Pause" Thread, thread creation & run performance

Question

Hello,
I'm having an object executing tasks in response to events (I call it Executer)
In "normal" execution mode, it's executing 2 types of tasks: tasks1 and tasks2.
when a specific event occurs (pauseEvent), I want it to STOP executing tasks2 for a specific amount of time (in this example 100ms): I'm calling that a "pause"
it will still be executing tasks1 in the meantime, and will resume executing tasks2 only after the pause has expired.
to do so, when I receive a pauseEvent I create a new Thread (PauseThread) and start it.
it itself calls the "setPause(boolean p)" method of Executer to set the "pause" flag to true
then it waits for 100ms
then it sets back the pause flag to false
(Executer checks the pause flags before executing tasks2)
class PauseThread extends Thread {
    private TaskExecuter  executer;
    private long                pauseTime;
    public PauseThread(Executer e, int t) {
        executer = e;
        pauseTime = t;
    public void run() {
        executer.setPause(true);
     try {
            sleep(pausetime);
        catch(InterruptedException e) {
            System.out.println("exception pause thread");
     executer.setPause(false);                
}all is working fine.
however, I'm trying to improve performances.
the whole process of creating & starting the thread takes up to 50us, I want to reduce this as much as possible.
obviously, I create & start a thread every time I want to do a pause, I'm thinking there MUST be a way to avoid this, and simply call the setTrue / Sleep / setFalse part of the thread instead.
I was thinking about creating and starting the thread only once at the creation of my Executer, and calling the "pause()" method when needed:
class PauseThread extends Thread {
    private TaskExecuter  executer;
    private long                pauseTime;
    public PauseThread(Executer e, int t) {
        executer = e;
        pauseTime = t;
    public void run() {
     while(true) {
    public void pause() {
        executer.setPause(true);
     try {
            sleep(pausetime);
        catch(InterruptedException e) {
            System.out.println("exception pause thread");
     executer.setPause(false);                
}would that be correct ?
I'm concerned with the performance hit of the "while(true)" (as I'm fighting for micro-seconds, even the slighliest useless cpu hit should be avoided)
what if I had "sleep(1)" in my while loop ?
I'm pretty sure there's a better way to do this, any idea ? maybe using wait / notify, however I get the feeling those methods are not designed for this use...
any hint ?
thanks !

Answer 1

yes, I'm certainly reinventing the wheel ! but trying to understand it at the same time !
what was your other suggestion ? Timer + TimerTask ? I've already implemented it and using it now ! as I said it's working good, 3x improvement ! simply trying to see if there's a way to avoid creating a TimerTask object at each run.
coming back at the "piece of nonsense", what would this achieve:
class PauseThread extends Thread {
    private TaskExecuter  executer;
    private long                pauseTime;
    private boolean           flag = false;
    public PauseThread(Executer e, int t) {
        executer = e;
        pauseTime = t;
    public void run() {
     while(true) {
            if(flag) {
                flag = false;
                sleep(pauseTime); // add try/catch
                executer.setPause(false);
    public void startPause() {
        flag = true
}then in my Executer, I create and start the PauseThread only once, and when I want to pause it, I simply do:
setPause(true);
pauseThread.startPause();in this case the sleep would execute in the run(), pause the "pause" thread, not the "executer" thread, no ?
I will read about the concurrency classes...