JAVA多线程实现方式

最新推荐文章于 2024-08-15 23:35:35 发布

jieniyimiao

最新推荐文章于 2024-08-15 23:35:35 发布

阅读量576

点赞数 1

分类专栏： JAVA java核心技术文章标签： JAVA多线程实现方式 ScheduledExecutorService ExecutorService Callable Thread

本文链接：https://blog.csdn.net/u013467442/article/details/89344477

版权

JAVA 同时被 2 个专栏收录

82 篇文章 5 订阅

订阅专栏

java核心技术

10 篇文章 1 订阅

订阅专栏

1. 楔子

java有多种方式实现多线程，比如继承Thread类或实现Runnable接口创建无返回值的多线程、使用ExecutorService、Callable、Future实现有返回结果的多线程等，这些该具体如何实现？各有什么不同？在什么样的场景下使用哪种方式比较好？本文就来探讨这些问题。

2.继承Thread

Thread本质上也是实现了Runnable接口，他是Runnable的一个实例，本质上可以归为Runnable。Thread类声明如下：

public
class Thread implements Runnable {...}

Runnable接口中只有一个run接口，代表线程要执行的操作，声明如下：

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

启动线程的唯一方法就是通过Thread类的start()方法。它将启动一个新线程，并执行run()方法。
通过自己的类直接extends Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。
示例代码如下：

public class ThreadForExtend extends Thread {
    @Override
    public void run() {
        System.out.println("this thead for extends thead!");
        System.out.println(Thread.currentThread().getName());
    }

    // 设置线程名字
    public ThreadForExtend(String name) {
        this.setName(name);
    }

    public static void main(String[] args) throws InterruptedException {
        System.out.println("--step1--");
        ThreadForExtend t = new ThreadForExtend("thread-threadForExtend");
        t.start();
        System.out.println("--step2--");
        TimeUnit.SECONDS.sleep(2);
        System.out.println(Thread.currentThread().getName());
        System.out.println("--step3--");
    }
}

结果如下：
在这里插入图片描述

注：这里实际上是采用了设计模式中的模板方法模式，Thread类作为模板，而run方法是在变化的，因此放到子类来实现

3. 实现Runnable接口

如果自己的类已经extends另一个类，就无法直接extends Thread，此时，必须通过实现Runnable接口来创建线程。
启动Runnable 实例时，需要放在Thread中，然后调用 start() 方法.

示例代码如下：

public class ThreadForRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("thread for runnable!");
    }

    public static void main(String[] args) throws InterruptedException {
        System.out.println("--step1--");
        Thread t = new Thread(new ThreadForRunnable());
        t.start();
        System.out.println("--step2--");
        TimeUnit.SECONDS.sleep(2);
        System.out.println("--step3--");
    }
}

结果如下
在这里插入图片描述
main为主线程，在主线程外创建了一个另外一个线程。
如果不指定线程名字，系统会默认指定线程名，命名规则是Thread-N的形式。但是为了排查问题方便，建议在创建线程的时候指定一个合理的线程名字。

4. 使用内部类的方式

这并不是一种新的实现线程的方式，只是另外的一种写法。比如有些情况我们的线程就想执行一次，以后就用不到了。那么像上面两种方式（继承Thread类和实现Runnable接口）都还要再定义一个类，显得比较麻烦，我们就可以通过匿名内部类的方式来实现。使用内部类实现依然有两种，分别是继承Thread类和实现Runnable接口。代码如下：

