1 自定义一个类，然后实现 Runnable接口，然后实现run()方法。

public class MyRunnable implements Runnable{
    public void run() {
        System.out.println("我是MyRunnable");
    }
}

new Thread(new MyRunnable()).start();

2 自定义一个自己的线程类，然后继承 Thread 类，且重新run方法

public class MyThread1 extends Thread {
    public void run() {
        System.out.println("我是线程1");
    }
}

3 自定义一个自己的Callable类，然后实现它的call方法。

public class MyCallable<V> implements Callable<V> {

    @Override
    public V call() throws Exception {
        System.out.println("我是SomeCallable.call方法");
        return null;
    }
}

Callable<String> myCallable = new MyCallable<String>();
//由Callable<String>创建一个FutureTask<String>对象：
FutureTask<String> oneTask = new FutureTask<String>(oneCallable);
//注释：FutureTask<String>是一个包装器，它通过接受Callable<String>来创建，它同时实现了Future和Runnable接口。
//由FutureTask<Integer>创建一个Thread对象：
Thread oneThread = new Thread(oneTask);
oneThread.start();

4 通过线程池实现 Runnable

ExecutorService pool = Executors.newFixedThreadPool(5);
int i = 0;
for (; i < 50; i++) {
    int finalI = i;
    pool.submit(() -> System.out.println("我是任务" + finalI));
}
pool.shutdown();

5 通过线程池实现Callable接口

Future<Integer> res = pool.submit(() -> {
    return finalI;
});