java——juc篇

我真的很帅阿

已于 2024-04-29 21:05:46 修改

阅读量1.2k

点赞数 19

分类专栏：八股文文章标签：面试 java juc 并发编程

于 2024-01-21 22:00:07 首次发布

本文链接：https://blog.csdn.net/m0_61028090/article/details/135652332

版权

八股文专栏收录该内容

10 篇文章 2 订阅

订阅专栏

一、线程基础

1、进程与线程的区别？（⭐⭐⭐）

进程：进程是程序的一次执行过程，是操作系统资源分配的基本单位。程序由指令和数据组成，指令要运行就得加载至CPU，数据要读写就得加载至内存，在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存以及IO 的。
线程：一个线程就是一个指令流，是操作系统中最小的调度单位，负责将指令流中的一条条指令以一定的顺序交给 CPU 执行。
两者区别：
- 关系：进程是正在运行程序的实例，进程中包含了线程，每个线程执行不同的任务。
- 内存：不同的进程使用不同的内存空间，同一进程下的所有线程共享内存空间。
- 开销：线程更轻量，线程上下文切换开销要比进程上下文切换开销低。

2、并行和并发的区别（⭐）

并发：两个及两个以上的作业在同一 时间段 内执行。
并行：两个及两个以上的作业在同一时刻执行。

3、创建线程的方式有哪些？（⭐⭐⭐⭐）

继承Thread类：继承 Thread 类，并重写了其中的 run () 方法，之后直接调用 start () 即可实现多线程。

public class MyThread extends Thread {

    @Override
    public void run() {
        System.out.println("通过集成 Thread 类实现线程");
    }

}

new MyThread().start()

实现runnable接口：定义一个线程执行的任务（run 方法里面的逻辑）并没有创建线程。它首先通过 MyRunnable 类实现 Runnable 接口，然后重写 run () 方法，之后还要把这个实现了 run () 方法的实例传到 Thread 类中才可以实现多线程。

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("通过实现 Runnable 方式实现线程");
    }

}

// 使用
// 1、创建MyRunnable实例
MyRunnable runnable = new MyRunnable();
//2.创建Thread对象
//3.将MyRunnable放入Thread实例中
Thread thread = new Thread(runnable);
//4.通过线程对象操作线程(运行、停止)
thread.start();

实现Callable接口：Callable 与 Runnable 名字还有点像，区别在于 Runnable 是无返回值的。它们的本质都是定义线程要做的任务（call 或 run 方法里面的逻辑），而不是说他们本身就是线程。但无论有无返回值，它们都是需要被线程执行。
线程池创建线程

runnable和Callable的区别：

Runnable 接口 run 方法没有返回值； Callable 接口 call 方法有返回值，是个泛型，和Future 、 FutureTask 配合可以用来获取异步执行的结果。
Callalbe 接口支持返回执行结果，需要调用 FutureTask.get() 得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。
Callable接口的call()方法允许抛出异常；而Runnable接口的run()方法的异常只能在内部使用try-catch消化，不能继续上抛。

线程中的run()和 start()的区别：

start():用来启动线程，通过该线程调用run方法执行run方法中所定义的逻辑代码。start方法只能被调用一次。
run():封装了要被线程执行的代码，可以被调用多次。

调用 start() 方法方可启动线程并使线程进入就绪状态，直接执行 run() 方法的话不会以多线程的方式执行，会把 run() 方法当成一个 main 线程下的普通方法去执行。

4、线程的状态及其生命周期（⭐⭐⭐⭐）

新建状态(New)：线程对象被创建出来，但没有执行start()。
可执行状态(RUNNABLE)：线程调用start()方法转为可执行状态。
阻塞状态(Blocked)：没有获取锁则进入阻塞状态，获得锁再切换为可执行状态。
等待状态(wating)：线程调用了wait()方法进入等待状态，其他线程调用notify()唤醒后可切换为可执行状态。
超时等待状态(TIME_WAITING)：线程调用了sleep(50)方法，进入计时等待状态，到时间后可切换为可执行状态。
终止状态(TERMINATED)：该线程已经运行完毕。

