java使用多种方式实现多线程及线程池的使用

本文主要是介绍java使用多种方式实现多线程及线程池的使用，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

一、多线程实现了什么？

为了解决负载均衡问题,充分利用CPU资源.为了提高CPU的使用率,采用多线程的方式去同时完成几件事情而不互相干扰.为了处理大量的IO操作时或处理的情况需要花费大量的时间等等,比如:读写文件,视频图像的采集,处理,显示,保存等

二、多线程的使用

在java中，多线程得主要实现方式有四种：继承Thread类，实现Runnable接口、实现callable接口通过FutureTask包装器来创建Thread线程，使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，而后两种是带返回值的。除此之外，通过Timer启动定时任务，或者通过像Spring Task和quartz这样的第三方任务调度框架也可以开启多线程任务

1、继承Thread类创建线程

Thread类本质上也是实现了Runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程比较简单，通过继承Thread类并复写run()方法，就可以启动新线程并执行自己定义的run()方法。

public class ThreadDemo extends Thread {
    
    public ThreadDemo(String name) {
        // 设置当前线程的名字
        this.setName(name);
    }
    
    @Override
    public void run() {
        System.out.println("当前运行的线程名为： " + Thread.currentThread().getName());
    }
    
    public static void main(String[] args) throws Exception {
        // 注意这里，要调用start方法才能启动线程，不能调用run方法
        new ThreadDemo("MyThreadOne").start();
        new ThreadDemo("MyThreadTwo").start();
        
    }
    
}

输出结果：

当前运行的线程名为： MyThreadOne
当前运行的线程名为： MyThreadTwo

2、实现Runnable接口创建线程 由于Java是单继承机制，如果自己的类已经继承自另一个类，则无法再直接继承Thread类，此时，可以通过实现Runnable接口来实现多线程。

实现Runnable接口并实现其中的run方法，然后通过构造Thread实例，传入Runnable实现类，然后调用Thread的start方法即可开启一个新线程。

public class MyRunnable implements Runnable {
    
    @Override
    public void run() {
        System.out.println("当前运行的线程名为： " + Thread.currentThread().getName());
    }
    
    public static void main(String[] args) throws Exception {
        MyRunnable runnable = new MyRunnable();
        new Thread(runnable, "MyThreadOne").start();
        new Thread(runnable, "MyThreadTwo").start();
        
    }
    
}

输出结果：

当前运行的线程名为： MyThreadOne
当前运行的线程名为： MyThreadTwo

3、实现Callable接口通过FutureTask包装器来创建Thread线程

首先需要一个实现Callable接口的实例，然后实现该接口的唯一方法call逻辑，接着把Callable实例包装成FutureTask传递给Thread实例启动新线程。FutureTask本质上也实现了Runnable接口，所以同样可以用来构造Thread实例。

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

public class MyCallable {
    
    public static void main(String[] args) throws Exception {
        // 创建线程任务，lambada方式实现接口并实现call方法
        Callable<Integer> callable = () -> {
            System.out.println("线程任务开始执行了...");
            Thread.sleep(2000);
            return 1;
        };
        
        // 将任务封装为FutureTask
        FutureTask<Integer> task = new FutureTask<>(callable);
        
        // 开启线程，执行线程任务
        new Thread(task).start();
        
        // ====================
        // 这里是在线程启动之后，线程结果返回之前
        System.out.println("线程启动之后，线程结果返回之前...");
        // ====================
        
        // 为所欲为完毕之后，拿到线程的执行结果
        Integer result = task.get();
        System.out.println("主线程中拿到异步任务执行的结果为：" + result);
        
    }
    
}

运行结果：

线程启动之后，线程结果返回之前...
线程任务开始执行了...
主线程中拿到异步任务执行的结果为：1

4、使用ExecutorService、Callable、Future实现有返回结果的线程（线程池方式）

ExecutorService、Callable、Future三个接口都是属于Executor框架。可返回值的任务必须实现Callable接口。通过ExecutorService执行Callable任务后，可以获取到一个Future的对象，在该对象上调用get()就可以获取到Callable任务返回的结果了。

