MyBatis整体架构分析：【备战秋招冲击大厂

进程：是并发执行的程序在执行过程中分配和管理资源的基本单位，是一个动态概念，竞争计算机系统资源的基本单位。

线程：是进程的一个执行单元，是进程内科调度实体。比进程更小的独立运行的基本单位。线程也被称为轻量级进程。

为什么会有线程？

每个进程都有自己的地址空间，即进程空间，在网络或多用户换机下，一个服务器通常需要接收大量不确定数量用户的并发请求，为每一个请求都创建一个进程显然行不通（系统开销大响应用户请求效率低），因此操作系统中线程概念被引进。

1)线程的执行过程是线性的，尽管中间会发生中断或者暂停，但是进程所拥有的资源只为线状执行过程服务，一旦发生线程切换，这些资源需要被保护起来。

2)进程分为单线程进程和多线程进程，单线程进程宏观来看也是线性执行过程，微观上只有单一的执行过程。多线程进程宏观是线性的，微观上多个执行操作。

3)线程的改变只代表CPU的执行过程的改变，而没有发生进程所拥有的资源的变化。

进程线程的区别：

1)地址空间：同一进程的线程共享本进程的地址空间，而进程之间则是独立的地址空间。

2)资源拥有：同一进程内的线程共享本进程的资源如内存、I/O、cpu等，但是进程之间的资源是独立的。

3)一个进程崩溃后，在保护模式下不会对其他进程产生影响，但是一个线程崩溃整个进程都死掉。所以多进程要比多线程健壮。

4)进程切换时，消耗的资源大，效率低。所以涉及到频繁的切换时，使用线程要好于进程。同样如果要求同时进行并且又要共享某些变量的并发操作，只能用线程不能用进程

5)执行过程：每个独立的进程有一个程序运行的入口、顺序执行序列和程序入口。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

6)线程是处理器调度的基本单位，进程是资源分配的最小单位。

7)两者均可并发执行。

• 优缺点：

  1)线程执行开销小，但是不利于资源的管理和保护。线程适合在SMP机器（双CPU系统）上运行。

  2)进程执行开销大，但是能够很好的进行资源管理和保护。进程可以跨机器迁移。

• 何时使用多进程，何时使用多线程？

  1)对资源的管理和保护要求高，不限制开销和效率时，使用多进程。

  2)要求效率高，频繁切换时，资源的保护管理要求不是很高时，使用多线程。

更多Java学习资料、面试真题获得，请【点击此处】

2. 协程

协程运行在线程之上，当一个协程执行完成后，可以选择主动让出，让另一个协程运行在当前线程之上。协程并没有增加线程数量，只是在线程的基础之上通过分时复用的方式运行多个协程，而且协程的切换在用户态完成，切换的代价比线程从用户态到内核态的代价小很多。

在有大量IO操作业务的情况下，我们采用协程替换线程，可以到达很好的效果，一是降低了系统内存，二是减少了系统切换开销，因此系统的性能也会提升。

在协程中尽量不要调用阻塞IO的方法，比如打印，读取文件，Socket接口等，除非改为异步调用的方式，并且协程只有在IO密集型的任务中才会发挥作用。

协程只有和异步IO结合起来才能发挥出最大的威力。

3. 线程的5种状态

4. sleep、yield、wait、join的区别

• sleep：Thread类的方法，必须带一个时间参数。会让当前线程休眠进入阻塞状态并释放CPU（Sleep释放CPU，wait 也会释放CPU，因为cpu资源太宝贵了，只有在线程running的时候，才会获取cpu片段），提供其他线程运行的机会且不考虑优先级，但如果有同步锁，则sleep不会释放锁即其他线程无法获得同步锁，可通过调用interrupt()方法来唤醒休眠线程。

• yield：让出CPU调度，Thread类的方法，类似sleep只是不能由用户指定暂停多长时间，并且yield()方法只能让同优先级的线程有执行的机会。 yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。调用yield方法只是一个建议，告诉线程调度器我的工作已经做的差不多了，可以让别的相同优先级的线程使用CPU了，没有任何机制保证采纳。

• wait：Object类的方法(notify()、notifyAll() 也是Object对象)，必须放在循环体和同步代码块中，执行该方法的线程会释放锁，进入线程等待池中等待被再次唤醒(notify随机唤醒，notifyAll全部唤醒，线程结束自动唤醒)即放入锁池中竞争同步锁

