Java创建线程的三种方式(Thread/Runnable/Callable)

/**
 * @author Junlan Shuai[shuaijunlan@gmail.com].
 * @date Created on 19:41 2017/4/10.
 */
public class ExtendThread extends Thread
{
    String name;
    public ExtendThread(String name)
    {
        this.name = name;
    }
    @Override
    public void run()
    {
        System.out.println(name);
    }
}

/**
 * @author Junlan Shuai[shuaijunlan@gmail.com].
 * @date Created on 19:40 2017/4/10.
 */
public class ImplRunnable implements Runnable
{
    public String name;
    public ImplRunnable(String name)
    {
        this.name = name;
    }
    public void run()
    {
        System.out.println(name);
    }
}

import java.util.concurrent.Callable;

/**
 * @author Junlan Shuai[shuaijunlan@gmail.com].
 * @date Created on 19:43 2017/4/10.
 */
public class ImplCallable implements Callable<String>
{
    public String name;
    public ImplCallable(String name)
    {
        this.name = name;
    }
    public String call() throws Exception
    {
        return name;
    }
}

public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.BlockJUnit4ClassRunner;
import java.util.concurrent.*;

/**
 * @author Junlan Shuai[shuaijunlan@gmail.com].
 * @date Created on 19:45 2017/4/10.
 */
@RunWith(BlockJUnit4ClassRunner.class)
public class Test1
{
    @Test
    public void test1()
    {
        Thread thread = new ExtendThread("Junlan Shuai");
        thread.start();
        try
        {
            Thread.sleep(1000);
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
    @Test
    public void test2()
    {
        Thread thread = new Thread(new ImplRunnable("Junlan Shuai"));
        thread.start();
        try
        {
            Thread.sleep(1000);
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
    @Test
    public void test3()
    {
        ImplCallable implCallable = new ImplCallable("Junlan Shuai");
        ExecutorService es = Executors.newFixedThreadPool(3);
        Future future = es.submit(implCallable);
        try
        {
            System.out.println(future.get());
            Thread.sleep(1000);
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        } catch (ExecutionException e)
        {
            e.printStackTrace();
        }
    }
}