1.什么是线程，多线程
线程 : 是操作系统能够进行运算调度的最小单位；它被包含在进程之中，是进程中的实际运作单位。
多线程 : 是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。
简单来说：线程是程序中一个单一的顺序控制流程；而多线程就是在单个程序中同时运行多个线程来完成不同的工作。
多线程的作用：是为了同步完成多项任务，不是为了提高运行效率，而是为了提高资源使用效率来提高系统的效率。多线程是在同一时间需要完成多项任务的时候实现的。
2.多线程的优缺点
优点：
1）、多线程技术可以加快程序的运行速度，使程序的响应速度更快，因为用户界面可以在进行其它工作的同时一直处于活动状态
2）、可以把占据长时间的程序中的任务放到后台去处理，同时执行其他操作，提高效率
3）、当前没有进行处理的任务时可以将处理器时间让给其它任务
4）、可以让同一个程序的不同部分并发执行，释放一些珍贵的资源如内存占用等等
5）、可以随时停止任务
6）、可以分别设置各个任务的优先级以优化性能
缺点：
1）、因为多线程需要开辟内存，而且线程切换需要时间因此会很消耗系统内存。
2）、线程的终止会对程序产生影响
3）、由于多个线程之间存在共享数据，因此容易出现线程死锁的情况
4）、对线程进行管理要求额外的 CPU开销。线程的使用会给系统带来上下文切换的额外负担。
3.多线程的实现方式有哪些
1. 继承Thread类，重写run方法
2.实现Runnable接口，重写run方法，实现Runnable接口的实现类的实例对象作为Thread构造函数的target（无返回值）
3.实现Callable接口，通过Callable和FutureTask创建线程 （有返回值）
4.线程池：提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提高了响应的速度。
5.CompletableFuture，JDK1.8中的CompletableFuture为我们提供了异步函数式编程,CompletableFuture提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合CompletableFuture的方法。
6.Spring的@Async注解
4.体系结构
java.util.concurrent.Executor : 负责线程的使用与调度的根接口
|--ExecutorService 子接口: 线程池的主要接口
|--ThreadPoolExecutor 线程池的实现类
|--ScheduledExecutorService 子接口：负责线程的调度
|--ScheduledThreadPoolExecutor ：继承 ThreadPoolExecutor， 实现 ScheduledExecutorService *
工具类 : Executors
ExecutorService newFixedThreadPool() : 创建固定大小的线程池
ExecutorService newCachedThreadPool() : 缓存线程池，线程池的数量不固定，可以根据需求自动的更改数量。
ExecutorService newSingleThreadExecutor() : 创建单个线程池。线程池中只有一个线程
ScheduledExecutorService newScheduledThreadPool() : 创建固定大小的线程，可以延迟或定时的执行任务。
5.代码示例
public class TestThread {
public static void main(String[]args)throws Exception {
//1.继承Thread类
ThreadTest threadTest =new ThreadTest();
threadTest.start();
//2.实现Runnable接口
RunnableTest runnableTest =new RunnableTest();
new Thread(runnableTest).start();
//3.实现Callable接口
CallableTest callableTest =new CallableTest();
FutureTask futureTask =new FutureTask<>(callableTest);
new Thread(futureTask).start();
Listlists = (List)futureTask.get();
for (Integer integer :lists) {
System.out.print(integer +" ");
}
System.out.print(" ");
//4.使用线程池
ThreadPoolTest();
//5.使用CompletableFuture
CompletableFutureTest_runAsync();
CompletableFutureTest_supplyAsync();
}
static class ThreadTest extends Thread{
@Override
public void run() {
for(int i =0 ; i <10 ; i ++) {
if(i %2 ==0) {
System.out.print(i+" ");
}
}
System.out.println(" ");
}
}
static class RunnableTest implements Runnable{
@Override
public void run() {
for(int i =0 ; i <10 ; i ++) {
if(i %3 ==0) {
System.out.print(i+" ");
}
}
System.out.println(" ");
}
}
static class CallableTest implements Callable> {
@Override
public Listcall()throws Exception {
Listlists =new ArrayList<>();
for(int i =3 ; i <100 ; i ++) {
if(i %4 ==0) {
lists.add(i);
}
}
return lists;
}
}
public static void ThreadPoolTest()throws ExecutionException, InterruptedException {
ExecutorService executorService =Executors.newFixedThreadPool(5);
List>>ints =new ArrayList<>();
int[]arr = {10,20,31,40,50};
for(int i =0; i
int finalI =i;
Future>future =executorService.submit(() -> {
System.out.println(Thread.currentThread().getName()+" ");
Listlists =new ArrayList<>();
if(arr[finalI] %10 ==0) {
lists.add(arr[finalI]);
}
return lists;
});
ints.add(future);
}
for (Future>future :ints) {
System.out.println(future.get());
}
}
//无返回值
public static void CompletableFutureTest_runAsync()throws Exception {
CompletableFuturefuture =CompletableFuture.runAsync(() -> {
try {
TimeUnit.SECONDS.sleep(1);
}catch (InterruptedException e) {
}
System.out.println("run end ...");
});
future.get();
}
//有返回值
public static void CompletableFutureTest_supplyAsync()throws Exception {
CompletableFuturefuture =CompletableFuture.supplyAsync(() -> {
try {
TimeUnit.SECONDS.sleep(1);
}catch (InterruptedException e) {
}
System.out.println("run end ...");
return System.currentTimeMillis();
});
long time =future.get();
System.out.println("time = "+time);
}
}
