银行外包面试题及答案-java后端

MyBatis中井号与美元符号的区别

#{变量名}可以进行预编译、类型匹配等操作，#{变量名}会转化为jdbc的类型。

select * from tablename where id = #{id}

假设id的值为12，其中如果数据库字段id为字符型，那么#{id}表示的就是’12’，如果id为整型，那么id就是12，并且MyBatis会将上面SQL语句转化为jdbc的select * from tablename where id=?，把?参数设置为id的值。

${变量名}不进行数据类型匹配，直接替换。

select * from tablename where id = ${id}

如果字段id为整型，sql语句就不会出错，但是如果字段id为字符型，那么sql语句应该写成select * from table where id = ‘${id}’。

#方式能够很大程度防止sql注入。

$方式无法防止sql注入。

$方式一般用于传入数据库对象，例如传入表名。

尽量多用#方式，少用$方式。

spring事务的隔离级别

隔离级别是指若干个并发的事务之间的隔离程度，与我们开发时候主要相关的场景包括：脏读取、重复读、幻读。

DEFAULT ：这是默认值，表示使用底层数据库的默认隔离级别。对大部分数据库而言，通常这值就是： READ_COMMITTED 。READ_UNCOMMITTED ：该隔离级别表示一个事务可以读取另一个事务修改但还没有提交的数据。该级别不能防止脏读和不可重复读，因此很少使用该隔离级别。READ_COMMITTED ：该隔离级别表示一个事务只能读取另一个事务已经提交的数据。该级别可以防止脏读，这也是大多数情况下的推荐值。REPEATABLE_READ ：该隔离级别表示一个事务在整个过程中可以多次重复执行某个查询，并且每次返回的记录都相同。即使在多次查询之间有新增的数据满足该查询，这些新增的记录也会被忽略。该级别可以防止脏读和不可重复读。SERIALIZABLE ：所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别。

@Transactional(isolation = Isolation.DEFAULT)

spring的事务传播行为意义何在？

例如事务之间的交互，比如A事务失败了，会不会影响B事务，A事务捕获B事务的异常，这时候应该怎么办，要不要回滚，还有一些其他情况，这些都需要spring事务传播行为的支持。
说得通俗一点就是多个具有事务控制的service的相互调用时所形成的复杂的事务边界控制。

REQUIRED ：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。(如果被调用端发生异常，那么调用端和被调用端事务都将回滚)SUPPORTS ：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。MANDATORY ：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。REQUIRES_NEW ：创建一个新的事务，如果当前存在事务，则把当前事务挂起。NOT_SUPPORTED ：以非事务方式运行，如果当前存在事务，则把当前事务挂起。NEVER ：以非事务方式运行，如果当前存在事务，则抛出异常。NESTED ：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于 REQUIRED 。

@Transactional(propagation = Propagation.REQUIRED)

springboot中使用事务

首先在启动类中添加注解，开启事务管理器

@EnableTransactionManagement

然后在service的实现方法上添加注解

@Transactional(rollbackFor = CustomException.class)

MAT使用教程生成内存文件：

加 jvm启动参数，当发生OutOfMemoryError时，机器会自动dump内存快照

-XX:+HeapDumponOutOfMemoryError -XX:HeapDumpPath=$LOG_DIR/java.hprof"

手动生成，通过执行jdk自带命令

jmap -dump:format=b,file=heap.bin

接下就可以用 MAT打开转换后的 hprof文件

打开后的首页，里面是一些堆的基本概要信息，比如空间大小、类的数量、对象实例数量、类加载器等等。

Atcion里面提供了多种分析维度：

Histogram可以列出内存中的对象，对象的个数以及大小。Dominator Tree可以列出那个线程，以及线程下面的那些对象占用的空间。 Histogram

它按类名将所有的实例对象列出来，点击表头（Class Name）可以排序，第一行输入正则表达式可以过滤筛选；

Shallow Heap ：一个对象内存的消耗大小，不包含对其他对象的引用；
Retained Heap ：是shallow Heap的总和，也就是该对象被GC之后所能回收的内存大小；

Dominator Tree

可以列出内存中存活的大对象列表，优点是有Percentage字段，可以看各种情况的百分比。

快速找出某个实例没被释放的原因，可以右健 Path to GC Roots–>exclude all phantom/weak/soft etc. references
，它展示了对象间的引用关系。

步骤总结

生产出现OOM，如何排查

使用dmesg命令查看系统日志

