多线程的几种实现方式

先直接上代码，展示多线程的实现方式。

第一种：实现Runnabel接口。

package com.ceshi.sm;

public class RunnableDemo {
    
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread t = new Thread(myRunnable);
        t.start();
        System.out.println(Thread.currentThread().getName()); //打印线程的名称
    }
    
    
}


class MyRunnable implements Runnable{
    
    //实现Runnale接口，重写run方法
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
    
}

第二种：继承Thread类

package com.ceshi.sm;

public class ThreadDemo {
    
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
        System.out.println(Thread.currentThread().getName()); //打印线程的名称
    }
    
    
}


class MyThread extends Thread{
    
    //实现Runnale接口，重写run方法
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
    
}

第三种：实现Callable接口，通过FutureTask 实现类的支持来实现。

package com.ceshi.sm;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;


public class CallableDemo{

    public static void main(String[] args) {
        MyCallable myCallable = new MyCallable();
        //将myCallable对象作为myCallable的构造函数的参数传入
        FutureTask<Integer> result = new FutureTask<Integer>(myCallable);
        
        Thread t = new Thread(result);
        t.start();
        System.out.println(Thread.currentThread().getName());
        try {
            Integer sum = result.get();
            System.out.println(sum);
            
        } catch (InterruptedException | ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
     }
    
}    

//实现Callable<>接口，重写call方法
class MyCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName());
        int sum = 0;
        for(int i = 0; i < 100000; i++){
            sum += i;
        }
        return Integer.valueOf(sum);
    }
}

前面两种形式大家都比较熟悉，我们来看一下第三种实现形式。

Callable接口的代码比较简单，与Runnable相似，只是方法名和返回值类型不同而已。所以，我们来看一下FutureTask类。

我们可以看出，获得Callable对象后，作为参数创建了匿名内部类sync对象。

由于RunnableFuture接口继承自Runnable接口。所以，FutureTask类要重写run方法，在run方法中最终调用了call方法。