public class ThreadForAnonymous {
    public static void main(String[] args) {
        // 基于接口的实现
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    printThreadInfo();
                }
            }
        }).start();

        // 基于子类的方式
        new Thread() {
            @Override
            public void run() {
                while (true) {
                    printThreadInfo();
                }
            }
        }.start();
    }

    /**
     * 输出当前线程的信息
     */
    private static void printThreadInfo() {
        System.out.println("当前运行的线程名为： " + Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

结果如下：
在这里插入图片描述
lambda 方式改造
刚才使用匿名内部类，会发现代码还是比较冗余的，lambda可以大大简化代码的编写。用lambda来改写上面的基于接口的形式的代码，如下

        new Thread(() -> {
            while (true) {
                printThreadInfo();
            }
        }).start();

5.使用ExecutorService、Callable、Future实现有返回结果的多线程

我们知道，线程和数据库连接这些资源都是非常宝贵的资源。那么每次需要的时候创建，不需要的时候销毁，是非常浪费资源的。那么我们就可以使用缓存的策略，也就是使用线程池。

需要开启新线程执行有返回值的任务必须实现Callable接口。
执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object结果了。
结合线程池接口ExecutorService就可以实现有返回结果的多线程了。

实例如下所示：

public class ThreadForCallable {

    public static void main(String[] args) throws Exception {
        int poolSize = 5;
        //创建固定数目线程的线程池
        ExecutorService threadPoll = Executors.newFixedThreadPool(poolSize);
        List<Future<Object>> futures = new ArrayList<>();
        //创建多个Task
        for (int i = 0; i < poolSize; i ++) {
            MyTask task = new MyTask("No" + i);
            //放入线程池中执行任务并取得返回值
            Future<Object> future = threadPoll.submit(task);
            futures.add(future);
        }

        //关闭线程池，但是执行的线程还需要继续执行
        threadPoll.shutdown();
        System.out.println("--start--");

        //输出所有结果(会阻塞等待当前线程的返回结果)
        for(Future<Object> f : futures) {
            System.out.println(f.get(10, TimeUnit.SECONDS).toString());
        }
    }

   private static class MyTask implements Callable<Object> {
        private String taskNo;

        public MyTask(String taskNo) {
            this.taskNo = taskNo;
        }

        @Override
        public Object call() throws InterruptedException {
            System.out.println("任务 " + taskNo + " 启动了...");
            Date startTime = new Date();
            TimeUnit.SECONDS.sleep(5);
            Date endTime = new Date();
            long costTime = endTime.getTime() - startTime.getTime();
            System.out.println("任务 " + taskNo + " 执行完毕.");

            //返回值
            return taskNo + " 任务返回运行结果, 任务执行耗费时间【" + costTime + "毫秒】";
        }
    }
}

结果如下：
在这里插入图片描述
说明：

ExecutoreService提供了submit()方法，传递一个Callable，或Runnable，返回Future。如果Executor后台线程池还没有完成Callable的计算，这调用返回Future对象的get()方法，会阻塞直到计算完成。
Future 接口 get() 方法
Future 接口提供了一个特殊的阻塞方法 get()，它返回 Callable 任务执行的实际结果，但如果是 Runnable 任务，则只会返回 null。
因为 get() 方法是阻塞的。如果调用 get() 方法时任务仍在运行，那么调用将会一直被执阻塞，直到任务正确执行完毕并且结果可用时才返回。
再介绍Executors类：
提供了一系列工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口。
public static ExecutorService newFixedThreadPool(int nThreads)创建固定数目线程的线程池。
public static ExecutorService newCachedThreadPool()创建一个可缓存的线程池，调用execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
public static ExecutorService newSingleThreadExecutor()创建一个单线程化的Executor。
public static ScheduledExecutorService newScheduledThreadPool(intcorePoolSize)创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。

不使用线程池的有返回值的线程创建示例代码如下：

public class ThreadForNoPool {
    public static void main(String[] args) throws Exception {
        // 创建线程任务
        Callable<Integer> call = () -> {
            System.out.println("线程任务开始执行了....");
            Thread.sleep(2000);
            return 1;
        };

        // 将任务封装为FutureTask
        FutureTask<Integer> task = new FutureTask<>(call);

        // 开启线程，执行线程任务
        new Thread(task).start();

        // ====================
        // 这里是在线程启动之后，线程结果返回之前
        System.out.println("这里可以为所欲为....");
        // ====================

        // 为所欲为完毕之后，拿到线程的执行结果
        Integer result = task.get();
        System.out.println("主线程中拿到异步任务执行的结果为：" + result);
    }
}

在这里插入图片描述

6.定时器

定时器可以说是一种基于线程的一个工具类，可以定时的来执行某个任务。在应用中经常需要定期执行一些操作，比如要在凌晨的时候汇总一些数据，比如要每隔10分钟抓取一次某个网站上的数据等等，总之计时器无处不在。

在Java中实现定时任务有很多种方式，JDK提供了Timer类来帮助开发者创建定时任务，另外也有很多的第三方框架提供了对定时任务的支持，比如Spring的schedule以及著名的quartz等等。因为Spring和quartz实现都比较重，依赖其他的包，上手稍微有些难度，不在本篇博客的讨论范围之内，这里就看一下JDK所给我们提供的API来实现定时任务。
实例如下所示：

package com.sino.daily.code_2019_4_16;

import org.joda.time.DateTime;

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

/**
 * Created on 2019/4/17 14:32.
 *
 * @author caogu
 */
public class ThreadForTimer {
    public static void main(String[] args) throws InterruptedException {
        Timer timer = new Timer();
        //指定时间点执行
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("指定时间点执行");
            }
        }, DateTime.now().plusSeconds(5).toDate());

        //间隔时间重复执行
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("间隔时间重复执行");
            }
        }, new Date(), 2000);

        Thread.sleep(10000);
        // 不取消线程会一值存在
        timer.cancel();
    }
}

结果：
在这里插入图片描述
TimerTask 也是Runnable 接口的实例：

public abstract class TimerTask implements Runnable {}

6 番外：定时器改进

在这里插入图片描述
自JDK1.5开始，JDK提供了ScheduledThreadPoolExecutor类来支持周期性任务的调度。在这之前的实现需要依靠Timer和TimerTask或者其它第三方工具来完成。但Timer有不少的缺陷，比如：

Timer是单线程模式；
如果在执行任务期间某个TimerTask耗时较久，那么就会影响其它任务的调度；
Timer的任务调度是基于绝对时间的，对系统时间敏感；
Timer不会捕获执行TimerTask时所抛出的异常，由于Timer是单线程，所以一旦出现异常，则线程就会终止，其他任务也得不到执行

ScheduledExecutorService的主要作用就是可以将定时任务与线程池功能结合使用,来重用线程池的功能。用来替换Timer和TimerTask的实现方式。

public class ScheduledExecutorServiceTest {
    public static void main(String[] args) {
        //立刻执行，而且每隔1000毫秒执行一次。
        ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
        executorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("run "+ System.currentTimeMillis());
            }
        }, 0, 1000, TimeUnit.MILLISECONDS);
    }
}