Package org.apache.tools.ant.util

# Class WorkerAnt

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

All Implemented Interfaces:
  `Runnable`

public class WorkerAnt extends 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 `org.apache.tools.ant.taskdefs.Parallel.TaskRunnable`

Since:
  Ant 1.8

## Nested Class Summary

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

`Thread.Builder, Thread.State, Thread.UncaughtExceptionHandler`

## Field Summary

Fields
Modifier and Type
Field
Description
`static final 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
Description
`WorkerAnt(Task task)`
Create the worker, using the worker as the notification point.
`WorkerAnt(Task task, Object notify)`
Create the worker.

## Method Summary

Modifier and Type
Method
Description
`BuildException`
`getBuildException()`
Get any build exception.
`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, currentThread, dumpStack, enumerate, getAllStackTraces, getContextClassLoader, getDefaultUncaughtExceptionHandler, getId, getName, getPriority, getStackTrace, getState, getThreadGroup, getUncaughtExceptionHandler, holdsLock, interrupt, interrupted, isAlive, isDaemon, isInterrupted, isVirtual, join, join, join, join, ofPlatform, ofVirtual, onSpinWait, resume, setContextClassLoader, setDaemon, setDefaultUncaughtExceptionHandler, setName, setPriority, setUncaughtExceptionHandler, sleep, sleep, sleep, start, startVirtualThread, stop, suspend, threadId, toString, yield`

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

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

## Field Details

### ERROR_NO_TASK

public static final String ERROR_NO_TASK
Error message if invoked with no task

See Also:
  - Constant Field Values

## Constructor Details

### WorkerAnt

public WorkerAnt(Task task, 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 Details

### 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 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 InterruptedException
Block on the notify object and so wait until the thread is finished.

Parameters:
  `timeout` - timeout in milliseconds
Throws:
  `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 `Runnable`
Overrides:
  `run` in class `Thread`