java中创建线程的四种方法以及区别

public class MyThread extends Thread {
    @Override
    public void run() {
        // do something
        System.out.println("当前线程：" + Thread.currentThread());
    }

    public static void main(String[] args) {
        new MyThread().start();
    }
}

public class MyThread2 implements Runnable {

    @Override
    public void run() {
        System.out.println("当前线程：" + Thread.currentThread());
    }

    public static void main(String[] args) {
        new Thread(new MyThread2()).start();
    }
}

boolean cancel(boolean mayInterruptIfRunning) // 视图取消该Future里面关联的Callable任务
V get() // 返回Callable里call（）方法的返回值，调用这个方法会导致程序阻塞，必须等到子线程结束后才会得到返回值
V get(long timeout,TimeUnit unit) // 返回Callable里call（）方法的返回值，最多阻塞timeout时间，经过指定时间没有返回抛出TimeoutException   
boolean isDone() // 若Callable任务完成，返回True    
boolean isCancelled() // 如果在Callable任务正常完成前被取消，返回True

// Executors提供了一系列工厂方法用于创先线程池，返回的线程池都实现了ExecutorService接口。   
// 创建固定数目线程的线程池。
public static ExecutorService newFixedThreadPool(int nThreads)
public static ExecutorService newCachedThreadPool()

// 创建一个可缓存的线程池，调用execute将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。

// 创建一个单线程化的Executor。
public static ExecutorService newSingleThreadExecutor()

// 创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

public class Executor1{

    public static void main(String[] args){
        // 使用newCachedThreadPool(),
        // execute会首先在线程池中选择一个已有空闲线程来执行任务，如果线程池中没有空闲线程，它便会创建一个新的线程来执行任务。
        ExecutorService executorService = Executors.newCachedThreadPool();
//      ExecutorService executorService = Executors.newFixedThreadPool(5);
//      ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 5; i++){
            executorService.execute(new TestRunnable());
            System.out.println("************* a" + i + " *************");
        }
        executorService.shutdown();
    }
}

class TestRunnable implements Runnable{
    @Override
    public void run(){
        System.out.println(Thread.currentThread().getName() + "线程被调用了。");
    }
}

public class Executor2 {
    public static void main(String[] args){
        ExecutorService executorService = Executors.newCachedThreadPool();
        List<Future<String>> resultList = new ArrayList<>();

        //创建10个任务并执行
        for (int i = 0; i < 10; i++){
            //使用ExecutorService执行Callable类型的任务，并将结果保存在future变量中
            Future<String> future = executorService.submit(new TaskWithResult(i));
            //将任务执行结果存储到List中
            resultList.add(future);
        }

        //遍历任务的结果
        for (Future<String> fs : resultList){
            try{
                //Future返回如果没有完成，则一直循环等待，直到Future返回完成
                while(!fs.isDone());
                //打印各个线程（任务）执行的结果
                System.out.println(fs.get());
            }catch(InterruptedException e){
                e.printStackTrace();
            }catch(ExecutionException e){
                e.printStackTrace();
            }finally{
                //启动一次顺序关闭，执行以前提交的任务，但不接受新任务
                executorService.shutdown();
            }
        }
    }
}

class TaskWithResult implements Callable<String> {
    private int id;

    public TaskWithResult(int id){
        this.id = id;
    }

    /**
     * 任务的具体过程，一旦任务传给ExecutorService的submit方法，
     * 则该方法自动在一个线程上执行
     */
    @Override
    public String call() {
        System.out.println("call()方法被自动调用！！！    " + Thread.currentThread().getName());
        //该返回结果将被Future的get方法得到
        return "call()方法被自动调用，任务返回的结果是：" + id + "    " + Thread.currentThread().getName();
    }
}

public class MyThreadPool {
    public static void main(String[] args){
        //创建等待队列
        BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>(20);
        //创建线程池，池中保存的线程数为3，允许的最大线程数为5
        ThreadPoolExecutor pool = new ThreadPoolExecutor(3,5,50, TimeUnit.MILLISECONDS,bqueue);
        //创建七个任务
        for (int i = 0; i < 7; i++) {
            //每个任务会在一个线程上执行
            pool.execute(new MyThreadDemo());
        }

        //关闭线程池
        pool.shutdown();
    }
}

class MyThreadDemo implements Runnable{
    @Override
    public void run(){
        System.out.println(Thread.currentThread().getName() + "正在执行。。。");
        try{
            Thread.sleep(100);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
    }
}

/**
    *
    * @param corePoolSize 线程池中所保存的线程数，包括空闲线程。
    * @param maximumPoolSize 池中允许的最大线程数。
    * @param keepAliveTime 当线程数大于核心数时，该参数为所有的任务终止前，多余的空闲线程等待新任务的最长时间。
    * @param unit 等待时间的单位。
    * @param workQueue 任务执行前保存任务的队列，仅保存由execute方法提交的Runnable任务。
    */ 
   public ThreadPoolExecutor (int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,BlockingQueue<Runnable> workQueue)