注意：Future的get方法是阻塞的，即：线程无返回结果，get方法会一直等待。

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CreateThreadDemo4 {
    
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("---- 主程序开始运行 ----");
        Date startTime = new Date();
        
        int taskSize = 5;
        // 创建一个线程池,Executors提供了创建各种类型线程池的方法，具体详情请自行查阅
        ExecutorService executorService = Executors.newFixedThreadPool(taskSize);
        
        // 创建多个有返回值的任务
        List<Future> futureList = new ArrayList<Future>();
        for (int i = 0; i < taskSize; i++) {
            Callable callable = new MyCallable(i);
            // 执行任务并获取Future对象
            Future future = executorService.submit(callable);
            futureList.add(future);
        }
        
        // 关闭线程池
        executorService.shutdown();

        // 获取所有并发任务的运行结果
        for (Future future : futureList) {
            // 从Future对象上获取任务的返回值，并输出到控制台
            System.out.println(">>> " + future.get().toString());
        }

        Date endTime = new Date();
        System.out.println("---- 主程序结束运行 ----，程序运行耗时【" + (endTime.getTime() - startTime.getTime()) + "毫秒】");
    }
}

class MyCallable implements Callable<Object> {
    private int taskNum;

    MyCallable(int taskNum) {
        this.taskNum = taskNum;
    }

    public Object call() throws Exception {
        System.out.println(">>> " + taskNum + " 线程任务启动");
        Date startTime = new Date();
        Thread.sleep(1000);
        Date endTime = new Date();
        long time = endTime.getTime() - startTime.getTime();
        System.out.println(">>> " + taskNum + " 线程任务终止");
        return taskNum + "线程任务返回运行结果, 当前任务耗时【" + time + "毫秒】";
    }
}

输出结果：

---- 主程序开始运行 ----
>>> 0 线程任务启动
>>> 1 线程任务启动
>>> 2 线程任务启动
>>> 3 线程任务启动
>>> 4 线程任务启动
>>> 0 线程任务终止
>>> 1 线程任务终止
>>> 0线程任务返回运行结果, 当前任务耗时【1001毫秒】
>>> 1线程任务返回运行结果, 当前任务耗时【1001毫秒】
>>> 4 线程任务终止
>>> 3 线程任务终止
>>> 2 线程任务终止
>>> 2线程任务返回运行结果, 当前任务耗时【1001毫秒】
>>> 3线程任务返回运行结果, 当前任务耗时【1001毫秒】
>>> 4线程任务返回运行结果, 当前任务耗时【1001毫秒】
---- 主程序结束运行 ----，程序运行耗时【1009毫秒】

5、其他创建线程的方式

当然，除了以上四种主要的线程创建方式之外，也还有很多其他的方式可以启动多线程任务。比如通过Timer启动定时任务，或者通过像Spring Task和quartz这样的第三方任务调度框架也可以开启多线程任务，关于第三方任务调度框架的例子还请查询相关资料。

三、java中线程池得使用

1、为什么不适用 new Thread？

首先从我秉持的原则入手，“简洁优雅”。试想如果在一段代码中你需要创建很多线程，那么你就不停地调用 new Thread(...).start() 么？显然这样的代码一点也不简洁，也不优雅。初次之外这样的代码还有很多坏处：

每次都要新建一个对象，性能差；建出来的很多个对象是独立的，缺乏统一的管理。如果在代码中无限新建线程会导致这些线程相互竞争，占用过多的系统资源从而导致死机或者 oom；缺乏许多功能如定时执行、中断等。

从这些坏处很容易可以看出解决方法，那就是弄一个监管者来统一的管理这些线程，并将它们存到一个集合（或者类似的数据结构）中，而且还要动态地分配它们的任务。当然Java已经给我们提供好十分健全的东西来使用了，那就是线程池！

Java线程池 Java提供了一个工厂类来构造我们需要的线程池，这个工厂类就是 Executors 。这个类提供了很多方法，我们这里主要讲它提供的4个创建线程池的方法，即

newCachedThreadPool() newFixedThreadPool(int nThreads) newScheduledThreadPool(int corePoolSize) newSingleThreadExecutor()

newCachedThreadPool：这个方法正如它的名字一样，创建一个可缓存的无界线程池，如果线程池长度超过处理需要，可灵活回收空线程，若无可回收，则新建线程。当线程池中的线程空闲时间超过60s，则会自动回收该线程，当任务超过线程池的线程数则创建新的线程，线程池的大小上限为Integer.MAX_VALUE,可看作无限大。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 可缓存无界线程池测试 
 * 当线程池中的线程空闲时间超过60s则会自动回收该线程，核心线程数为0 
 * 当任务超过线程池的线程数则创建新线程。线程池的大小上限为Integer.MAX_VALUE， 
 * 可看做是无限大。
 */

public class newCachedThreadPool {
    