5、新建 T1、T2、T3 三个线程，如何保证按顺序执行？（⭐⭐⭐）

使用线程类的join()方法在一个线程中启动另一个线程，另外一个线程完成该线程继续执行。

如：在t2线程里添加代码:t1.join(); 在t3线程里添加代码t2.join()；

join()方法的作用：

使主线程(即调用t.join方法的线程)挂起，并等待子线程 t 执行完毕后才会被唤醒。

6、notify()和 notifyAll()的区别（⭐⭐）

notifyAll：唤醒所有wait的线程
notify：随机唤醒一个 wait 线程

7、sleep() 方法和 wait() 方法的异同（⭐⭐⭐）

相同点：都可以让线程进入阻塞状态。
不同点：
- 方法归属：sleep是Thread的静态本地方法，wait()是Object类的本地方法。
- 醒来时机：sleep执行完线程会自动苏醒；wait需要其他线程调用notify或notifyAll。
- 锁特性：调用wait方法需要获取对象锁，唤醒后会释放锁；调用sleep不需要获取锁也不会释放锁。

8、如何停止一个正在运行的线程？（⭐⭐）

使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。
使用stop方法强行终止（不推荐，方法已作废）。
使用interrupt方法中断线程。

二、线程中的并发安全

1、synchronized关键字的底层原理（⭐⭐⭐）

synchronized用于解决多线程的并发安全问题，可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。
synchronized底层是由monitor实现的，在线程获取锁成功过后需要和monitor对象进行关联，即将对象头的mark word字段存储monitor的地址，并将monitor的owner字段指向该线程。
由于monitor是操作系统级别的对象，在实现线程之间的切换时需要从用户态转换到内核态，成本较高，因此synchronized属于 重量级锁，效率低下。 jdk1.6之后引入了锁升级减少了锁的开销，如：轻量级锁、偏向锁等。
- monitor有三个字段：
  - Owner：存储当前获取锁的线程的，只能有一个线程可以获取。
  - EntryList：关联没有抢到锁的线程，处于Blocked状态的线程。
  - WaitSet：关联调用了wait方法的线程，处于Waiting状态的线程。

锁升级：

在HotSpot虚拟机中，对象的内存结构包括三个字段：对象头、实例数据、对齐填充。

其中对象头有两个字段：
- Klass word：对象的类。
- Mark word：如下图。

jdk1.6之后，synchronized锁进行了优化，锁一共分为四种状态：

无锁状态
偏向锁：用于解决锁的重入问题。
- 共享资源首次被访问时，JVM会对该共享资源对象做一些设置，比如将对象头中是否偏向锁标志位置为1，对象头中的线程ID设置为当前线程ID，后续当前线程再次访问这个共享资源时，会根据偏向锁标识跟线程ID进行比对是否相同，比对成功则直接获取到锁，进入临界区域，这也是synchronized锁的可重入功能。
轻量级锁：
- 轻量级锁通过自旋等待（CAS操作）来尝试获取锁，避免线程立即挂起。如果自旋等待达到一定次数仍无法获取锁，则会升级为重量级锁。
重量级锁

2、谈谈 JMM（Java 内存模型）（⭐⭐⭐）

首先搞清楚java内存区域和java内存模型的区别：

java内存区域：定义的是jvm在运行时如何如何分区存储程序数据。
java内存模型：和java并发编程相关，描述了Java程序中各种变量(线程共享变量)的访问规则
，目的是为了简化多线程编程。

所有的共享变量都存储于主内存，这里所说的变量指的是实例变量和类变量。不包含局部变量，因为局部变量是线程私有的，因此不存在竞争问题。
每一个线程还存在自己的工作内存，线程的工作内存，保留了被线程使用的变量的工作副本。
线程对变量的所有操作(读，写)都必须在工作内存中完成，而不能直接读写主内存中的变量，不同线程之间也不能直接访问对方工作内存中的变量，线程之间交互需要通过主内存完成。

