面试笔记——多线程使用场景

news2024/11/24 14:29:50

线程池使用场景（CountDownLatch， Future）

CountDownLatch
CountDownLatch（闭锁/倒计时锁）用来进行线程同步协作，等待所有线程完成倒计时（一个或者多个线程，等待其他多个线程完成某件事情之后才能执行）。

构造参数用来初始化等待计数值
await() 用来等待计数归零
countDown() 用来让计数减一

在这里插入图片描述
上图中，给定初始值count = 3，调用await方法来判断count是否为0，若不为0，则将线程挂起等待，当count等于0之后，该线程才能继续执行。T2，T3，T4执行时，它们都调用了countdown()，每一次调用这个方法，都会对count减一。因此，调用了3次之后，T1线程继续执行。

CountDownLatch的使用demo：

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {

    public static void main(String[] args) throws InterruptedException {
        //初始化了一个倒计时锁 参数为 3
        CountDownLatch latch = new CountDownLatch(3);

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+"-begin...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            //count--
            latch.countDown();
            System.out.println(Thread.currentThread().getName()+"-end..." +latch.getCount());
        }).start();
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+"-begin...");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            //count--
            latch.countDown();
            System.out.println(Thread.currentThread().getName()+"-end..." +latch.getCount());
        }).start();
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+"-begin...");
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            //count--
            latch.countDown();
            System.out.println(Thread.currentThread().getName()+"-end..." +latch.getCount());
        }).start();
        String name = Thread.currentThread().getName();
        System.out.println(name + "-waiting...");
        //等待其他线程完成
        latch.await();
        System.out.println(name + "-wait end...");
    }
    
}

运行结果：

Thread-0-begin...
Thread-1-begin...
main-waiting...
Thread-2-begin...
Thread-0-end...2
Thread-2-end...1
Thread-1-end...0
main-wait end...

使用场景一——批量导入：
项目上线之前，需要把数据库中的数据一次性的同步到es索引库中，数据可能有1000万左右，一次性读取数据肯定不行（oom异常），可以使用线程池的方式导入，利用CountDownLatch来控制，就能避免一次性加载过多，防止内存溢出：
在这里插入图片描述

使用场景二——数据汇总：
在一个电商网站中，用户下单之后，需要查询数据，数据包含了三部分：订单信息、包含的商品、物流信息；这三块信息都在不同的微服务中进行实现的，可以通过线程池实现，提升查询效率：
在这里插入图片描述
在实际开发的过程中，难免需要调用多个接口来汇总数据，如果所有接口（或部分接口）的没有依赖关系，就可以使用线程池+future来提升性能。

使用场景三——异步线程：
在很多软件中，都提供了搜索功能，并且会记录用户的搜索记录。在实现搜索功能的时候，不能让搜索功能受到保存搜索记录的影响，通常采取异步的方式来保存搜索记录，通过异步线程来实现该功能。当用户输入关键字开始搜索后，正常返回用户搜索的相关数据，再开一个线程来记录用户的历史记录，并把这个新开的线程放到线程池中去执行。

控制方法允许并发访问的线程数量

Semaphore 信号量，是JUC包下的一个工具类，底层是AQS，我们可以通过其限制执行的线程数量。

使用场景：通常用于那些资源有明确访问数量限制的场景，常用于限流。

Semaphore使用步骤

创建Semaphore对象，可以给一个容量
semaphore.acquire()：请求一个信号量，这时候的信号量个数-1（一旦没有可使用的信号量，也即信号量个数变为负数时，再次请求的时候就会阻塞，直到其他线程释放了信号量）
semaphore.release()：释放一个信号量，此时信号量个数+1

import java.util.concurrent.Semaphore;

public class SemaphoreCase {
    public static void main(String[] args) {
        // 1. 创建 semaphore 对象
        Semaphore semaphore = new Semaphore(3);
        // 2. 10个线程同时运行
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    // 3. 获取许可，计数-1
                    semaphore.acquire();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    System.out.println("running...");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("end...");
                } finally {
                    // 4. 释放许可  计数+1
                    semaphore.release();
                }
            }).start();
        }
    }

}

对ThreadLocal的理解

ThreadLocal是多线程中对于解决线程安全的一个操作类，它会为每个线程都分配一个独立的线程副本从而解决了变量并发访问冲突的问题。ThreadLocal 同时实现了线程内的资源共享。

ThreadLocal基本使用：

set(value) 设置值——ThreadLocal 自己作为 key，资源对象作为 value，放入当前线程的 ThreadLocalMap 集合中
get() 获取值——以 ThreadLocal 自己作为 key，到当前线程中查找关联的资源值
remove() 清除值——以 ThreadLocal 自己作为 key，移除当前线程关联的资源值

demo:

public class ThreadLocalTest {
    static ThreadLocal<String> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {
        new Thread(() -> {
            String name = Thread.currentThread().getName();
            threadLocal.set("value1");
            print(name);
            System.out.println(name + "-after remove : " + threadLocal.get());
        }, "t1").start();
        new Thread(() -> {
            String name = Thread.currentThread().getName();
            threadLocal.set("value2");
            print(name);
            System.out.println(name + "-after remove : " + threadLocal.get());
        }, "t2").start();
    }

    static void print(String str) {
        //打印当前线程中本地内存中本地变量的值
        System.out.println(str + " :" + threadLocal.get());
        //清除本地内存中的本地变量
        threadLocal.remove();
    }

}

输出：

t1 :value1
t1-after remove : null
t2 :value2
t2-after remove : null

ThreadLocal本质来说就是一个线程内部存储类，从而让多个线程只操作自己内部的值，从而实现线程数据隔离。
在这里插入图片描述
set方法：

get方法/remove方法：
在这里插入图片描述
ThreadLocal——内存泄漏

Java对象中的四种引用类型：强引用、软引用、弱引用、虚引用

强引用：最为普通的引用方式，表示一个对象处于有用且必须的状态，如果一个对象具有强引用，则GC并不会回收它。即便堆中内存不足了，宁可出现OOM，也不会对其进行回收。
- User user = new User();
弱引用：表示一个对象处于可能有用且非必须的状态。在GC线程扫描内存区域时，一旦发现弱引用，就会回收到弱引用相关联的对象。对于弱引用的回收，无关内存区域是否足够，一旦发现则会被回收
```
User user = new User(); 
WeakReference weakReference = new WeakReference(user);
```

每一个Thread维护一个ThreadLocalMap，在ThreadLocalMap中的Entry对象继承了WeakReference。其中key为使用弱引用的ThreadLocal实例，value为线程变量的副本（强引用）：

static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;

    Entry(ThreadLocal<?> k, Object v) {
        super(k);
        value = v;
    }
}