• join：一种特殊的wait，当前运行线程调用另一个线程的join方法，当前线程进入阻塞状态直到另一个线程运行结束等待该线程终止。注意该方法也需要捕捉异常。等待调用join方法的线程结束，再继续执行。如：t.join()；//主要用于等待t线程运行结束，若无此句，main则会执行完毕，导致结果不可预测。

5. 为何不推荐使用stop()和suspend()方法?

stop()方法不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。

suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被”挂起”的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用 wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。

6. 7种线程同步方法

1)synchronized同步方法

2)synchronized同步代码块

3)LOCK

4)Volatile

5)Threadlocal

6)阻塞队列

7)wait与notify 

7. 监视器(Monitor)内部如何线程同步？

监视器和锁在Java虚拟机中是一块使用的。监视器监视一块同步代码块，确保一次只有一个线程执行同步代码块。每一个监视器都和一个对象引用相关联。线程在获取锁之前不允许执行同步代码。

8. 线程的创建方式

启动线程有如下三种方式：

• 继承Thread类创建线程类

  （1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。

  （2）创建Thread子类的实例，即创建了线程对象。

  （3）调用线程对象的start()方法来启动该线程。

package com.thread；

public class FirstThreadTest extends Thread{

    int i = 0；

    //重写run方法，run方法的方法体就是现场执行体

    public void run(){

        for(；i<100；i++){

            System.out.println(getName()+"  "+i)；

        }

    }

    public static void main(String[] args) {

        for(int i = 0；i< 100；i++){

            System.out.println(Thread.currentThread().getName()+"  ： "+i)；

            if(i==20) {

                new FirstThreadTest().start()；

                new FirstThreadTest().start()；

            }

        }

    }

} 

上述代码中Thread.currentThread()方法返回当前正在执行的线程对象。GetName()方法返回调用该方法的线程的名字。

• 通过Runnable接口创建线程类：使用实现Runnable接口的方式创建的线程可以处理同一资源，从而实现资源的共享.

  • 适合多个相同程序代码的线程去处理同一个资源（多线程内的数据共享）

  • 增加程序健壮性，数据被共享时，仍然可以保持代码和数据的分离和独立

  • 避免java特性中的单继承限制

  • 更能体现java面向对象的设计特点

    （1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。

    （2）创建 Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。

    （3）调用线程对象的start()方法来启动该线程。

package com.thread；

public class RunnableThreadTest implements Runnable{

    private int i；

    public void run(){

        for(i = 0；i <100；i++){

            System.out.println(Thread.currentThread().getName()+" "+i)；

        }

    }

    public static void main(String[] args) {

        for(int i = 0；i < 100；i++){

            System.out.println(Thread.currentThread().getName()+" "+i)；

            if(i==20){

                RunnableThreadTest rtt = new RunnableThreadTest()；

                new Thread(rtt，"新线程1").start()；

                new Thread(rtt，"新线程2").start()；

            }

        }

    }

} 

• 通过Callable和Future创建线程

  （1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。

  （2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

  （3）使用FutureTask对象作为Thread对象的target创建并启动新线程。

  （4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

package com.thread；

import java.util.concurrent.Callable；

import java.util.concurrent.ExecutionException；

import java.util.concurrent.FutureTask；

 

public class CallableThreadTest implements Callable<Integer>{

     public static void main(String[] args) {

        CallableThreadTest ctt = new CallableThreadTest()；

        FutureTask<Integer> ft = new FutureTask<>(ctt)；

        for(int i = 0；i < 100；i++){

            System.out.println(Thread.currentThread().getName()+" 的变量i的值"+i)；

            if(i==20) {

                new Thread(ft，"有返回值的线程").start()；

            }

        }

        try{

            System.out.println("子线程的返回值："+ft.get())；

        } catch (InterruptedException e) {

            e.printStackTrace()；

        } catch (ExecutionException e) {

            e.printStackTrace()；

        }

    }

 

    @Override

    public Integer call() throws Exception{

        int i = 0；

        for(；i<100；i++){

            System.out.println(Thread.currentThread().getName()+" "+i)；

        }

        return i；

    }

} 

9. cyclicbarrier和countdownlatch的区别

• CountDownLatch和CyclicBarrier都能够实现线程之间的等待

• CountDownLatch一般用于某个线程A或多个线程，等待若干个其他线程执行完任务之后，它才执行；CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量；调用await()方法的线程会被阻塞，直到计数器减到 0 的时候，才能继续往下执行；调用了await()进行阻塞等待的线程，它们阻塞在Latch门闩/栅栏上；只有当条件满足的时候（countDown() N次，将计数减为0），它们才能同时通过这个栅栏；以此能够实现，让所有的线程站在一个起跑线上。

• CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；另外，CountDownLatch是减计数，计数减为0后不能重用；而CyclicBarrier是加计数，可置0后复用。

10. Java中提供的线程池

Executors类提供了4种不同的线程池：newCachedThreadPool， newFixedThreadPool， newScheduledThreadPool， newSingleThreadExecutor

1)newCachedThreadPool：用来创建一个可以无限扩大的线程池，适用于负载较轻的场景，执行短期异步任务。（可以使得任务快速得到执行，因为任务时间执行短，可以很快结束，也不会造成cpu过度切换）

2)newFixedThreadPool：创建一个固定大小的线程池，因为采用无界的阻塞队列，所以实际线程数量永远不会变化，适用于负载较重的场景，对当前线程数量进行限制。（保证线程数可控，不会造成线程过多，导致系统负载更为严重）

3)newSingleThreadExecutor：创建一个单线程的线程池，适用于需要保证顺序执行各个任务。

4)newScheduledThreadPool：适用于执行延时或者周期性任务。

11. 自定义线程池（ThreadPoolExector）

new ThreadPoolExecutor(

                    2，

                    9，

                    1L，

                    TimeUnit.SECONDS，

                    new LinkedBlockingDeque<Runnable>(10)，

                    Executors.defaultThreadFactory()，

                    new ThreadPoolExecutor.DiscardPolicy())； 

七大参数：

1)corePoolSize（常驻核心线程数）：当向线程池提交一个任务时，若线程池已创建的线程数小于corePoolSize，即便此时存在空闲线程，也会通过创建一个新线程来执行该任务，直到已创建的线程数大于或等于corePoolSize时，（除了利用提交新任务来创建和启动线程（按需构造），也可以通过 prestartCoreThread() 或 prestartAllCoreThreads() 方法来提前启动线程池中的基本线程。）

2)maximumPoolSize（线程池最大线程数）：线程池所允许的最大线程个数。当队列满了，且已创建的线程数小于maximumPoolSize，则线程池会创建新的线程来执行任务。另外，对于无界队列，可忽略该参数。

3)keepAliveTime（线程存活保持时间）当线程池中线程数大于核心线程数时，线程的空闲时间如果超过线程存活时间，那么这个线程就会被销毁，直到线程池中的线程数小于等于核心线程数。

4)unit(时间单位)

5)workQueue（任务队列）：用于传输和保存等待执行任务的阻塞队列。

6)threadFactory（线程工厂）：用于创建新线程。threadFactory创建的线程也是采用new Thread()方式，threadFactory创建的线程名都具有统一的风格：pool-m-thread-n（m为线程池的编号，n为线程池内的线程编号）。

handler（线程饱和策略）：当线程池和队列都满了，再加入线程会执行此策略。

• 四种拒绝策略：

  1)ThreadPoolExecutor.AbortPolicy(默认)：丢弃任务并抛出RejectedExecutionException异常。

  2)ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常。

  3)ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新提交被拒绝的任务

  4)ThreadPoolExecutor.CallerRunsPolicy：由调用线程（提交任务的线程）处理该任务

• 配置线程池

  1)CPU密集型任务：尽量使用较小的线程池，一般为CPU核心数+1。 因为CPU密集型任务使得CPU使用率很高，若开过多的线程数，会造成CPU过度切换。

  2)IO密集型任务：可以使用稍大的线程池，一般为2*CPU核心数。IO密集型任务CPU使用率并不高，因此可以让CPU在等待IO的时候有其他线程去处理别的任务，充分利用CPU时间。CPU核心线程数/1-阻塞系数（0.8~0.9）

  3)混合型任务：可以将任务分成IO密集型和CPU密集型任务，然后分别用不同的线程池去处理。

12. 线程池的状态

• RUNNING：这是最正常的状态，接受新的任务，处理等待队列中的任务。线程池的初始化状态是RUNNING。线程池被一旦被创建，就处于RUNNING状态，并且线程池中的任务数为0。

• SHUTDOWN：不接受新的任务提交，但是会继续处理等待队列中的任务。调用线程池的shutdown()方法时，线程池由RUNNING -> SHUTDOWN。

• STOP：不接受新的任务提交，不再处理等待队列中的任务，中断正在执行任务的线程。调用线程池的shutdownNow()方法时，线程池由(RUNNING or SHUTDOWN ) -> STOP。