3、谈谈CAS（⭐⭐⭐）

CAS全称是： Compare And Swap(比较再交换)，它体现的是一种乐观锁的思想，在无锁情况下保证多线程操作共享数据的原子性。

具体实现如下图：

当线程A对共享变量a进行++操作时，需要将a读入工作内存，执行++操作，再进行CAS操作，发现旧数据A和共享数据V相等，于是修改成功，将新值写入主内存；而线程B想进行- -操作，再进行CAS操作时，发现不相等，于是开始重复这个过程(自旋操作)。

CAS引出的ABA问题：就是在比较并交换时，存在一个时间差，在这期间数据可能会被修改多次，只不过最终结果和最初结果恰巧相同。

解决办法：使用AtomicStampedReference类可以解决ABA问题。这个类维护了一个版本号Stamp，在进行CAS操作的时候，不仅要比较当前值，还要比较版本号。只有两者都相等，才执行更新操作。

CAS引出的循环时间过长问题：由于线程在修改数据失败后会进行自旋操作，如果长时间自旋的话，会给cpu带来很大的负担。

解决办法：破坏死循环，当自旋超过一定次数时，结束自旋操作。

悲观锁和乐观锁的区别：

悲观锁：悲观锁总是假设最坏的情况，认为共享资源每次被访问的时候就会出现并发安全问题，所以每次在获取资源操作的时候都会上锁，这样其他线程想拿到这个资源就会阻塞直到锁被上一个持有者释放。也就是说，共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程。如synchronized。
乐观锁：乐观锁总是假设最好的情况，认为共享资源每次被访问的时候不会出现问题，线程可以不停地执行，无需加锁也无需等待，只是在提交修改的时候去验证对应的数据是否被其它线程修改了。如CAS。

4、谈谈volatile（⭐⭐⭐）

可见性问题：

可见性问题和Java内存模型(JMM)有关，在JMM中，存在主内存和工作内存，主内存存的是共享变量，工作内存是线程私有的，线程对数据的操作是在工作内存当中进行的，此时数据的改动对于主内存以及其他工作内存是不可见的。

当一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

保证线程间的可见性：一个线程修改了某个变量的值，该新值对其他线程来说是立即可见的。
- volatile关键字可以保证变量的可见性，如果我们将变量声明为 volatile，这就指示 JVM，这个变量是共享且不稳定的，每次使用它都到主存中进行读取。
禁止指令重排序：用 volatile 修饰共享变量会在读、写共享变量时加入不同的屏障，阻止其他读写操作越过屏障，从而达到阻止重排序的效果。

5、谈谈AQS（⭐⭐⭐）

AQS全称AbstractQueuedSynchronizer，即抽象队列同步器。它是构建锁或者其他同步组件的基础框架，常见的实现类有：ReentrantLock(阻塞式锁)、Semaphore(信号量)、CountDownLatch(倒计时锁)。AQS与Synchronized的区别如下图：

AQS 核心思想：如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制。

AQS的核心框架实现：

AQS内部维护了一个先进先出的双向队列CLH，队列中存储的排队的线程。
- CLH队列一个虚拟的双向队列（虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系），暂时获取不到锁的线程将被加入到该队列中。每个线程被封装成队列中的一个节点，节点保存着线程的引用、前驱节点、后继节点等信息。

AQS内部还维护了一个属性state，由 volatile 修饰。相当于资源，默认为0(无锁状态)。当有线程修改了state为1，则该线程获取了资源。状态信息state可以通过getState和setState方法获取和修改，这些方法由final修饰，无法更改。
使用CAS操作保证各线程对state修改的原子性。即compareAndSetState方法。

5.1、谈谈ReentrantLock（⭐⭐⭐）

ReentrantLock表示可重入锁，同一线程可多次获取锁。
ReentrantLock主要利用CAS+AQS队列来实现。
ReentrantLock支持公平锁和非公平锁，在提供的构造器的中无参默认是非公平锁，也可以传参设置为公平锁。

