Dirty ways to create Threads in Java

Question

I have recently started digging into Multi-Threading in Java. While exploring things, I discovered there are 2 quick and dirty ways to create Threads "on the go" in Java. Here is the example:

public static void main(String[] args) {
    System.out.println("Thread: " + Thread.currentThread().getName());

    new Thread() {
        public void run() {
            System.out.println("Thread: "
                    + Thread.currentThread().getName());
            System.out.println("hello");
        }
    }.start();

    new Thread(new Runnable() {

        @Override
        public void run() {
            System.out.println("Thread: "
                    + Thread.currentThread().getName());
            System.out.println("hello");
        }

    }).start();
}

1. First one is the one which starts with new Thread() {
2. Second one comes after that which starts with new Thread(new Runnable() {

I just wanted to ask if both of the ways are correct? Any difference other than difference of Implementing Runnable Interface v/s Extending Thread class?

Answer 1

Both ways are acceptable (and neither way is "dirty" in my opinion). The first is less verbose and the one I would prefer in a trivial case like this. If you're extending Thread, so you can also skip Thread.currentThread():

new Thread() {
    public void run() {
        System.out.println("Thread: " + getName());
        System.out.println("hello");
    }
}.start();

In any non-trivial case however (i.e. if the thread does more than just a couple of prints) the usual rule of "favor composition over inheritance" applies which advocates the second approach.

If you're using Java 8, you can even take advantage of the fact that Runnable is a functional interface:

new Thread(() -> {
    System.out.println("Thread: " + Thread.currentThread().getName());
    System.out.println("hello");
}).start()

A final note: I rarely use threads these days. Whenever I do, I tend to end up rewriting it using ExecutorServices.