日常积累--

杂项

• 静态方法中没有 this

• raft

• redis 解决时钟跳跃

• 多线程情况下远程接口调用失败如何处理，

  • 使用Future拿到结果，外层根据结果进行处理
  • 对结果进行标记，比如执行失败的有哪些数据，这些数据定时进行重试

• 如何在一个bean初始化过程中去自定义一些操作

  • spring的生命周期定义了一些方法，比如我们在kafka的Bean初始化完成之后订阅topic，要销毁之前取消订阅

java基础 String

String 类中使⽤ final 关键字修饰字符数组来保存字符串， private final char value[] ，所以 String 对象是不可变的。

StringBuffer 对⽅法加了同步锁或者对调⽤的⽅法加了同 步锁，所以是线程安全的。

StringBuilder 并没有对⽅法进⾏加同步锁，所以是⾮线程安全的

接⼝和抽象类的区别是什么

由于静态⽅法可以不通过对象进⾏调⽤，因此在静态⽅法⾥，不能调⽤其他⾮静态变量，也不可 以访问⾮静态变量成员

接⼝和抽象类的区别是什么？

1. 接⼝的⽅法默认是 public ，所有⽅法在接⼝中不能有实现(Java 8 开始接⼝⽅法可以有默认 实现），⽽抽象类可以有⾮抽象的⽅法。
2. 接⼝中除了 static 、 final 变量，不能有其他变量，⽽抽象类中则不⼀定。
3. ⼀个类可以实现多个接⼝，但只能实现⼀个抽象类。接⼝⾃⼰本身可以通过 extends 关键 字扩展多个接⼝。
4. 接⼝⽅法默认修饰符是 public ，抽象⽅法可以有 public 、 protected 和 default 这些修饰 符（抽象⽅法就是为了被重写所以不能使⽤ private 关键字修饰！）。
5. 从设计层⾯来说，抽象是对类的抽象，是⼀种模板设计，⽽接⼝是对⾏为的抽象，是⼀种⾏ 为的规范

dk 8 的时候接⼝可以有默认⽅法和静态⽅法功能。

静态⽅法和实例⽅法有何不同

1. 在外部调⽤静态⽅法时，可以使⽤"类名.⽅法名"的⽅式，也可以使⽤"对象名.⽅法名"的⽅ 式。⽽实例⽅法只有后⾯这种⽅式。也就是说，调⽤静态⽅法可以⽆需创建对象。
2. 静态⽅法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态⽅法），⽽不 允许访问实例成员变量和实例⽅法；实例⽅法则⽆此限制

== 与 equals(重要)

== : 如果是基本数据类型·等。即，判断两个对象是不是同⼀个对象(基本数据 类型⽐᫾的是值，引⽤数据类型⽐᫾的是内存地址)。

equals() : 它的作⽤也是判断两个对象是否相等。

但它⼀般有两种使⽤情况：

• 情况 1：类没有覆盖 equals() ⽅法。则通过 equals() ⽐᫾该类的两个对象时，等价于通过 “==”⽐᫾这两个对象。
• 情况 2：类覆盖了 equals() ⽅法。⼀般，我们都覆盖 equals() ⽅法来⽐᫾两个对象的内容是 否相等；若它们的内容相等，则返回 true (即，认为这两个对象相等)

为什么重写 equals 时必须重写 hashCode ⽅法

两个对象相等,对两个对象分别调⽤ equals ⽅法都返回 true。但是，两个对象有相同的 hashcode 值，它们也不⼀定是是相等的 。

其实简单的说就是为了保证同一个对象，保证在equals相同的情况下hashcode值必定相同，如果重写了equals而未重写hashcode方法，可能就会出现两个没有关系的对象equals相同的，但hashcode确实不相同的。

HashSet中 hashcode方法的作用存入数据时先根据hash值 计算位置 如果位置中有 则执行equals方法 如果相等则不存 不相等 则再进行散列

当你把对象加⼊ HashSet 时， HashSet 会先计算对象的 hashcode 值来判断对象加⼊的位置， 同时也会与其他已经加⼊的对象的 hashcode 值作⽐᫾，如果没有相符的 hashcode， HashSet 会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调⽤ equals() ⽅ 法来检查 hashcode 相等的对象是否真的相同。如果两者相同， HashSet 就不会让其加⼊操作成 功。如果不同的话，就会重新散列到其他位置。

private/final/static 则⼦类就不能重写该⽅法,但是被 static 修饰 的⽅法能够被再次声明

Mysql

如何快速下载数据，使用 sqldump

RR 隔离级别 解决了部分幻读

java8 之后 concurrentHashMap 取消了segment分段锁，采用cas和synchronized 保证并发安全， 只锁定当前链表或者红黑树的首节点，只要hash不冲突，就不会产生竞争情况，效率更高。

vaicon面试题：sql 语句优化会不会, 说出你知道的?
(1) 避免在列上做运算，可能会导致索引icon失败
(2) 使用 join 时应该小结果集驱动大结果集，同时把复杂的 join 查询拆分成多个 query，
不然 join 越多表，会导致越多的锁定和堵塞。
(3) 注意 like 模糊查询的使用，避免使用%%
(4) 不要使用 select * 节省内存
(5) 使用批量插入语句，节省交互
(6) Limit 基数比较大时，使用 between and
(7) 不要使用 rand 函数随机获取记录
(8) 避免使用 null，建表时，尽量设置 not nul，提高查询性能
(9) 不要使用 count（id），应该使用 count（*）
(10) 不要做无谓的排序，尽可能在索引中完成排序
(11) From 语句中一定不要使用子查询
(12) 使用更多的 where 加以限制，缩小查找范围
(13) 合理运用索引
(14) 使用 explain 查看 sql 性能

多线程 同一个类中的 2 个方法都加了同步锁，多个线程能同时访问同一个类中的这两个方法吗？

• Lock 可以让等待锁的线程响应中断，Lock 获取锁，之后需要释放锁LOCK多个线程不可访问同一个类中的 2 个加了 Lock 锁的方法。
• 而 synchronized 却不行，使用 synchronized 时，当我们访问同一个类对象的时候，是同一把锁，所以可以访问该对象的其他 synchronized 方法

如何避免死锁

1）加锁顺序（线程按照一定的顺序加锁）

2）加锁时限（线程尝试获取锁的时候加上一定的时限，超过时限则放弃对该锁的请求，并释放自己占有的锁）

Java 中多线程间的通信怎么实现

1.共享变量

2.wait/notify 机制

启动一个线程是调用 **run()**方法还是 **start()方法？

• 启动一个线程是调用 start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由 JVM 调度并执行，这并不意味着线程就会立即运行。
• run()方法是线程启动后要进行回调（callback）的方法

内部类

内部类 要new 要new out().new inner()

动静态代理的区别，什么场景使用？

• 静态代理通常只代理一个类，动态代理是代理一个接口下的多个实现类。
• 静态代理事先知道要代理的是什么，而动态代理不知道要代理什么东西，只有在运行时才知道。
• 动态代理是实现 JDK 里的 InvocationHandler 接口的 invoke 方法，但注意的是代理的是接口，也就是你的业务类必须要实现接口，通过 Proxy 里的 newProxyInstance 得到代理对象
• 还有一种动态代理 CGLIB，代理的是类，不需要业务类继承接口，通过派生的子类来实现代理。通过在运行时，动态修改字节码达到修改类的目的。

AOP 编程就是基于动态代理实现的，比如著名的 Spring 框架、Hibernate 框架等等都是动态代理的使用例子

在开发中遇到过内存溢出么？原因有哪些？解决方法有哪些？ WEB 长链接

HTTP1.1 默认保持长连接（HTTP persistent connection，也翻译为持久连接），数据传输完成了保持 TCP 连接不断开（不发 RST 包不四次握手），等待在同域名下继续用这个通道传输数据；相反的就是短连接

Spring 有哪些不同类型的 依赖注入DI方式？

1.Set 注入

2.构造器注入

3.静态工厂的方法注入

调用静态工厂的方法 获取需要的对象

4.实例工厂的方法注入

Spring 支持的几种 bean 的作用域。

• singleton : bean 在每个 Spring ioc 容器中只有一个实例。
• prototype 原型：每次创建一个新的对象
• request：每次 http 请求都会创建一个 bean，该作用域仅在基于 web 的 Spring ApplicationContext 情形下有效。
• session ：在一个 HTTP Session 中 ， 一 个 bean 定义对应一个实例。该作用域仅在基于 web 的Spring ApplicationContext 情形下有效。
• global-session：在一个全局的 HTTP Session 中，一个 bean 定义对应一个实例。该作用域仅在基于 web 的Spring ApplicationContext 情形下有效。
• 缺省的 Spring bean 的作用域是 Singleton。

Spring 框架中的单例 bean 是线程安全的吗

不是，如果要达到线程安全可以使用 proptotype 每次注入都new一个新的 达到线程安全，自己手写的 单例bean 可以实现线程安全

SpringMVC request 接收设置是线程安全的吗？

是线程安全的，request、response 以及 requestcontext 在使用时不需要进行同步。

而根据 spring 的默认规则，controller 对于 beanfactory 而言是单例的。即 controller 只有一个， controller 中的request 等实例对象也只有一个

spring循环依赖

经常由于设计不佳或者各种因素，导致类之间相互依赖。这些类可能单独使用时不会出问题，但是在使用Spring进行管理的时候可能就会抛出BeanCurrentlyInCreationException等异常 。当抛出这种异常时表示Spring解决不了该循环依赖，

• A的构造方法中依赖了B的实例对象，同时B的构造方法中依赖了A的实例对象
• A的构造方法中依赖了B的实例对象，同时B的某个field或者setter需要A的实例对象，以及反之
• A的某个field或者setter依赖了B的实例对象，同时B的某个field或者setter依赖了A的实例对象，以及反之

在全是构造方法中相互依赖的情况解决不了

使用到单例 和

三级缓存

singletonObjects指单例对象的cache，

singletonFactories指单例对象工厂的cache，

earlySingletonObjects指提前曝光的单例对象的cache

@Component
public class A {
    // A中注入了B
	@Autowired
	private B b;
}

@Component
public class B {
    // B中也注入了A
	@Autowired
	private A a;
}

或者
--------------------

@Component
public class A {
//	@Autowired
//	private B b;
	public A(B b) {

	}
}

@Component
public class B {

//	@Autowired
//	private A a;

	public B(A a){

	}
}

spring事务失效的场景

• 未启用spring事务管理功能： @EnableTransactionManagement 注解用来启用spring事务自动管理事务的功能，这个注解千万不要忘记写了

• 方法不是public类型的

  • @Transaction 可以用在类上、接口上、public方法上，如果将@Trasaction用在了非public方法上，事务将无效

• 数据源未配置事务管理器

• 自身调用问题 未使用代理类

  • spring是通过aop的方式，对需要spring管理事务的bean生成了代理对象，然后通过代理对象拦截了目标方法的执行，在方法前后添加了事务的功能，所以必须通过代理对象调用目标方法的时候，事务才会起效。

    @Component
    public class UserService {
        public void m1(){
            this.m2();
        }
        
        @Transactional
        public void m2(){
            //执行db操作
        }
    }
    //因为m1中通过this的方式调用了m2方法，而this并不是代理对象，this.m2()不会被事务拦截器，所以事务是无效的，如果外部直接调用通过UserService这个bean来调用m2方法，事务是有效的
    

• 异常类型错误

  • RuntimeException和Error的情况下，spring事务才会回滚。

  • //可以自定义异常类型列表
    Transactional(rollbackFor = {异常类型列表})
    

• 异常被吞

  • 在方法内 将异常try catch 了没有抛出异常

• 业务和spring事务代码必须在一个线程中

  • spring事务实现中使用了ThreadLocal，如果不在一个线程中事务失效

  //
  @Transactional
  public void m1() {
      new Thread() {
          一系列事务操作
      }.start();
  }
  

2、如何快速定位事务相关bug？ 方式1：看日志

如果你使用了logback或者log4j来输出日志，可以修改一下日志级别为debug模式，可以看到事务的详细执行日志，帮助你定位错误

方式2：调试代码

如果你对源码比较了解，那么你会知道被spring管理事务的业务方法，执行的时候都会被TransactionInterceptor拦截器拦截，会进入到它的invoke方法中，咱们可以在invoke方法中设置一些断点，可以看到详细的执行过程，排错也就比较容易了。

jdk 还是cms

1.8默认 是ps po

简单说一下本地事务和分布式事务的区别

• 本地事务就是同一个数据库，同一个链接。
• 分布式，就是通过其他的第三方协调者加日志，完成不同数据库的事务。

spring事传播机制

(66条消息) Spring事务传播机制_霂宇的博客-CSDN博客_spring事务的传播机制

REQUIRED（默认）：支持使用当前事务，如果当前事务不存在，创建一个新事务。 任意异常都回滚

子事务	主事务	结果
异常	正常，并try-catch异常	均回滚
正常	异常	均回滚
正常	异常，并try-catch异常	不回滚

SUPPORTS：支持使用当前事务，如果当前事务不存在，则不使用事务。
MANDATORY 强制：中文翻译为强制，支持使用当前事务，如果当前事务不存在，则抛出Exception。
REQUIRES_NEW：创建一个新事务，如果当前事务存在，把当前事务挂起。 相对独立，子异常 主try-catch

子事务	主事务	结果
异常	正常，并try-catch异常	子回滚，主不回滚
正常	异常	子不回滚，主回滚
异常	正常	均回滚

NOT_SUPPORTED：无事务执行，如果当前事务存在，把当前事务挂起。
NEVER：无事务执行，如果当前有事务则抛出Exception。
NESTED：嵌套事务，如果当前事务存在，那么在嵌套的事务中执行。如果当前事务不存在，则表现跟REQUIRED一样。

2.3 子事务的传播机制为NESTED 嵌套 外层回滚 内部也回滚

子事务	主事务	结果
异常	正常，并try-catch异常	子回滚，主不回滚
正常	异常	均回滚
异常	正常	均回滚

​ 子事务异常，主事务try-catch了异常，REQUIRED情况下主子均会回滚，但NESTED模式主不会回滚。因此可以看下场景一，NESTED是如何处理的。

事务隔里级别

1、isolation_default

使用数据库默认的事务隔离级别

2、isolation_read_uncommitted

允许读取尚未提交的修改，可能导致脏读、幻读和不可重复读

3、isolation_read_committed

允许从已经提交的事务读取，可防止脏读、但幻读，不可重复读仍然有可能发生

4、isolation_repeatable_read

对相同字段的多次读取的结果是一致的，除非数据被当前事务自生修改。可防止脏读和不可重复读，但幻读仍有可能发生

**5、isolation_serializable ** 幻读读到了前一次查询没查到的行

完全服从acid隔离原则，确保不发生脏读、不可重复读、和幻读，但执行效率最低。

JVM

线上内存占用过高 频繁GC

OOM

引起内存溢出的原因有很多种，常见的有以下几种：

1.内存中加载的数据量过于庞大，如一次从数据库取出过多数据；

2.集合类中有对对象的引用，使用完后未清空，使得 JVM 不能回收；

3.代码中存在死循环或循环产生过多重复的对象实体；

4.使用的第三方软件中的 BUG；

5.启动参数内存值设定的过小；

内存溢出的解决方案：

第一步，修改 JVM 启动参数，直接增加内存。(-Xms，-Xmx 参数一定不要忘记加。)

第二步，检查错误日志，查看“OutOfMemory”错误前是否有其它异常或错误。

第三步，对代码进行走查和分析，找出可能发生内存溢出的位置。

重点排查以下几点：

• 1.检查对数据库查询中，是否有一次获得全部数据的查询。一般来说，如果一次取十万条记录到内存，就可能引起内存溢出。这个问题比较隐蔽，在上线前，数据库中数据较少，不容易出问题，上线后，数据库中数据多了，一次查询就有可能引起内存溢出。因此对于数据库查询尽量采用分页的方式查询。
• 2.检查代码中是否有死循环或递归调用。
• 3.检查是否有大循环重复产生新对象实体。
• 5.检查 List、MAP 等集合对象是否有使用完后，未清除的问题。List、MAP 等集合对象会始终存有对对象的引用，使得这些对象不能被 GC 回收。

第四步，使用内存查看工具动态查看内存使用情况

• 最常见的原因就是应用程序需要的堆空间是大的，但是 JVM 提供的却小。
  • 这个的解决方法就是提供大的堆空间即可。除此之外还有复杂的原因：，
• 内存泄露：特定的编程错误会导致你的应用程序不停的消耗更多的内存，每次使用有内存泄漏风险的功能就会留下 一 些 不 能 被 回 收 的 对 象 到 堆 空 间 中 ， 随 着 时 间 的 推 移 ， 泄 漏 的 对 象 会 消 耗 所 有 的 堆 空 间 ， 最 终 触 发java.lang.OutOfMemoryError: Java heap space 错误。

解决方案：第一个解决方案是显而易见的，你应该确保有足够的堆空间来正常运行你的应用程序，在 JVM 的启动配置中增加

如下配置：-Xmx1024m

• 流量/数据量峰值：应用程序在设计之初均有用户量和数据量的限制，某一时刻，当用户数量或数据量突然达到一个 峰 值 ， 并 且 这 个 峰 值 已 经 超 过 了 设 计 之 初 预 期 的 阈 值 ， 那 么 以 前 正 常 的 功 能 将 会 停 止 ， 并 触 发java.lang.OutOfMemoryError: Java heap space 异常

解决方案，如果你的应用程序确实内存不足，增加堆内存会解决 GC overhead limit 问题，就如下面这样，给你的应用程序 1G 的堆内存

A a = new A(); 在jvm中的过程

更改jvm参数怎么影响到栈的大小

定期回收和惰性回收

MQ

什么情况下使用mq，

面试题

讲一下最近接触的项目，担任的角色，遇到过那些问题，如何解决的？
2. 项目中用到多线程icon没有，怎么用的（有延伸）？
3. 如何解决高并发下数据重复问题？

1. 加分布式锁，但是会影响性能
2. 产生的数据结果 有唯一索引比如主键等 能够标识数据唯一的，入库时做处理
3. 单机情况下 可以考虑使用布隆过滤器，对能够标识的值 进行过滤，如果存在则不处理
4. 对springicon的理解和springboot 特点及原理
5. 关于MQ如何保证消息幂等性？
   1. 生成端重复发送，Mq_server收到消息后ack，可以生成消息Id，id要由MQ生成与业务无关
   2. 消费端，消费端 收到后ack，使用业务数据生成唯一Id，业务相关
6. mq消息堆积
   1. 是消费者消费能力不足，那么就要排查是什么原因导致的消费能力不足，适当增加消费者的数量
7. 数据库sql优化，db锁用法
8. 7.15s左右将大小1G的bcp文件数据入库（大概200万条以上），你有什么思路？
9. 大容量复制程序（又称为bcp）是控制台应用程序，用于将数据从文本文件导出和导入到SQL Server，反之亦然。
10. 多线程，分段处理

线程的调度算法

华为外包考点1

• .for循环可以使用break跳出循环，但forEach不能。
• 2.for循环可以控制循环起点（i初始化的数字决定循环的起点），forEach只能默认从索引0开始。
• 3.for循环过程中支持修改索引（修改 i），但forEach做不到（底层控制index自增，我们无法左右它）。
• forech 遍历集合的时候 使用的是iteator 不能删除元素 只能使用iteator的删除方法 不能修改元素 只能修改元素的属性
• foreach 必须从头遍历 不能指定下标 适合全部遍历 ，不知道集合大小的情况

网路模型

jvm优化 可以扯 方法内联

面试官问 堆和栈的区别 可以拓展 逃逸分析中的栈上分配

jvm优化 尽量不要逃逸

springboot注解 controller

lambda 在项目中的应用

起线程的时候

微服务通讯原理

项目部署在哪里 部署在虚拟机和 仓库中的区别

docker解决了运行环境不一致带来的问题 
docker镜像 可以放在 docker仓库中 在其他地方可以快速部署
docker部署更快 
docker 的镜像很小  

nginx 如何配置

分布式锁

线程安全的集合

redis 缓存穿透

restful put请求能做删除方法吗

可以 get post 就能把增删改查做完 既然用restful风格还是要遵守