5.2、CountDownLatch是什么？什么场景下使用？（⭐⭐⭐⭐）

CountDownLatch允许 count 个线程阻塞在一个地方，直至所有线程的任务都执行完毕。

CountDownLatch(倒计时锁)是AQS的实现类之一，默认构造 AQS 的 state 值为 count。当线程使用 countDown() 方法时,即以 CAS 的操作来减少 state,直至 state 为 0 。当调用 await() 方法的时候，如果 state 不为 0，即任务还没有执行完毕，await() 方法就会一直阻塞，直到state 值被减为 0，该线程才会从阻塞中被唤醒，await() 方法之后的语句得到执行。

使用场景：项目中有一个使用多线程读取多个文件处理的场景用到了 CountDownLatch。

我们要读取处理 6 个文件，这 6 个任务都是没有执行顺序依赖的任务，但是我们需要返回给用户的时候将这几个文件的处理的结果进行统计整理。

为此我们定义了一个线程池和 count 为 6 的 CountDownLatch 对象。使用线程池处理读取任务，每一个线程处理完之后就将 count-1，调用CountDownLatch 对象的 await()方法，直到所有文件读取完之后，才会接着执行后面的逻辑。伪代码如下：

public class CountDownLatchExample1 {
    // 处理文件的数量
    private static final int threadCount = 6;

    public static void main(String[] args) throws InterruptedException {
        // 创建一个具有固定线程数量的线程池对象（推荐使用构造方法创建）
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        final CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            final int threadnum = i;
            threadPool.execute(() -> {
                try {
                    //处理文件的业务操作
                    //......
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //表示一个文件已经被完成
                    countDownLatch.countDown();
                }

            });
        }
        countDownLatch.await();
        threadPool.shutdown();
        System.out.println("finish");
    }
}

5.3、谈谈Semaphore （⭐⭐⭐）

synchronized 和 ReentrantLock都是一次只允许一个线程访问某个资源，Semaphore (信号量)可以控制同时访问特定资源的线程数量，通常用于那些资源有明确访问数量限制的场景比如限流。

Semaphore 的使用：假设有 N个线程来获取 Semaphore 中的共享资源，以下代码表示同一时刻只有N 个线程能获取到共享资源，其他线程都会阻塞。直到有线程释放了共享资源，其他阻塞的线程才能获取到资源。

// 初始共享资源数量
final Semaphore semaphore = new Semaphore(5);
// 获取1个许可
semaphore.acquire();
// 释放1个许可
semaphore.release();

Semaphore 有两种模式：

公平模式： 调用 acquire() 方法的顺序遵循 FIFO；
非公平模式： 抢占式的。

6、synchronized和Lock有什么区别 ?（⭐⭐⭐⭐）

synchronized是一个关键字，底层由monitor实现；而lock是Java实现的一个接口。
获取synchronized锁的线程执行完之后会自动释放锁，即使线程发生异常也会自动释放锁；而lock需要在finally代码块中调用unlock方法主动释放锁。
尝试获取synchronized锁的线程会阻塞等待；而lock中有尝试获取锁的方法tryLock，当获取不到锁的时候会立即返回，不会阻塞等待。
synchronized适用于锁竞争不太激烈的情况；lock适用于锁竞争激烈的情况。

7、谈谈ConcurrentHashMap （⭐⭐⭐⭐）

底层数据结构：
- JDK1.7及之前之前采用 分段数组(segment) + 链表实现。
- JDK1.8开始底层的数据结构和JDK1.8HashMap一样，采用数组+链表/红黑树实现。
加锁方式：
- JDK1.7采用Segment分段锁，底层使用的是ReentrantLock。
- JDK1.8放弃了Segment分段锁的设计，采用 CAS + synchronized 保证线程安全，锁粒度更细。CAS控制数组节点的添加，synchronized只锁定当前链表或红黑二叉树的首节点，只要hash不冲突，就不会产生并发安全问题。

jdk1.7：

jdk1.8：

8、Java中怎么保证多线程的执行安全？（⭐⭐⭐）

