Java面试过程-CSDN博客

本文链接：https://blog.csdn.net/zrhsmile/article/details/140818080

文章目录

华为杭研

多线程

创建线程的几种方式

集成Thread，重写run方法
实现Runnable, 重写run方法；新建Thread，放入Runnable的task

实现Callable，重写call方法；新建FutureTask，获取执行结果

public class CallableTest {
    public static void main(String[] args) throws Exception {

        MyThread mt = new MyThread();

        FutureTask<Integer> result = new FutureTask<Integer>(mt);

        new Thread(result).start();

        // 获取运算结果是同步过程，即 call 方法执行完成，才能获取结果
        Integer sum = result.get();

        System.out.println(sum);
    }
}
class MyThread implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;

        for (int i = 1; i <= 100; i++) {
            sum += i;
        }

        return sum;
    }

}

通过线程池创建线程，线程池和callable的结合[线程池submit提交]

调用第三方接口，一秒只能十次怎么做处理
1. 当在一台机器上时，不用考虑多线程；
  1. 数量和时间计数，每请求一次+1；当时间达到1秒，thread.sleep(1)；另外，当数量达到10次的时候，也sleep（1）
2. 多线程的时候，使用redis分布式锁； redis.setnx() ,时间为1秒，然后，锁的时间为3秒；当请求第三方的reqDTO达到十次时，一次请求；同时，也校验时间；时间休眠
  
  参考文档：接口每秒次数限制
3. 利用滑动窗口实现(用redis实现)
  
  参考文档：滑动窗口限流和滑动窗口限流具体实现
  注： redis.zremrangeByScore(key, ‘-inf’, max)【删除窗口开始前的数据】；redis.zcard(key)计算总数；redis.zadd(key,currentTime,max）添加请求

为什么不能直接Excutors.newFixedThreadPool(5)创建线程池，而用ThreadPoolExecutor

FixedThreadPool和SingleThreadPool：允许的请求队列长度为Integer.MAX_VALUE,可能会堆积大量的请求，从而导致OOM
CachedThreadPool和ScheduledThreadPool：允许的创建线程数量为Integer.MAX_VALUE,可能会创建大量的线程，从而导致OOM。

创建newFixedThreadPool的时候，没有指定LinkedBlockQueue的长度，所以，默认容量是Integer.MAX_VALUE; 可以向队列中无限插入线程，导致OOM

public class MyThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                5,
                2L,
                TimeUnit.SECONDS,
                // 指定阻塞队列长度为3
                new ArrayBlockingQueue<Runnable>(3),
                // 默认的线程工厂
                Executors.defaultThreadFactory(),
                //new ThreadPoolExecutor.AbortPolicy()
                //new ThreadPoolExecutor.CallerRunsPolicy()
                //new ThreadPoolExecutor.DiscardOldestPolicy()
                // 拒绝策略
                new ThreadPoolExecutor.DiscardPolicy()
        );
        //10个顾客请求
        try {
            for (int i = 1; i <= 10; i++) {
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() +
                            "\t 办理业务");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
    }
}

多线程事务回滚
1. 使用线程池，然后，实现callable，callable提交数据
2. 再通过List<Future> 获取service.invokeAll(callableList）的结果
3. 如果有一个失败，利用connection.rollback回滚

参考文档:https://juejin.cn/post/7193672218625179705

forkjoin多任务，怎么获取数据结果。

创建ForkJoinPool,
创建ForkJoinTask task ,创建自己的task类（实现RecursiveTask重写compute方法）
forkJoinPool.submit(task)

和future一样，使用get；

public class ForkJoinTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();

        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinDemo(1L, 100000000L);
        //提交任务
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);
        Long sum = submit.get();

        long end = System.currentTimeMillis();
        System.out.println(end-start);
    }
}

public class ForkJoinDemo extends RecursiveTask<Long> {

    private Long start = 1L;
    private Long end = 100000000L;

    //临界值
    private Long temp = 10000L;

    public ForkJoinDemo(Long start, Long end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        if ((end - start) < temp) {
            // 基本运算
            Long sum = 0L;
            for (Long i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
        }else {
            // ForkJoin
            Long middle = (start + end)/2;
            // 把一个大任务拆分成两个小任务
            ForkJoinDemo task1 = new ForkJoinDemo(start, middle);
            // 把任务压入线程队列
            task1.fork();
            ForkJoinDemo task2 = new ForkJoinDemo(middle+1, end);
            task2.fork();
            return task1.join()+task2.join();
        }
    }
}

参考文档：https://blog.csdn.net/myjess/article/details/121377597

ForkJoinPool与ThreadPoolExecutor的区别
1. ForkJoinPool使用分治算法，任务窃取进行任务拆分；ThreadPoolExecutor是任务顺序执行
2. 自动处理线程数，自动并行
3. 参考文档：ForkJoinPool与ThreadPoolExecutor的对比与选择_forkjoinpool threadpoolexecutor-CSDN博客
多任务顺序之行
1. 创建多个线程，每个线程start方法，再调用join方法
2. ✅有三个线程T1,T2,T3如何保证顺序执行？
并行任务，CompletableFuture
1. allOf等待所有子任务结束
2. 参考文档:CompletableFuture 详解
主线程等待子任务结束再执行，多种实现方式
1. 和8类似
多线程的令牌，漏桶算法
参考文档：✅漏桶和令牌桶有啥区别？
guva的RateLimiter创建令牌桶 https://segmentfault.com/a/1190000044488582