dmesg |grep -E ‘kill|oom|out of memory’，可以查看操作系统启动后的系统日志，这里就是查看跟内存溢出相关联的系统日志。

这时候，需要启动项目，使用ps命令查看进程

ps -aux|grep java命令查看一下你的java进程，就可以找到你的java进程的进程id。

接着使用top命令

top命令显示的结果列表中，会看到%MEM这一列，这里可以看到你的进程可能对内存的使用率特别高。以查看正在运行的进程和系统负载信息，包括cpu负载、内存使用、各个进程所占系统资源等。

使用jstat命令

用jstat -gcutil 20886 1000 10命令，就是用jstat工具，对指定java进程（20886就是进程id，通过ps -aux | grep java命令就能找到），按照指定间隔，看一下统计信息，这里会每隔一段时间显示一下，包括新生代的两个S0、s1区、Eden区，以及老年代的内存使用率，还有young gc以及full gc的次数。

使用 jstat -gcutil 8968 500 5 表示每500毫秒打印一次Java堆状况（各个区的容量、使用容量、gc时间等信息），打印5次。

一般来说大量的对象涌入内存，结果始终不能回收，会出现的情况就是，快速撑满年轻代，然后young gc几次，根本回收不了什么对象，导致survivor区根本放不下，然后大量对象涌入老年代。老年代很快也满了，然后就频繁full gc，但是也回收不掉。

然后对象持续增加不就oom了，内存放不下了，就爆了。

所以jstat先看一下基本情况，马上就能看出来，其实就是大量对象没法回收，一直在内存里占据着，然后就差不多内存快爆了。

线程池ThreadPoolExecutor的核心线程数，最大线程数，队列长度的关系？

关于线程池的几个参数，很多人不是很清楚如何配置，他们之间是什么关系，我用代码来证明一下。

public class ThreadPool {
 
    public static void main(String[] args) {
        // 创建线程池 ， 参数含义 ：（核心线程数，最大线程数，加开线程的存活时间，时间单位，任务队列长度）
        ThreadPoolExecutor pool = new ThreadPoolExecutor(5, 8,
                0L, TimeUnit.MILLISECONDS,
                new linkedBlockingQueue(2));
 
        //设置a的值范围在：a = （corePoolSize-1） ～ (max+queue+1) ,分析：任务数 与 活跃线程数,核心线程数,队列长度,最大线程数的关系。
        int a = 7;
 
        for (int i = 1; i <= a; i++) {
            int j = i;
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    //获取线程名称
                    Thread thread = Thread.currentThread();
                    String name = thread.getName();
                    //输出
                    int activeCount = pool.getActiveCount();
                    System.out.println("任务："+j+"-----,线程名称:"+name+"-----活跃线程数:"+activeCount);
                }
            });
        }
        //关闭线程池
        pool.shutdown();
    }
}

输出结果，观察关系：

//任务数 a = 4 , 活跃线程数4 , 任务数 < 核心线程数。
//任务数 a = 5 , 活跃线程数5 , 任务数 = 核心线程数。
//任务数 a = 6 , 活跃线程数5 , 任务数 < 核心线程数5 + 队列长度2 。
//任务数 a = 7 , 活跃线程数5 , 任务数 = 核心线程数5 + 队列长度2 。

//任务数 a = 8 , 活跃线程数6 , 任务数 < 最大线程数8 + 队列长度2 . 活跃线程数是在核心线程数5的基础上.加1个活跃线程。
//任务数 a = 9 , 活跃线程数7 , 任务数 < 最大线程数8 + 队列长度2. 活跃线程数是在核心线程数5的基础上.加2个活跃线程。
//任务数 a = 10 , 活跃线程数8 , 任务数 = 最大线程数8 + 队列长度2. 活跃线程数是在核心线程数5的基础上.加3个活跃线程。

//任务数 a = 11 , 活跃线程数8 , 任务数 > 最大线程数8 + 队列长度2 。抛出异常RejectedExecutionException

总结：

随着任务数量的增加，会增加活跃的线程数。

当活跃的线程数 = 核心线程数，此时不再增加活跃线程数，而是往任务队列里堆积。

当任务队列堆满了，随着任务数量的增加，会在核心线程数的基础上加开线程。

直到活跃线程数 = 最大线程数，就不能增加线程了。

如果此时任务还在增加，则：任务数11 > 最大线程数8 + 队列长度2 ，抛出异常RejectedExecutionException，拒绝任务。

银行外包面试题及答案-java后端

Java相关栏目本月热门文章