满足Java并发编程的三大特性：

原子性：一段程序执行是不可分割的，要么全部执行成功，要么全部失败。
- 可以使用synchronized和lock保证程序的原子性。
可见性：一个线程对共享变量的修改对另一个线程可见。
- 可以使用volatile(推荐)保证可见性，synchronized、Lock也可以。
有序性：在Java内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。
- 可以通过volatile关键字来保证一定的“有序性”，synchronized和Lock也可以。

三、线程池

1、什么是线程池？为什么要用线程池？

线程池就是管理一系列线程的资源池。当有任务要处理时，直接从线程池中获取线程来处理，处理完之后线程并不会立即被销毁，而是等待下一个任务。池化技术的好处：

降低资源消耗。重复利用已创建的线程降低线程创建和销毁造成的消耗。
提高响应速度。当有任务时，可以不需要等待线程的创建就能立即执行。

线程池的关闭方式：

shutdown：使线程池状态从 RUNNING 转变为 SHUTDOWN，该状态下不再处理新任务，但会将工作队列中的任务执行结束。
shutdownNow：使线程池状态将会从 RUNNING 转变为 STOP，该状态下新任务旧任务都不再处理，并且会中断线程。

2、线程池的核心参数（⭐⭐⭐⭐）

线程池有七个参数：

corePoolSize：核心线程数目
maximumPoolSize：最大线程数目 = 核心线程 + 临时线程的最大数目
workQueue：当没有空闲核心线程时，新来任务会加入到此队列排队，当队列满时会创建临时线程执行任务
keepAliveTime：临时线程的生存时间，若生存时间内没有新任务，此线程资源会释放
unit：临时线程生存时间的单位
threadFactory：线程工厂，可以定制线程对象的创建，如设置线程名字、是否是守护线程等
handler：拒绝策略 - 当所有线程都在繁忙，队列也放满时，会触发拒绝策略
- 1.AbortPolicy：直接抛出异常，默认策略；
- 2.CallerRunsPolicy：用调用者所在的线程来执行任务；
- 3.DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；
- 4.DiscardPolicy：直接丢弃任务；

工作流程图：

3、线程池中有哪些常见的阻塞队列（⭐⭐⭐）

ArrayBlockingQueue：基于数组结构的有界阻塞队列，FIFO。
LinkedBlockingQueue：基于链表结构的有界阻塞队列，FIFO。
DelayedWorkQueue ：是一个优先级队列，它可以保证每次出队的任务都是当前队列中执行时间最靠前的。
SynchronousQueue：不存储元素的阻塞队列，每个插入操作都必须等待一个移出操作。

ArrayBlockingQueue的LinkedBlockingQueue区别：

LinkedBlockingQueue默认无界，支持有界；ArrayBlockingQueue强制有界。
LinkedBlockingQueue底层是单向链表实现；ArrayBlockingQueue基于数组实现。
LinkedBlockingQueue头尾各一把锁，效率较高；ArrayBlockingQueue只有一把锁。

4、如何确定核心线程数？（⭐⭐⭐）

CPU密集型任务：这类任务消耗的主要是 CPU 资源，可以将线程核心数设置为 N（CPU 核心数）+1。
- 多出来的一个核心线程是为了防止各种原因导致任务暂停而带来的影响。一旦任务暂停，CPU 就会处于空闲状态，而在这种情况下多出来的线程可以充分利用 CPU 的空闲时间。
I/O密集型任务：这类任务系统会将大部分时间用在I/O交互上，这段时间CPU是空闲的，可以交给其他线程使用，因此可以多配置一些线程，常用的值为2N（CPU核心数）。

5、如何创建线程池？线程池有哪些种类？（⭐⭐⭐）

方式一：使用ThreadPoolExecutor构造函数来创建。

方式二：使用Executors工具类来创建。
- newFixedThreadPool：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
- newSingleThreadExecutor：创建一个单线程的线程池，若多余的任务被提交到该线程池，其会被保存在一个任务队列中，待线程空闲，按先入先出的顺序执行队列中的任务。
- newCachedThreadPool：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
- newScheduledThreadPool：可执行延迟任务的线程池，支持定时及周期性任务执行。

