Creating threads without extends and implements

I was going through an old project (Java) in my company where I found the author (already left), creates and runs thread without extending the Thread class or implementing the Runnable interface. One noticable thing was that the class was a singleton class. There are no usage of thread pooling, or the new concurrent package from java. Code snippet outlines given below –

import java.sql.*;
import org.apache.log4j.*;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.sql.DataSource;

public class DataLookup 
{

  private static DataLookup _ref;

  private DataLookup() 
  {
  }

  public static DataLookup getInstance() 
  {
    if (_ref == null) 
    {
      synchronized (DataLookup.class) 
      {
        if (_ref == null) 
        {
          _ref = new DataLookup();
        }
      }
      return _ref;
    }
  }
  /*
  * Implementation Logic
  */

  public void writeRecord(String a, String b, String c)
  {
    /*
    * Implementation Logic
    */
    Thread writerThread = new Thread()
    {
      public void run() 
      {
        /*
         * Implementation Logic
        */
      }
    }
    writerThread.start();
  }
}

How does this approach work – using threads without extending from Thread class or implementing Runnable interface? What are the advantages and disadvantages of using this approach (without extends and implements).

Answer

Thread writerThread = new Thread()
{
  public void run() 
  {
    /*
     * Implementation Logic
    */
  }
}

This code creates an anonymous class that extends Thread.

Anonymous classes enable you to make your code more concise. They enable you to declare and instantiate a class at the same time. They are like local classes except that they do not have a name. Use them if you need to use a local class only once.

The above quote is taken from The Java Tutorials, where you can read more about them.