There's nothing in the code you posted that would obviously cause your
problem.  However, it's equally obvious (if nothing else, from the
ellipses and the "doSomething") that the code you posted isn't the code
that's giving the error message.  If you can't be bothered to show us
the code that's failing, then it's rather difficult to help you.

The problem is that you have forgotten to call initialize() before
starting the thread.

There are a few things you can do here to prevent this kind of bug:

1.  Convert initialize to a constructor, or at least make initialize
private and call it from a constructor.  It's impossible to construct
an object while forgetting to call a constructor, but it isn't
impossible to forget to call initialize(), obviously.  Probably you
think initialize() is a good idea because of applets, but the applet
API is very poor (it relies on subclassing, for one).

2.  Make all fields that you need to set ONCE, final.  This will make
sure that you set them, and only set them once.  This will probably
force you to implement suggestion 1.  Work with the compiler on this
one, don't fight the error messages.  This is probably the most
significant way of preventing NullPointerExceptions.

3.  Don't declare that you throw Exception.  Declare SPECIFIC types of
exception.  If you declare that you throw Exception, this forces the
caller to either catch or throw Exception, which will include
RuntimeException, masking real bugs.  Of course, the caller could use
instanceof to make sure that any RuntimeExceptions are rethrown, e.g:

try
{
  yourMethod();
}
catch (final Exception exception)
{
  if (exception instanceof RuntimeException)
     throw (RuntimeException)exception;
}

Even so, it's better to be explicit about the individual types of
exception thrown, so that the caller can choose to, e.g., handle a
FileNotFoundException differently to an SQLException.

4.  This is more of a design problem than an implementation problem,
but you seem to be programming to implementations, rather than
interfaces.  That is, there is no interface for Task, just an
AbstractTask.  You are coupling the implementation of AbstractTask with
the subtypes of it, which is entirely pointless.  It saves a few
keypresses, that's all, but loses a lot of flexibility.

5.  Don't use the 'null' keyword unless you mean it.  Setting a field
to null is unnecessary, it's null by default.  Also, if you use
suggestion 2, final, then Java will count the =null as The One
assignment, and signal all the other assignments as errors.  It's
better to omit it.