6、为什么不推荐使用内置线程池（Executors）？（⭐⭐⭐）

采用无界的阻塞队列，可能会堆积大量的任务，最终导致内存溢出。
允许创建的线程数为Integer.MAX_VALUE，也可能导致内存溢出。

7、Future 类有什么用？

Future 类是异步思想的典型运用，主要用在一些需要执行耗时任务的场景。具体来说：当我们执行某一耗时的任务时，可以将这个耗时任务交给一个子线程去异步执行，同时我们可以执行其他任务，不用傻傻等待耗时任务执行完成。等我们的事情干完后，我们再通过 Future 类获取到耗时任务的执行结果。以此提高程序的执行效率。

在 Java 中，Future 类只是一个泛型接口，内部实现了以下四种功能：

取消任务；
判断任务是否被取消;
判断任务是否已经执行完成;
获取任务执行结果。

// V 代表了Future执行的任务返回值的类型
public interface Future<V> {
    // 取消任务执行
    // 成功取消返回 true，否则返回 false
    boolean cancel(boolean mayInterruptIfRunning);
    // 判断任务是否被取消
    boolean isCancelled();
    // 判断任务是否已经执行完成
    boolean isDone();
    // 获取任务执行结果
    V get() throws InterruptedException, ExecutionException;
    // 指定时间内没有返回计算结果就抛出 TimeOutException 异常
    V get(long timeout, TimeUnit unit)

        throws InterruptedException, ExecutionException, TimeoutExceptio

}

8、谈谈对ThreadLocal的理解（⭐⭐⭐⭐）

ThreadLocal是什么？有什么用？

ThreadLocal，本地线程变量，ThreadLocal可以让每个线程绑定自己的变量，该变量对其他线程而言是封闭且隔离的。

ThreadLocal 的简单使用：

public class ThreadLocal_demo {
    public static void main(String[] args) {
        ThreadLocal<Object> local = new ThreadLocal<>();
        IntStream.range(0,10).forEach(i->new Thread(()->{
            local.set(Thread.currentThread().getName() + ":" + i);
            System.out.println("线程：" + Thread.currentThread().getName() + "local:" + local.get());
        }).start());
    }
}

运行结果表明每个线程都能保存私有的值：

ThreadLocal的原理

ThreadLocal的set方法源码：

public void set(T value) {
    //获取当前请求的线程
    Thread t = Thread.currentThread();
    //取出 Thread 类内部的 threadLocals 变量(哈希表结构)
    ThreadLocalMap map = getMap(t);
    if (map != null)
        // 将需要存储的值放入到这个哈希表中
        map.set(this, value);
    else
        createMap(t, value);
}

ThrealLocal 类中可以通过Thread.currentThread()获取到当前线程对象后，直接通过getMap(Thread t)可以访问到该线程的ThreadLocalMap对象。

每个Thread中都具备一个ThreadLocalMap，而ThreadLocalMap可以存储以ThreadLocal为 key ，Object 对象为 value 的键值对。

ThreadLocal的get方法源码：

    private T get(Thread t) {
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T) e.value;
                return result;
            }
        }
        return setInitialValue(t);
    }
 
    private Entry getEntry(ThreadLocal<?> key) {
        int i = key.threadLocalHashCode & (table.length - 1);
        Entry e = table[i];
        if (e != null && e.refersTo(key))
            return e;
        else
            return getEntryAfterMiss(key, i, e);
    }

ThreadLocal 的应用场景

解决高并发条件下多线程访问共享变量产生的并发安全问题。

例如：项目中@Autowired默认是单例模式，那么负责连接数据库的connection也是单例的，如果多个线程同时获取connection请求连接数据库的话，就会产生并发安全问题。底层的解决方案就是使用ThreadLocal，每个线程请求连接数据库的时候，会先从自己的ThreadLocal中获取connection对象，达到各个线程隔离的效果。