Java中线程创建的四种方式

---

一、继承Thread类

• 步骤
  1.自定义线程类,该类继承Thread,可重写run()方法
  2.创建自定义线程类对象
  3.该对象调用start()方法
• 举例

 class MyThread extends Thread{
   @Override
   public void run() {
       System.out.println("继承Thread类的自定义线程执行");
   }
}
public class testCreateThread {
   public static void main(String[] args) {
       MyThread myThread = new MyThread();
       myThread.start();
       /*
       运行结果:
       继承Thread类的自定义线程执行
        */
   }
}

二、实现Runnable接口

• 步骤
  1.自定义Runnable类,该类实现Runnable,重写run()方法
  2.创建自定义Runnable实例
  3.将该实例作为参数创建Thread类对象(事实上,前3步可以用lambda表达式创建匿名内部类简写)
  4.该对象调用start()方法
• 举例

class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println("实现Runnable接口的自定义线程执行");
    }
}
public class testCreateThread {
    public static void main(String[] args) {
        /*
       
         */
        Thread myRunnable1 = new Thread(new MyRunnable());
        Thread myRunnable2=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类实现Runnable接口的自定义线程执行");
            }
        });
        myRunnable1.start();
        myRunnable2.start();
        /*
        运行结果:
        实现Runnable接口的自定义线程执行
        匿名内部类实现Runnable接口的自定义线程执行
         */
    }
}

三、实现Callable接口

• 步骤
  /*
  1.自定义Callable类,该类实现Callable,重写call()方法
  2.创建自定义Callable类实例
  3.将该实例作为参数创建FutureTask类对象
  4.将FutureTask类对象作为参数创建Thread类对象
  5.Thread类对象调用start()方法
  注:实现Callable接口和实现Runnable接口的区别是:实现Callable接口时重写的call()方法有返回值,可以通过FutureTask.get()来得到返回值;实现Runnable接口时重写的run()方法无返回值(当然也可以实现Runnable接口的同时也有返回值,具体看举例)
  */
• FutureTask

 public class FutureTask<V>extends Object implements RunnableFuture<V>
 /*
 可取消的异步计算。 该类提供了一个Future的基本实现 ，
 具有启动和取消计算的方法，查询计算是否完整，并检索计算结果。
  结果只能在计算完成后才能检索; 如果计算尚未完成，则get方法将阻止。
   一旦计算完成，则无法重新启动或取消计算（除非使用runAndReset()调用计算 ）。 
A FutureTask可用于包装Callable或Runnable对象。 
因为FutureTask实现Runnable ，一个FutureTask可以提交到一个Executor执行。 

• 举例

class MyCallable implements Callable<String> {
   @Override
   public String call() throws Exception {
       System.out.println("实现Callable接口的自定义线程执行");
       return "success1";
   }
}
class MyRunnable implements Runnable{

   @Override
   public void run() {
       System.out.println("实现Runnable接口的自定义线程执行");
   }
}
public class testCreateThread {
   public static void main(String[] args) throws ExecutionException, InterruptedException {

       /*
       public interface RunnableFuture<V> extends Runnable, Future<V>
       public class FutureTask<V> implements RunnableFuture<V>
       因此FutureTask类实现了Runnable接口,故其也可以作为参数创建Thread类对象
       
       public FutureTask(Callable<V> callable) {
       public FutureTask(Runnable runnable, V result) {  //该构造函数就可以实现Runnable接口的同时也有返回值
        */
       FutureTask<String> futureTask1 = new FutureTask<>(new MyCallable());
       FutureTask<String> futureTask2 = new FutureTask<>(new MyRunnable(),"success2");
       Thread thread1 = new Thread(futureTask1);
       Thread thread2 = new Thread(futureTask2);
       thread1.start();
       thread2.start();
       System.out.println(futureTask1.get());
       System.out.println(futureTask2.get());

       /*
       运行结果:
       实现Callable接口的自定义线程执行
       实现Runnable接口的自定义线程执行
       success1
       success2
        */
   }
}

四、Exectors工具类

• 步骤
  1.调用Executors的静态方法创建线程池对象ExecutorService(ThreadPoolExecutor实现了ExecutorService接口)
  2.调用线程池对象的execute()方法执行线程(每调用一次该方法,执行一次)
  3.调用线程池对象的shutdown()方法关闭线程
• 举例

class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"运行");
    }
}
public class testCreateThread {
    public static void main(String[] args)  {
        /*
        public static ExecutorService newSingleThreadExecutor()
        创建一个使用从无界队列运行的单个工作线程的执行程序。
        这只是简单介绍下Executors的使用
        其实还有其他线程池,如:newFixedThreadExecutor,newCachedThreadExecutor,newScheduledThreadExecutor
        这四种线程池的区别在之后的文章中会做较详细的介绍
         */
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i <3 ; i++) {
            executorService.execute(new MyRunnable());
        }
        //注意:线程池要手动关闭,否则程序会一直运行
        executorService.shutdown();
        /*
        运行结果:
        pool-1-thread-1运行
        pool-1-thread-1运行
        pool-1-thread-1运行
         */

    }