一、多线程实现了什么?

为了解决负载均衡问题,充分利用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