    public static void main(String[] args) {
        // 创建可缓存的无界线程池
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool(); // 创建缓存线程池
        
        for (int i = 0; i < 10; i++) {
            final int index = i;
            
            // 每次发布任务前等待一段时间，如1s
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
            // 执行任务
            cachedThreadPool.execute(() -> System.out.println(Thread.currentThread().getName() + ":" + index));
        }
    }
}

输出结果：

pool-1-thread-1:0
pool-1-thread-1:1
pool-1-thread-1:2
pool-1-thread-1:3
pool-1-thread-1:4
pool-1-thread-1:5
pool-1-thread-1:6
pool-1-thread-1:7
pool-1-thread-1:8
pool-1-thread-1:9

newFixedThreadPool(int nThreads)

创建一个指定大小的线程池，可以看到这个方法中带了一个参数，这个方法创建的线程池是定长的，这个参数就是线程池的大小。也就是说，在同一时间执行的线程数量只能是 nThreads 这么多，这个线程池可以有效的控制最大并发数从而防止占用过多资源。超出的线程会放在线程池的一个队列里等待其他线程执行完，它是一个无界队列

/**
 * 创建固定线程数量的线程池测试
 * 创建一个固定大小的线程池，该方法可指定线程池的固定大小，对于超出的线程会在LinkedBlockingQueue队列中等待
 * 核心线程数可以指定，线程空闲时间为0
 */
public class newFixedThreadPool {
    
    public static void main(String[] args) {
        
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3); // 创建缓存线程池，大小为3
        
        for (int i = 0; i < 10; i++) {
            final int index = i;
            
            // 每次发布任务前等待一段时间，如1s
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
            // 执行任务
            fixedThreadPool.execute(() -> System.out.println(Thread.currentThread().getName() + ":" + index));
        }
    }
}

输出结果：

pool-1-thread-1:0
pool-1-thread-2:1
pool-1-thread-3:2
pool-1-thread-1:3
pool-1-thread-2:4
pool-1-thread-3:5
pool-1-thread-1:6
pool-1-thread-2:7
pool-1-thread-3:8
pool-1-thread-1:9

可以看到我创建了一个大小为3的线程池，也就是说它支持的最大并发线程数是3，运行后发现这些数确实是3个3个为一组输出的。

合理得设置定长线程池是一件非常重要的事

从 Scheduled 大概可以猜出这个线程池是为了解决上面说过的第3个坏处，也就是缺乏定时执行功能。这个线程池也是定长的，参数 corePoolSize 就是线程池的大小，即在空闲状态下要保留在池中的线程数量。

而要实现调度需要使用这个线程池的 schedule() 方法（注意这里要把新建线程池的返回类 ExecutorService 改成 ScheduledExecutorService 噢）

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class newScheduledThreadPool {
    
    // 执行任务
    
    public static void main(String[] args) {
    
        // 注意！这里把 ExecutorService 改成了 ScheduledExecutorService ，否则没有定时功能
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3); // 创建缓存线程池
        
        for (int i = 0; i < 1; i++) {
            final int index = i;
            
            // 每次发布任务前等待一段时间，如1s
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
            // 执行任务
            scheduledThreadPool.schedule(() -> System.out.println(Thread.currentThread().getName() + ": 我会在3秒后执行。"),
                    3, TimeUnit.SECONDS);
        }
    }
}

输出结果

pool-1-thread-1: 我会在3秒后执行。

newSingleThreadExecutor() 这个线程池就比较简单了，他是一个单线程池，只使用一个线程来执行任务。但是它与 newFixedThreadPool(1, threadFactory) 不同，它会保证创建的这个线程池不会被重新配置为使用其他的线程，也就是说这个线程池里的线程始终如一。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class newSingleThreadExecutor {
    
    public static void main(String[] args) {
        
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor(); // 创建单线程池
        
        for (int i = 0; i < 10; i++) {
            final int index = i;
            
            // 执行任务
            singleThreadExecutor.execute(() -> {
                System.out.println(Thread.currentThread().getName() + ":" + index);
                
                // 模拟执行任务耗时1秒
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }
}

输出结果

pool-1-thread-1:0
pool-1-thread-1:1
pool-1-thread-1:2
pool-1-thread-1:3
pool-1-thread-1:4
pool-1-thread-1:5
pool-1-thread-1:6
pool-1-thread-1:7
pool-1-thread-1:8
pool-1-thread-1:9

这篇关于java使用多种方式实现多线程及线程池的使用的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程

java使用多种方式实现多线程及线程池的使用

newFixedThreadPool(int nThreads)

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