方式一：继承Thread类，并重写run方法

注意：开启线程要使用start()方法，run()方法只是普通的方法调用。

实际上的创建线程还是通过本地方法，Java本身并不能开启线程。

方式二：实现Runnable接口，并重写run方法

注意：这里要通过Thread对象来开启线程。

方式三：实现Callable接口，并重写call方法

注意：因为要通过Thread对象来开启线程，上面给出了Thread类的构造方法，没有直接的方法可以传入Callable，所以我们要对其进行加功。而Callable又是特别的，它可以有返回值。所以提供了一个FutureTask类，通过它可以获取返回的结果。且它间接实现了Runnable接口，所以可以传入Thread的构造函数。如下：

 方式四：通过线程池创建

package orange;


import java.util.concurrent.*;

public class MyThread4 {
    public static void main(String[] args) {
        /**
         * 高速缓存的线程池，需要多少创建多少，60s未调用就会自动销毁。
         *                              ThreadPoolExecutor(0, Integer.MAX_VALUE,
         *                                               60L, TimeUnit.SECONDS,
         *                                               new SynchronousQueue<Runnable>())
         */
        ExecutorService executorService = Executors.newCachedThreadPool();

        /**
         *  固定大小的线程池，满了就等待
         *                             ThreadPoolExecutor(nThreads, nThreads,
         *                                               0L, TimeUnit.MILLISECONDS,
         *                                               new LinkedBlockingQueue<Runnable>())
         */
        ExecutorService executorService1 = Executors.newFixedThreadPool(10);

        /**
         * 每次只创建一个线程，满了就等待
         *                              new ThreadPoolExecutor(1, 1,
         *                                             0L, TimeUnit.MILLISECONDS,
         *                                             new LinkedBlockingQueue<Runnable>()))
         */
        ExecutorService executorService2 = Executors.newSingleThreadExecutor();

        /**
         * 自定义线程池
         *         ThreadPoolExecutor(int corePoolSize,    //核心线程数
         *                                       int maximumPoolSize,   //最大线程数
         *                                       long keepAliveTime,    //非核心线程空闲时的存活时间
         *                                       TimeUnit unit,         //存活时间单位
         *                                       BlockingQueue<Runnable> workQueue, //阻塞队列，也就是等着获取线程的
         *                                       ThreadFactory threadFactory,   //线程工厂
         *                                       RejectedExecutionHandler handler)  //拒绝策略,默认为AbortPolicy()
         */
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10,
                20L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());

        executorService.execute(new Runnable() {
            public void run() {
                System.out.println(Thread.currentThread().getName() + "线程执行了");
            }
        });
        executorService1.execute(new Runnable() {
            public void run() {
                System.out.println(Thread.currentThread().getName() + "线程执行了");
            }
        });
        executorService2.execute(new Runnable() {
            public void run() {
                System.out.println(Thread.currentThread().getName() + "线程执行了");
            }
        });

        threadPoolExecutor.execute(new Runnable() {
            public void run() {
                System.out.println(Thread.currentThread().getName() + "线程执行了");
            }
        });
        executorService.shutdown();
        executorService1.shutdown();
        executorService2.shutdown();
        threadPoolExecutor.shutdown();
    }
}