多线程几种实现方法

四种方法：

1. 继承Thread

2. 实现Runnable

   -----------------------------------jdk5.0分割线--------------------------------------

3. 实现Callable(有返回值)，可抛出捕获异常，借助FutureTask类。

4. 用线程池ExecutorService和Executors

继承Thread

1. 创建其子类
2. 重写其run方法
3. 创建子类对象
4. 用子类对象调用start方法

public clas MyThread extends Thread{
    public void run(){
        System.out.println("MyThread.run()");
    }
}


//main中即可启动
Mythread thread = new MyThread();
thread.start();

实现Runnable接口

• 创建实现类并重写其中run方法
• 创建实现类对象
• 用此对象作参数传递到Thread（）中，创建thread对象
• 用此thread对象调用start方法

如果一个类已经extends另一个类，就无法直接extends Thread。此时必须实现一个Runnable接口

public class MyThread extends OtherClass implements Runnable {
　　public void run() {
　　 System.out.println("MyThread.run()");
　　}
}

想要启动MyThread，必须新建一个Thread对象，并且将自己的MyThread实例当做参数传入。

MyThread myThread = new MyThread();
Thread thread = new Thread(myThread);

thread.start();

实现Callable接口

1. 创建一个Callable实现类

2. 实现call方法，将此线程需要的操作声明在call方法中。

3. 创建Callable接口实现类的对象。

4. 将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask对象

5. 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start（）；

6. 如果对返回值感兴趣，可以获取Callable中call方法的返回值。

   import java.util.concurrent.Callable;
   import java.util.concurrent.ExecutionException;
   import java.util.concurrent.FutureTask;
   
   /**
    * 创建多线程的方式三：实现Callable接口 ---> JDK 5.0新增
    *
    * 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
    *      1.call()可以有返回值的。
    *      2.call()可以抛出异常，被外面的操作捕获，获取异常的信息
    *      3.Callable是支持泛型的
    *      4.需要借助FutureTask类，比如获取返回结果
    */
   //1.创建一个实现Callable的实现类
   class NumThread implements Callable{
   
       //2.实现call方法，将此线程需要执行的操作声明在call()中
       @Override
       public Object call() throws Exception {
           int sum = 0;
           for(int i = 1;i <= 100;i++){
               if(i % 2 == 0){
                   System.out.println(i);
                   sum += i;
               }
           }
           return sum;
       }
   }
   
   public class ThreadNew {
       public static void main(String[] args) {
           //3.创建Callable接口实现类的对象
           NumThread numThread = new NumThread();
   
           //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
           FutureTask futureTask = new FutureTask(numThread);
   
           //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
           new Thread(futureTask).start();
   
           try {
               //6.获取Callable中call方法的返回值
               //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
               Object sum = futureTask.get();
               System.out.println("总和为:" + sum);
           } catch (InterruptedException e) {
               e.printStackTrace();
           } catch (ExecutionException e) {
               e.printStackTrace();
           }
       }
   }