线程及线程池学习

1 线程和进程的区别？

进程：进程指正在运行的程序。

线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。同一个进程中的多个线程之间可以并发的执行。

2 创建线程有哪几种方式？

创建线程有三种方式：

继承 Thread 重写 run 方法；

实现 Runnable 接口；

实现 Callable 接口。

3 runnable和callable的区别

3.1相同点

都是接口

都可以编写多线程程序

都采用Thread.start()启动线程

3.2不同点

Runnable没有返回值；Callable可以返回执行结果，是个泛型，和Future、

FutureTask配合可以用来获取异步执行的结果

Callable接口的call()方法允许抛出异常；Runnable的run()方法异常只能在内部消化，不能往上继续抛

注：Callalbe接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

4 线程同步的方式

线程同步的方式有两种：

• 方式1：同步代码块

• 方式2：同步方法

同步代码块: 在代码块声明上 加上synchronized

synchronized (锁对象) {

可能会产生线程安全问题的代码

}

同步方法：在方法声明上加上synchronized

5 线程池

线程池，主要是管理线程，具有如下的优势：

（1）降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

（2）提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。

（3）提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

5.1 线程池的七大参数

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    //...
}

这 7 个参数分别是：

corePoolSize：核心线程数。是指线程池中长期存活的线程数

maximumPoolSize：最大线程数。线程池允许创建的最大线程数量，当线程池的任务队列满了之后，可以创建的最大线程数。

keepAliveTime：空闲线程存活时间。空闲线程存活时间，当线程池中没有任务时，会销毁一些线程，销毁的线程数=maximumPoolSize（最大线程数）-corePoolSize（核心线程数）。

TimeUnit：时间单位。空闲线程存活时间的描述单位，

BlockingQueue：线程池任务队列。线程池存放任务的队列，用来存储线程池的所有待执行任务。

ThreadFactory：创建线程的工厂。线程池创建线程时调用的工厂方法，通过此方法可以设置线程的优先级、线程命名规则以及线程类型（用户线程还是守护线程）等。

RejectedExecutionHandler：拒绝策略。当线程池的任务超出线程池队列可以存储的最大值之后，执行的策略。

默认的拒绝策略有以下 4 种：

• AbortPolicy：拒绝并抛出异常。

• CallerRunsPolicy：使用当前调用的线程来执行此任务。

• DiscardOldestPolicy：抛弃队列头部（最旧）的一个任务，并执行当前任务。

• DiscardPolicy：忽略并抛弃当前任务。

线程池的默认策略是 AbortPolicy 拒绝并抛出异常。

6 案例

一 创建线程池

package com.yty.system.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import org.springframework.core.task.TaskExecutor;
import java.util.concurrent.ThreadPoolExecutor;

@Configuration
public class ExecutorConfig {

    @Bean("taskExecutor1")
    public TaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        //设置线程池参数信息
        // 核心线程数
        taskExecutor.setCorePoolSize(3);
        // 最大线程数
        taskExecutor.setMaxPoolSize(4);
        // 线程队列数量
        taskExecutor.setQueueCapacity(2);
        // 空闲线程存活时间（秒）
        taskExecutor.setKeepAliveSeconds(60);
        // 线程名称前缀
        taskExecutor.setThreadNamePrefix("myExecutor--");
        // 线程执行完关闭
        taskExecutor.setWaitForTasksToCompleteOnShutdown(true);
        taskExecutor.setAwaitTerminationSeconds(60);
        // 修改拒绝策略为使用当前线程执行
        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        //初始化线程池
        taskExecutor.initialize();
        return taskExecutor;
    }

}

案例1：使用CompletableFuture.runAsync无返回值方式

import com.yty.system.entity.AccountInfo;
import com.yty.system.entity.vo.R;
import io.swagger.annotations.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.core.task.TaskExecutor;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;

/**
 * 

 *  前端控制器
 * 
 *
 * @author 
 * @since 2022-06-12
 */
@RestController
@RequestMapping("/user")
@Api(tags = "用户管理API")
public class UserController {

    @Autowired
    @Qualifier("taskExecutor1")
    private TaskExecutor taskExecutor;

    @GetMapping("listAsync")
    public R listAsync(int a) {
        long start = System.currentTimeMillis();
        CompletableFuture[] cf = new CompletableFuture[a];
        for (int i = 0; i < a; i++) {
            int finalI = i;
            cf[i] = CompletableFuture.runAsync(() -> {
                getA(finalI);
            }, taskExecutor);
        }
        // 是否执行完毕
        CompletableFuture.allOf(cf).join();
        long end = System.currentTimeMillis();
        String s = "总共耗时" + (end - start) + "毫秒";
        System.out.println(s);
        return R.ok(s);
    }

    private void getA(int i) {
        try {
            System.out.println("---------" + i);
            Thread.sleep(1000L);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

案例2：CompletableFuture.supplyAsync等待返回结果

import com.system.entity.AccountInfo;
import com.system.entity.vo.R;
import io.swagger.annotations.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.core.task.TaskExecutor;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;

/**
 * 

 *  前端控制器
 * 
 *
 * @author 1111
 * @since 2022-06-12
 */
@RestController
@RequestMapping("/user")
@Api(tags = "用户管理API")
public class UserController {

    @Autowired
    @Qualifier("taskExecutor")
    private TaskExecutor taskExecutor;

    @GetMapping("listAsync")
    public R listAsync1(int a) {
        long start = System.currentTimeMillis();
        // 返回结果
        List results = new ArrayList<>();
        // 数据
        List datas = new ArrayList();
        for (int i = 0; i < a; i++) {
            datas.add(i);
        }
        // 异步处理
        CompletableFuture[] cf = datas.stream().map(data -> CompletableFuture.supplyAsync(() -> {
            return getDataById(data);
        }, taskExecutor).thenApply(r -> r).whenComplete((d, e) -> results.add(d))).toArray(CompletableFuture[]::new);
        CompletableFuture.allOf(cf).join();
        long end = System.currentTimeMillis();
        String s = "总共耗时" + (end - start) + "毫秒";
        System.out.println(s);
        System.out.println("返回数据：" + results);
        return R.ok(s);
    }

    private static String getDataById(Integer id) {
        System.out.println("getDataById: "+ id + "---" + Thread.currentThread().getName());
        try {
            Thread.sleep(1000L);
            return id+"";
        }catch (Exception e) {
            e.printStackTrace();
        }
        return "99";
    }
}