总结Java中三种实现多线程的方式

Thread、Runnable、Callable

一、通过继承Thread来创建线程
①定义Thread类的子类，重写run（）方法（构造器声明：Thread（）、Thread（String name））
②创建Thread的实例（线程对象）
③调用start（）方法启动线程

public class TestThread{
     Public static void main(String[] args){
          SubThread st1 = new SubThread();//创建SubThread实例
          SubThread st2 = new SubThread();
          st1.start();//启动线程
          st2.start();
     }
}
class SubThread extends Thread{
    Public void run(){//重写run()方法
         for(int i = 0; i < 4; i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
   }   
}

存在Java单继承的局限性，如需访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可
注：如果start（）调用一个已经启动的线程，程序会报IllegalThreadStateException异常（即同一个Thread不能重复调start（）方法）
二、通过实现Runnable接口来创建线程
①定义Runnable接口实现类，重写run（）方法
②创建Runnable实现类的实例，将实例对象传递给Thread类的target来创建线程对象（构造器声明：Thread（Runnable target）、Thread（Runnable target，String name），target是其run（）方法被调用的对象，name是线程名称）
③调用start（）方法启动线程

Public class TestRunnable{
    Public static void main(String[] args){
        SubThread st = new SubThread();//创建SubThread实例
        new Thread(st,"线程1").start;//创建并开启线程对象
        new Thread(st,"线程2").start;
    }
}
class SubThread extends Thread{
    Public void run(){//重写run（）方法
        for(int i = 0; i < 4; i++){
            if(i % 2 != 0){
               System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
}

避免了Java单继承的局限性，如需访问当前线程，则必须使用Thread.currentThread()方法
三、通过Callable和Future接口来创建线程（套娃警告）
①定义Callable接口实现类，指定返回值类型，重写call（）方法
②创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call（）方法的返回值
③将FutureTask对象传递给Thread类的target来创建线程对象，调用start（）方法启动线程
④调用FutureTask对象的get（）方法来获取子线程的返回值
注：FutureTask为Future接口的实现类，它实现了Runnable接口，可以作为Thread类的target；Callable接口的实现类不能，因为Callable接口不是Runnable接口的子接口

import java.util.concurrent.*;
Public class TestCallable{
    Public static void main(String[] args){
          //创建myCallable对象
          Callable<Integer> myCallable = new SubThread();
          //使用FutureTask来包装myCallable对象
          FutureTask<Integer> ft = new FutureTask<Integer>(myCallable);
          for(int i = 0; i < 4; i ++){
              System.out.println(Thread.currentThread().getName() + ":" + i);
              if(i == 1){
                  //FutureTask对象作为Thread对象的target创建新的线程
                  Thread thread = new Thread（ft）;
                  thread.start();//启动线程
              }
          }
          System.out.println("主线程for循环执行完毕");
          try{
              int sum = ft.get();
              System.out.println("sum = " + sum);
          }catch(InterruptedException e){
              e.printStackTrace();
          }catch(ExecutionException e){
              e.printStackTrace();
          }
    }
}
class SubThread implements Callable<Integer>{
    private int i = 0;
    Public Integer call() throws Exception{
         int sum = 0;
         for(i = 0; i < 4; i++){
             System.out.println(Thread.currentThread().getName() + ":" + i);
             sum += 1;
         }
    }
}

避免了Java单继承的局限性，如需访问当前线程，则必须使用Thread.currentThread()方法,有返回值，可抛出异常