• TIDYING（整理状态）：所有的任务都销毁了，workCount 为 0，线程池的状态在转换为 TIDYING 状态时，会执行钩子方法 terminated()。因为terminated()在ThreadPoolExecutor类中是空的，所以用户想在线程池变为TIDYING时进行相应的处理；可以通过重载terminated()函数来实现。

• TERMINATED：线程池处在TIDYING状态时，执行完terminated()之后，就会由 TIDYING -> TERMINATED。

  

更多Java学习资料、面试真题获得，请【点击此处】

13. 线程池中shutdown()和shutdownNow()方法的区别

shutdown只是将线程池的状态设置为SHUTWDOWN状态，正在执行的任务会继续执行下去，没有被执行的则中断。而shutdownNow则是将线程池的状态设置为STOP，正在执行的任务则被停止，没被执行任务的则返回。

14. 线程池中 submit() 和 execute() 方法的区别

• execute()：只能执行 Runnable 类型的任务。

• submit()：可以执行 Runnable 和 Callable 类型的任务。

• submit()能获取返回值（异步）以及处理Exception。

15. ThreadLocal

https：//segmentfault.com/a/1190000037728236?utm_source=tag-newest

ThreadLocal提供了线程内存储变量的能力，这些变量不同之处在于每一个线程读取的变量是对应的互相独立的。通过get和set方法就可以得到当前线程对应的值。

• ThreadLocal和Synchronized都是为了解决多线程中相同变量的访问冲突问题，不同的点是：

• Synchronized是通过线程等待，牺牲时间来解决访问冲突

• ThreadLocal是通过每个线程单独一份存储空间，牺牲空间来解决冲突，并且相比于Synchronized，ThreadLocal具有线程隔离的效果，只有在线程内才能获取到对应的值，线程外则不能访问到想要的值。

• 应用场景

• 数据库连接池的实现：获取connection

• 提升性能和安全，如SimpleDateFormat

• 底层实现

  1)ThreadLocal仅仅是个变量访问的入口；

  2)每一个Thread对象都有一个ThreadLocalMap对象，这个ThreadLocalMap持有对象的引用；

  3)ThreadLocalMap以当前的threadLocal对象为key，以真正的存储对象为value。get()方法时通过threadLocal实例就可以找到绑定在当前线程上的副本对象。

• 每个线程都有一个属于自己的ThreadLocalMap类， 他用于关联多个以ThreadLocal对象为key， 以你的数据为value的Entry对象， 且该对象的key是一个弱引用对象，以防止内存泄漏。

  

16. Synchronized在静态方法和非静态方法的区别

• Synchronzied 修饰非静态方法==》对象锁（同步代码块，方法锁）

• Synchronzied 修饰静态方法==》类锁，因为是静态方法，它把整个类锁起来了；

17. Synchronized和Lock

• 实现层面不一样。synchronized 是Java关键字，JVM层面实现加锁和释放锁；Lock 是一个接口，在代码层面实现加锁和释放锁

• 是否自动释放锁。synchronized 在线程代码执行完或出现异常时自动释放锁；Lock 不会自动释放锁，需要再 finally{}代码块显式地中释放锁

• 是否一直等待。synchronized 会导致线程拿不到锁一直等待；Lock 可以设置尝试获取锁或者获取锁失败一定时间超时

最后

手绘了下图所示的kafka知识大纲流程图（xmind文件不能上传，导出图片展现），但都都可提供源文件给每位爱学习的朋友，获取链接：戳这里免费下载

V0L3dlaXhpbl81NzkwNzAyOA==,size_16,color_FFFFFF,t_70)

16. Synchronized在静态方法和非静态方法的区别

• Synchronzied 修饰非静态方法==》对象锁（同步代码块，方法锁）

• Synchronzied 修饰静态方法==》类锁，因为是静态方法，它把整个类锁起来了；

17. Synchronized和Lock

• 实现层面不一样。synchronized 是Java关键字，JVM层面实现加锁和释放锁；Lock 是一个接口，在代码层面实现加锁和释放锁

• 是否自动释放锁。synchronized 在线程代码执行完或出现异常时自动释放锁；Lock 不会自动释放锁，需要再 finally{}代码块显式地中释放锁

• 是否一直等待。synchronized 会导致线程拿不到锁一直等待；Lock 可以设置尝试获取锁或者获取锁失败一定时间超时

最后

手绘了下图所示的kafka知识大纲流程图（xmind文件不能上传，导出图片展现），但都都可提供源文件给每位爱学习的朋友，获取链接：戳这里免费下载

[外链图片转存中…(img-i5W92ce5-1628138990341)]