Java多线程的实现方式

多线程有3种实现的方法

1.     继承Thread类创建线程
2.     实现了Runnable接口接口创建线程
3.     通过可Callable和Futrue创建线程

第一种、继承Thread类创建线程，步骤如下：

1. 创建一个Thread类的子类。
2. 覆盖Thread类的run（）中的方法。
3. 创建所定义的子类的一个对象。
4. 调用该对象的start（）方法启动线程。

public class ThreadDemo extends Thread {

    private Thread t;
    private String threadName;

    ThreadDemo(String name){
        threadName = name;
        System.out.println("Creating " +  threadName );
    }

    @Override
    public void run() {
        System.out.println("Running " +  threadName );
        try {
            for(int i = 4; i > 0; i--) {
                System.out.println("Thread: " + threadName + ", " + i);
                // 让线程睡眠一会
                Thread.sleep(50);
            }
        }catch (InterruptedException e) {
            System.out.println("Thread " +  threadName + " interrupted.");
        }
        System.out.println("Thread " +  threadName + " exiting.");
    }

    public void start () {
        System.out.println("Starting " +  threadName );
        if (t == null) {
            t = new Thread (this, threadName);
            t.start ();
        }
    }
}

第二种、实现Runnable接口创建线程，步骤如下：

1. 定义一个实现Runnable接口的类。
2. 实现接口的run（）中的方法。
3. 用该类的对象作为参数创建Thread类的对象。
4. 调用Thread的start（）方法启动线程。

public class RunnableDemo implements Runnable{
    private Thread t;
    private String threadName;

    RunnableDemo(String name){
        threadName = name;
        System.out.println("Creating " +  threadName );
    }

    @Override
    public void run() {
        System.out.println("Running " +  threadName );
        try {
            for(int i = 4; i > 0; i--) {
                System.out.println("Thread: " + threadName + ", " + i);
                // 让线程睡眠一会
                Thread.sleep(50);
            }
        }catch (InterruptedException e) {
            System.out.println("Thread " +  threadName + " interrupted.");
        }
        System.out.println("Thread " +  threadName + " exiting.");
    }

    public void start () {
        System.out.println("Starting " +  threadName );
        if (t == null) {
            t = new Thread (this, threadName);
            t.start ();
        }
    }
}

第三种 通过可Callable和Futrue创建线程，步骤如下：

1. 定义一个实现Runnable接口的类。
2. 实现接口的call()中的方法。
3. 创建所定义的子类的一个对象。
4. 用FutureTask实现类来接收Callable执行的运算结果。
5. 用FutureTask类的对象作为参数创建Thread类的对象。
   
6. 调用Thread的start（）方法启动线程。
   

public class TestCallable {

    public static void main(String[] args) {

        CallableThreadDemo ctd = new CallableThreadDemo();

        //1.执行Callable方式，需要FutureTask实现类的支持，用于接收运算结果
        FutureTask<Integer> result = new FutureTask<Integer>(ctd);

        new Thread(result).start();

        //2.接收线程运算后的结果
        try {
            Integer sum = result.get(); //FutureTask 可用于闭锁

            System.out.println(sum);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class CallableThreadDemo implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int sum = 0;

        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        return sum;
    }
}