org.apache.tools.ant.util

## Class WorkerAnt

- java.lang.Object
- - java.lang.Thread
  - - org.apache.tools.ant.util.WorkerAnt

All Implemented Interfaces:
  java.lang.Runnable

    public class WorkerAnt
    extends java.lang.Thread

A worker ant executes a single task in a background thread. After the run, any exception thrown is turned into a buildexception, which can be rethrown, the finished attribute is set, then notifyAll() is called, so that anyone waiting on the same notify object gets woken up.

This class is effectively a superset of `Parallel.TaskRunnable`

Since:
  Ant 1.8

### Nested Class Summary

### Nested classes/interfaces inherited from class java.lang.Thread

`java.lang.Thread.State, java.lang.Thread.UncaughtExceptionHandler`

### Field Summary

Fields
`static java.lang.String` `ERROR_NO_TASK` Error message if invoked with no task

### Fields inherited from class java.lang.Thread

`MAX_PRIORITY, MIN_PRIORITY, NORM_PRIORITY`

### Constructor Summary

Constructors
Constructor and Description
`WorkerAnt(Task task)` Create the worker, using the worker as the notification point.
`WorkerAnt(Task task, java.lang.Object notify)` Create the worker.

### Method Summary

Methods
`BuildException` `getBuildException()` Get any build exception.
`java.lang.Throwable` `getException()` Get whatever was thrown, which may or may not be a buildException.
`Task` `getTask()` Get the task
`boolean` `isFinished()` Query the task/thread for being finished.
`void` `rethrowAnyBuildException()` Raise an exception if one was caught
`void` `run()` Run the task, which is skipped if null.
`void` `waitUntilFinished(long timeout)` Block on the notify object and so wait until the thread is finished.

### Methods inherited from class java.lang.Thread

`activeCount, checkAccess, clone, countStackFrames, currentThread, destroy, dumpStack, enumerate, getAllStackTraces, getContextClassLoader, getDefaultUncaughtExceptionHandler, getId, getName, getPriority, getStackTrace, getState, getThreadGroup, getUncaughtExceptionHandler, holdsLock, interrupt, interrupted, isAlive, isDaemon, isInterrupted, join, join, join, resume, setContextClassLoader, setDaemon, setDefaultUncaughtExceptionHandler, setName, setPriority, setUncaughtExceptionHandler, sleep, sleep, start, stop, stop, suspend, toString, yield`

### Methods inherited from class java.lang.Object

`equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

### Field Detail

#### ERROR_NO_TASK

    public static final java.lang.String ERROR_NO_TASK

Error message if invoked with no task

See Also:
  Constant Field Values

### Constructor Detail

#### WorkerAnt

    public WorkerAnt(Task task,
             java.lang.Object notify)

Create the worker.

This does not start the thread, merely configures it.

Parameters:
  `task` - the task
  `notify` - what to notify

#### WorkerAnt

    public WorkerAnt(Task task)

Create the worker, using the worker as the notification point.

This does not start the thread, merely configures it.

Parameters:
  `task` - the task

### Method Detail

#### getBuildException

    public BuildException getBuildException()

Get any build exception. This would seem to be oversynchronised, but know that Java pre-1.5 can reorder volatile access. The synchronized attribute is to force an ordering.

Returns:
  the exception or null

#### getException

    public java.lang.Throwable getException()

Get whatever was thrown, which may or may not be a buildException. Assertion: getException() instanceof BuildException <=> getBuildException()==getException()

Returns:
  the exception.

#### getTask

    public Task getTask()

Get the task

Returns:
  the task

#### isFinished

    public boolean isFinished()

Query the task/thread for being finished. This would seem to be oversynchronised, but know that Java pre-1.5 can reorder volatile access. The synchronized attribute is to force an ordering.

Returns:
  true if the task is finished.

#### waitUntilFinished

    public void waitUntilFinished(long timeout)
                           throws java.lang.InterruptedException

Block on the notify object and so wait until the thread is finished.

Parameters:
  `timeout` - timeout in milliseconds
Throws:
  `java.lang.InterruptedException` - if the execution was interrupted

#### rethrowAnyBuildException

    public void rethrowAnyBuildException()

Raise an exception if one was caught

Throws:
  `BuildException` - if one has been picked up

#### run

    public void run()

Run the task, which is skipped if null. When invoked again, the task is re-run.

Specified by:
  `run` in interface `java.lang.Runnable`
Overrides:
  `run` in class `java.lang.Thread`