java基础 - 多线程实现

多线程的实现方式（常见四种）

1、继承Thread类，重写run方法。示例代码如下：

package org.example.thread;

import java.util.concurrent.*;

public class ThreadTest {

    public static void main(String[] args) {
        Producer producer = new Producer();
        producer.start();
    }
}

class Producer extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("生产" + i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

2、实现Runnable接口，重写run方法。示例代码如下：

package org.example.thread;

public class ThreadTest {

    public static void main(String[] args) {
        Producer producer = new Producer();
        new Thread(producer).start();
    }
}

class Producer implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("生产" + i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

3、实现Callable接口，重写call方法，然后结合FutureTask类创建线程。示例代码如下：

package org.example.thread;

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

public class ThreadTest {

    public static void main(String[] args) {
        Producer producer = new Producer();
        FutureTask<String> futureTask = new FutureTask<>(producer);
        new Thread(futureTask).start();

        //获取线程返回值
        try {
            String result = futureTask.get();
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            throw new RuntimeException(e);
        }
    }
}

class Producer implements Callable<String> {

    @Override
    public String call() {
        for (int i = 0; i < 10; i++) {
            System.out.println("生产" + i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        return "线程执行完毕";
    }
}

Producer类实现了Callable接口，重写了带返回值的call方法，但是Thread类的构造函数不接受Callable类型的参数，所以这里用到FutureTask这个泛型类进行串联。

FutureTask类同时实现了Runnable接口 和 Future接口，可以传入Thread类构造函数来创建线程；同时它内部有一个Callable类型的成员变量可以通过构造函数进行赋值，线程运行时调用的run方法内部又调用了该Callable成员的call方法，而call方法正是我们可以自己实现的。这样Callable接口、Runnable接口 和 Thread类就被FutureTask这个类串起来了。

Future是用来检查和获取异步计算结果的接口。Future接口内部定义了取消任务的cancel方法、获取任务状态的isCancelled、isDone方法 和获取任务返回值的get方法。get方法是阻塞的，需要等任务执行完毕或者达到参数传入的限定时间，才会继续往下走。

4、使用线程池。示例代码如下：

package org.example.thread;

import java.util.concurrent.*;

public class ThreadTest {

    public static void main(String[] args) {

        Producer producer = new Producer();

        ExecutorService threadPool = Executors.newCachedThreadPool();
        threadPool.execute(producer);

        //关闭线程池，该方法会等待所有任务执行完毕后关闭。
        threadPool.shutdown();
    }
}

class Producer implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("生产" + i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}