JAVA多线程实现方式

1. 楔子

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

2.继承Thread

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

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);
    }
}

结果:
在这里插入图片描述
ScheduledExecutorService详细用法参考: 深入理解Java线程池:ScheduledThreadPoolExecutor

7.Spring方式:使用Spring来实现多线程

这种方式依赖于Spring3以上版本,我们可以通过Spring的@Async注解非常方便的实现多线程。具体的使用方式见 Spring Boot 对多线程支持-提高程序执行效率

参考文献

©️2020 CSDN 皮肤主题: 技术黑板 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值