SpringBoot的运行机制是怎么样的？

回答：从他的核心注解@springBootAppcliation开始，进入以后包含有三个注解；
第一注解是@SpringBootConfiguration注解，其实就是spring里面的Configuartion注解，它是用来标识一个类为配置类的；
第二个注解是@ComponentScan,这个也是spring里面的，它是用来将指定包下面需要装配的组件注册到容器里面去;
第三个注解是@EnableAutoConfiguration，这个注解也是springboot自动装配的核心注解；进入EnableAutoConfiguation以后会发现包含两个注解，第一个注解叫@AutoConfigurationPackage，他、它的作用是作为自动配置的包进行管理；第二个注解叫@import;它的作用是导入一类到ioc容器中，导入什么类呢，是根据meta-inf下面的spring.factories的配置进行导入的。
面试管总结：其实就是springboot通过根据配置文件，自动装配所属依赖的类，在用动态代理的方式注入到spring容器里面。（需要根据自己的理解总结话术）

Mybatis的二级缓存怎么开启？

回答：只需要在mybatis的配置文件里面去开启二级缓存，并且在mapper.xml里面打上cache标签就可以了。
面试管总结：由于求职者没使用过，说了一些mybatis的弊端，但是他根据以往的项目经验怎么样去解决此类问题的。说了一些用redis的使用？

redis缓存穿透，缓存血崩，缓存击穿怎么解决？

求职者先阐述了他们产生的原因，基于他产生的原因提出的解决方案。

SpringCloud里面的组件用过那些呢？

回答:用过的呢用五个组件，比如说eureka注册中心，网关 Zuul ，ribbon 负责那个负载均衡，configServe配置中心，还有就是hytrix熔断器。
面试官总结：eureka，Zuul ，ribbon ，configServe，hytrix，fegin等都进行描述。用到ribbon 负载均衡是因为服务可能部署多个，而此时具体的请求访问到的一个服务是不确定的，因此就要用到负载均衡；

负载均衡肯定有自带的策略，有几种呢？

回答：1.有随机分配（轮询）2.权重分配，3，还有hashcode,4.还有用户自定义分配，就是根据你业务模块的头部携带你自定一的一些用户信息进行它的随机负载进行分配。

熔断器它的阈值默认线程数是多少？

Mysql的索引数据结构？

回答：索引他是帮助数据库高效获取数据的一种数据结构，mysql它主要支持hash和B+tree，hash它对范围查询是不支持的，而B+tree是支持范围查询的，我们的myisam和innodb两种存储引擎都支持b+tree和hash。注意可能还问你B+tree、hash和红黑树的区别。
缺点：虽然能提高查询效力，但牺牲插入删除等的性能，因为每次的数据变更都需要去维护索引结构，带来大量的io开销，因此我们在索引创建的时候就要去考虑对一些唯一性较差，或者经常频繁更改的字段 不应该建立索引，而对一些唯一性较高并且经常作为查询或者过滤条件或者排序条件的字段可以建立索引，像比如说我们的电话号，当然每张表建索引的个数是有限的，单张只能对16个字段建立索引，建立索引后还有一些sql语法，导致索引失效，如or连接，isnull判断，不等于。

String,StringBuid，Stringbuffer的区别和使用场景？

答:通常我们需要改一个字符串的时候点apand,去使用stringbuid或者使用string buffer；
第一个区别:
string是final修饰的，不可变，每次操作都会产生新的对象。比如说string str=abc,给它加个d操作，就会生成一个新的对象。缺点:会浪费内存。而stringbuid和stringbuffer呢是在原对象进行操作，不会生产新的对象。
场景:经常需要操作或者改变字符串内容时使用stringbuid和stringbuffer。
区别2:
stringbuffef和stringbuid又有什么区别呢？
stringbuffer是线程安全的，而stringbuider是非线程安全的。
线程安全和非线程安全是什么意思？
答:当使用连个方法时需要考虑需要不需要枷锁sy来保证它的值会不会变，场景是必须满足多线程，共享变量，结果不改变。就是对象是否安全的判断。
由于stringbuffer的每个方法都加了sy修饰。所以是线程安全的。
两个的使用场景的呢？
性能,stringbuild>stringbuffer>string 通常企业都考虑性能和线程安全。
优先使用stringbuild，如果是多线程使用共享变量时使用stringbuffer

Mysql的索引数据结构？

你说下你对分布式是怎么理解的?

回答:分布式的话就相当于把一些核心的业务单独分离出来，像传统的的单体服务的话，如果他的一些核心功能挂掉的话，那么他整个的应用就会挂掉，如果是分布式的话，一个服务挂掉它不会影响整个服务使用，只是一块服务不能使用而已。

那你们这个项目里面大概分了多少服务?

答:像一些基本的服务，eureka,config,然后还做了一个user的一个服务，redis也做了一个服务，es也做了一个服务，

你们的业务服务有多少个?

答:四五个吧！

你说一下，springcloud你们用了哪些主键?

答:像我们服务要注册与发现嘛，会用到euraka，服务之前发起调用的话，然后会用到feign接口，像如果一个服务都挂在一个机器上的具体不知道调用哪一个，那我们就可以用Ribbon来做负载均衡，他里面有一些算法像轮询啊这些，还有随机啊，还有还可以使用到hytrix的时候，

除了随机和轮询以外还有什么其他的策略?

答:目前就了解到这些。
答:hytrix的话服务与服务之间，如果他没有保护机制的话那么它可能会出现服务雪崩，像比如a服务调用b服务，b服务挂掉的话，那么a服务也会卡在那里，像比如其他服务调用过来，那么会一直出现这种连锁反应，就会出现服务雪崩这种情况，那么我们就可以用hytix，然后用他的这个熔断机制，来访问他的托底信息。zuul的话，大概就是我们用户发起请求然后用zuul来调用具体的服务，config的话是一个配置中心，一般我们是用他来去配置的。

那他们的这个比如说euraka底层有没有去了解过?

答:像它服务注册的时候，它会向euraka进行注册嘛，euraka的话它会生成一个注册的清单。服务与这个清单的话，每个注册的服务它也可以向它拉取下来，如果它需要调用其他的话，可以通过这个清单找到其他服务，从而发去一个调用，

那如果euraka挂了呢？

答:可以对euraka做一个集群操作，

挂了是不是这些马上就不能使用了？

答:不会立马挂掉，比如他每隔一段时间会对服务进行探测，这个服务现在导入一些信息的话，那就证明它还没挂掉，

spring了解吗？

答:spring的话它一个轻量级的容器框架嘛，它的最主要的特点是ioc和aop。
ioc的话就是控制反转嘛，如果是我们自己创建对象的话这样管理起来就来就会很麻烦，那我们用spring的ioc把这个对象的控制权交给spring容器来管理，然后我们可以通过@autowired和@resource来进行注入，aop的话就是一个面相切面的一个编程，相当于对一部分代码进行一个切割，在不改变原来代码的情况下进行增强，一般使用jdk和cglib动态代理的方式，我们一般用来做事务呀还有日志这一类的，像事务的话就是通过注解这种方式，因为比较方便，

那你知道jdk的动态代理和cglib的动态代理有什么区别吗？

答:一个是实现一个接口的时候就会用到jdk动态代理，另一个的话实现类就用
cglib动态代理，

哪一种的性能好一点呢？

JDK1.8之前cglib性能好些，jdk1.8之后是jdk动态代理好一些。cglib底层是用Asm字节码实现。当有final修饰的不能进行代理。

@Asperctj有没有了解过?

spring框架里集成了这个aop框架，

你刚才说ioc，把创建对象的权利交给spring管理，那spring创建出来的对象，他的作用域有那些呢？

答:一个是singleton 单例的。prototype 多实例的，一个request ,请求结束销毁，一个session 会话结束销毁，最后一个gola sesiion 全局的。

spring创建出来的对象默认是单例是吧，他创建出来的单利可能产生线程安全问题，spring在这个单利的问题上怎么解决的?

答:如果配置是xml的话，可以把它配置成多利的，如果是单利呢？可以用threadlocal来做。

你们平时会不会在controller层或者其他层定义这个全局的一些变量，?你们是用单利吗？不会产生线程安全问题吗？

答案:是会的,会产生线程安全问题的。

那你说下#和＄号有什么区别？

答:#号的话就类似于原生的jdbc的properties,它可以有效的防止SQL注入，
像KaTeX parse error: Expected 'EOF', got '#' at position 37: …种的话，如果是一个字段就不能用#̲这种来取，就会用来取，

mybatis里面我们经常去写一个xml，里面的接口方法是怎么和标签绑定的?

答:通过id去绑定的，常用的标签有那些?select,update,delete,insert,其他一对一，一对多有个核心关键collection这种做映射嘛，

嵌套查询和嵌套结果有啥区别？

博客

hashmap底层原理?

答:jdk1.7之前是基于数组和链表，jdk1.8之后是基于数组和链表和红黑树的，它进行一个存值的话，它会先将k值进行一个hash运算，然后找到一个存储位置，如果位置上有值的话将他们的key进行对比，如果key相同话就会进行覆盖，他会在后面的方法进行一个返回，如果不同的话，就是以红黑树或者链表的形式来进行存取，如果超过了他的容量会进行扩容，
扩容为多少呢？
底层实现分析

扩容为多少呢？

答，扩容到原来两倍。

数组的初始容量多少呢？

答:16，

那你知道为什么扩容总是2的次幂?

你说下cookie和session的区别吧！

答:他们都是回话跟踪技术嘛，cookie主要存在于客户端，session主要存储在服务端，一般session是依赖cookie来存储，session的id是存在cookie里，，你刚说session依赖于cookie，如果浏览器把cookie禁用了，session还能用吗？这样的话可以从新写一个URL，写在里面，

mysql的事务隔离级别是什么？事务隔离级别有哪些？，可重复读会出现幻读吗（有坑）？

隔离级别是用来解决事务并发访问出现的脏读、幻读，不可重复读从而保证数据的完整性和一致性。
读未提交，事物的最低级别，就是事物可以读到其他事物没有提交的数据，会产生脏读，不可重复读，幻读情况。
读已提交，对于同一个数据，必须等其他事物提交以后，才能读取，他是不会产生脏读的，但是呢可能会产生不可重复读和幻读的现象。
可重复读，是mydSQL默认的隔离级别，是不会产生脏读，和不会产生不可重复读，有可能产生幻读，innodb除外。
最高级别的串行化，不会产生脏读不可重复读，幻读等，它是加锁读的，事物只能一个一个处理，不能并发处理。

● 读未提交（Read uncommitted）
安全性最差,可能发生并发数据问题,性能最好
● 读已提交（read committed）（oracle默认的）
Oracle默认的隔离级别
● 可重复读（repeatable read）
MySQL默认的隔离级别,安全性较好,性能一般
● 串行化（Serializable
表级锁，读写都加锁，效率低下,安全性高,不能并发

未提交读，就是一个事务可以读到另一个事务提交后的数据，还有一个序列化，这个是最高级别的，那么他将事务进行窜行化，默认级别就是数据库用什么它就用什么。

那你给我说一下什么是脏读，幻读，不可重复读?

1.脏读是指事务读取到其他事务没提交的数据。

测试：
A事务：

#改成未提交读
SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;

#开启事务
START TRANSACTION;

#修改苹果为西瓜
UPDATE product SET pname='西瓜' WHERE id=1;
#
SELECT * FROM product WHERE id=1;

2.不可重复读
是指在同一次事务中前后查询不一致的问题。

不可重复读描述： A事务查询两次的结果不一致，A事务查询后，B事务对事务进行了修改commit，b那里已经改变了，但是A事务查的还是原来的数据，产生幻读。
3.幻读
是一次事务中前后数据量发生变化用户产生不可预料的问题。

幻读描述：在事务A中，第一次查询出三条数据，同时又开始了事务B，B事务在此之上又添加了一条数数据，比如添加id=4的数据，并且已提交。然后A再次查的查的时候还是三条数据，但是在增加数据时，比如加id=4时就是执行报错。产生幻读现象。

不可重复读和幻读的区别

很多人容易搞混不可重复读和幻读，确实这两者有些相似。但不可重复读重点在于update和delete，而幻读的重点在于insert。

你们用数据库的时候有没有产生死锁的情况，死锁的话，他一般就相当于得到这把锁，但是没有最后释放，就会造成一个死锁的情况，

数据库的优化?

答，可以添加索引嘛，索引他是快速查询检索数据的一种结构，一般像这样忙经常查的呀，就可以对他进行一个索引项，wher,order by这种，但是有些时候我们可以就是避免这种索引失效的写法，像like，模糊匹配前置和or这种都会使索引失效，

mybatis他支持的索引类型有那些?一般常用的是唯一索引，组件索引

你知道索引的底层结构是怎么样的嘛？答:B+tree，类似于红黑树，和红黑树有什么不同吗？

聚集索引和非聚集索引的区别?

mysql的存储引擎？

你们在平常的工作中怎么使用redis啊？

做缓存之类就用到Redis，
怎么保证缓存双写和数据库的双写是一致性的呢？

redis你还了解吗？

他是一种单线程的嘛，他比普通的关系型数据库还有快，因为他在内存中嘛，所以我们可以做一些缓存之类的操作，它常用的数据类型，比如有string，list，hsah,set和sorset，可以做一些淘汰策略，lru就是从他的最近使用最少得在设置的过期时间当中，淘汰掉使用最少得数据，
Redis同样可以做一些持久化操作，比如rdb和aof，rdb是相当于每隔一个时间段进行一个持久化操作，aof就是每设置一个命令就进行一次，

rdb和 aof两种持久化策略，有什么区别吗？那一种效率高一点，

答:rdb效率高一些，因为aof每设置一次命令就进行全局的操作，
那你们项目用了什么持久化操作，rdb和aof，

说一下什么是restful风格?

就是一种请求风格，比如相同的名字，请求类型不一得到的数据也不一，
linux如何动态的去查看日志?

正向代理与反向代理的区别和使用场景？

Nginx怎么配置的呢？

spring cloud alibaba 面试题

alibaba 微服务面试题

负载均衡不满足可以修改吗？

答：可以的。基于IRule接口进行定义修改

自定义负载均衡！

答：方式1：在yaml文件中配置，
方式2: 配置启动类实现 @Bean注解进行配置 IRule接口

springcloud-alibaba 之负载均衡，或者说为什么写这个注解就可以有负载均衡了？

首先通过**@LoadBalanced注解**，使RestTemplate拥有负载均衡的功能。LoadBalancerClient这个接口有个实现类，叫RibonLoadbalancerClient,当你在这个这个类中的这个方法里打断点，运行可以看到RibonAutoConfiguration这个配置类(自动装配的那个类)。而实现负载均衡那个功能的是有那个IRule接口实现的。点击ctrl+H可以看到，RandomRule随机、RoundRobinRule轮询、权重等负载均衡的算法。

使用这个@LoadBalanced注解后，当启动项目时spring会自动配置一个拦截器，然后调用这个LoadBalancerClient。

Feign

答：是一个封装了类似与httpclient的声明式web客户端。
什么是声明式呢，只有声明接口没有接口的实现类。在controller层调用接口即可。
默认集成了负载均衡，也是集成了Ribon实现的

Feign的底层实现Ribon的负载均衡功能？

Feign的底层实现原理？

服务器和客户端如何链接，两服务器之间？

seversocket 和 socket 俩个对象，基于http协议传输。通过io流通讯。

throw 和 throws的区别？

1.throw语句总是出现在方法体里面，用来抛出一个异常，表示在这个地方就有一个异常出现，程序会在throw后面立即终止，它后面的语句将执行不到。
而throws是出现在方法名的后面，用来把方法中出现的异常抛出去给调用者处理。
当方法中出现了异常自己不想处理，那么可以使用throws在方法名后面将异常抛出
去给调用者处理。
（2）throw只能抛出一个异常对象。
而throws可以在方法名后面一次性抛出多个异常，多个异常对象以逗号分隔。
（3）throw抛出异常时，调用它的方法时可以不声明或不捕获，虽编译器不会报错，但是从开发角度说还是要使用try-catch来处理这个异常。
而throws抛出异常时，调用它的方法时也要声明抛出异常或者进行try-catch捕获，否则编译会报错。

sleep和wait的区别

博客来源
sleep() 方法是线程类（Thread）的静态方法，让调用线程进入睡眠状态，让出执行机会给其他线程，等到休眠时间结束后，线程进入就绪状态和其他线程一起竞争cpu的执行时间。

wait()是Object类的方法，当一个线程执行到wait方法时，它就进入到一个和该对象相关的等待池，同时释放对象的机锁，使得其他线程能够访问，可以通过notify，notifyAll方法来唤醒等待的线程

CAP原则

CAP原则又称CAP定理，指的是在一个分布式系统中，一致性（Consistency）、可用性（Availability）、分区容错性（Partition tolerance）。CAP 原则指的是，这三个要素最多只能同时实现两点，不可能三者兼顾。
一致性（C）：在分布式系统中的所有数据备份，在同一时刻是否同样的值。（等同于所有节点访问同一份最新的数据副本）
可用性（A）：保证每个请求不管成功或者失败都有响应。
分区容错性（P）：系统中任意信息的丢失或失败不会影响系统的继续运作。

集群的作用？

答：解决高可用，一个服务器宕机了，可以切换另一个服务。

负载均衡？

答：解决高并发，当一个服务访问量过多时，采用轮询，权重，hash等算法切换服务器来解决。

maven出现依赖冲突时，怎么解决？

依赖冲突解决

通过类名点class发射获取字节码对象？

springboot生命周期？

通常指bean生命周期，bean创建—初始化—销毁
构造(对象创建)：
单实例：在容器启动的时候创建对象;
多实例：在每次获取的时候创建对象；
初始化：
对象创建完成，并赋值好，调用初始化方法
销毁：
单实例，容器关闭的时候；
多实例：容器不会管理bean，容器调用销毁方法

springboot热部署？

热部署

spring bean的加载方式：

三种

第一种：
在需要加载的类如user加个@Componet注解，在配置类再加@ComponetScan扫描包注解。
第二种：（推荐）
通过@Bean注解的方式，比如在启动类上加，public User user(){ new user()} 返回值是方法名
第三种：
通过在启动类上加@imprt（User.class）方式来。

springSercurity默认是post请求路径！

单体架构时登录过程存信息的过程

401错误？405？403？

401 : 访问资源时没有认证。
403 : 访问资源时没有权限。
404：访问的资源找不到（一定要检查你访问资源的url）
405: 请求方式不匹配（客户端请求方式是GET，服务端处理请求是Post就是这个问题）
500: 不看后台无法解决？（error,warn）

base64加密？比md5好

Git冲突解决方案

第一步：pull拉下来一下，更新程序，
第二步：同步，查看冲突代码，《《《《到===表示更新后的，====到》》》表示更新前的。vi text.txt
第三步：人工修改，保持本地最新版,和队友商量修改。
第四步：Add to Git Index，提交修改
第五步：Commit提交

idea时怎么解决？

冲突后有个merge可视化的对话框！
可以看到更新前更新后的内容。》》表示添加，叉叉都是删除。

int和Integer？

int 默认0，integer默认为null,基本类型，包装类是引用类型，包装类有缓存，如btpye缓存类型范围是-128-127.

享元模式，用到池时

MyISAM与InnoDB 的区别

1.InnoDB支持事务，MyISAM不支持，
2.InnoDB支持外键，而MyISAM不支持。
3.InnoDB是聚集索引， MyISAM是非聚集索引，
4.InnoDB支持行锁，MyISAM支持表锁，

什么是关系型数据库和非关系型数据库

关系数据库：是建立在关系模型基础上的数据库，
非关系型数据库：简称NOSQL，是基于键值对的对应关系

悲观锁

就是操作系统将会悲观的认为，如果不严格同步线程调用，那么一定会因为线程间的竞争而产生异常。所以互斥锁会将资源锁定，只供一个线程使用，而阻塞其他线程。其他得得等这个执行完释放锁，拿到到锁之后才可以访问资源。

互斥锁不是万能的，如果都是读操作就不需要每次都去锁定资源。

CAS

CAS（Compare and swap）比较与交换， 是一种有名的无锁算法，将资源设置成可访问的状态比如0，或者不可访问状态1，当多个线程看到资源状态为0时，此时都读到了，产生两个值代表读到的值0，代表想要改变的新值1。两个线程去强资源，假设a先获取了时间片，将资源对象的状态值与自己旧的值0比较，如果相同修改则改为新值1。这时b线程也进行比较，不一致会进入竞争资源的状态并不马上挂起，等超时再放弃。由于cpu都支持了cas原子性操作。
CAS的3个操作数
内存值V
旧的预期值A
要修改的新值B

volatile

volatile变量是一个更轻量级的同步机制，因为在使用这些变量时不会发生上下文切换和线程调度等操作，但是volatile变量也存在一些局限，比如不能用于构建原子的复合操作，因此当一个变量依赖旧值时就不能使用volatile变量，volatile内部已经做了synchronized。

volatile只能保证变量对各个线程的可见性，但不能保证原子性

保证该变量对所有线程的可见性
在多线程的环境下：当这个变量修改时，所有的线程都会知道该变量被修改了，也就是所谓的“可见性”
不保证原子性
修改变量(赋值)实质上是在JVM中分了好几步，而在这几步内(从装载变量到修改)，它是不安全的。

哈希表

乐观锁：还是像它的名字一样，对于并发间操作产生的线程安全问题持乐观状态.

乐观锁认为竞争不总是会发生，因此它不需要持有锁，将”比较-替换”这两个动作作为一个原子操作尝试去修改内存中的变量，如果失败则表示发生冲突，那么就应该有相应的重试逻辑。

两种常见的锁

synchronized 互斥锁（悲观锁，有罪假设）

采用synchronized修饰符实现的同步机制叫做互斥锁机制，它所获得的锁叫做互斥锁。
每个对象都有一个monitor(锁标记)，当线程拥有这个锁标记时才能访问这个资源，没有锁标记便进入锁池。任何一个对象系统都会为其创建一个互斥锁，这个锁是为了分配给线程的，防止打断原子操作。每个对象的锁只能分配给一个线程，因此叫做互斥锁。

ReentrantLock 排他锁（悲观锁，有罪假设）

ReentrantLock是排他锁，排他锁在同一时刻仅有一个线程可以进行访问，实际上独占锁是一种相对比较保守的锁策略，在这种情况下任何“读/读”、“读/写”、“写/写”操作都不能同时发生，这在一定程度上降低了吞吐量。然而读操作之间不存在数据竞争问题，如果”读/读”操作能够以共享锁的方式进行，那会进一步提升性能。

ReentrantReadWriteLock 读写锁（乐观锁，无罪假设）

因此引入了ReentrantReadWriteLock，顾名思义，ReentrantReadWriteLock是Reentrant（可重入）Read（读）Write（写）Lock（锁），我们下面称它为读写锁。
读写锁内部又分为读锁和写锁，读锁可以在没有写锁的时候被多个线程同时持有，写锁是独占的。
读锁和写锁分离从而提升程序性能，读写锁主要应用于读多写少的场景。

线程池

ExecutorService:用来存储线程的池子,把新建线程/启动线程/关闭线程的任务都交给池来管理
Executors 辅助创建线程池的工具类来创建线程池。

package cn.tedu.tickets;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;/*本类用于测试线程池*/
public class TestThreadPool {public static void main(String[] args) {//5.创建接口实现类TicketR3类的对象作为目标业务对象TicketR3 target = new TicketR3();/*Executors是用来辅助创建线程池的工具类对象* 常用方法是newFixedThreadPool(int)这个方法可以创建指定数目的线程池对象* 创建出来的线程池对象是ExecutorService:用来存储线程的池子，负责：新建/启动/关闭线程*///6.使用Executors工具创建一个最多有5个线程的线程池对象ExecutorService池对象ExecutorService pool = Executors.newFixedThreadPool(5);for (int i = 0; i < 5; i++) {/*execute()让线程池中的线程来执行业务，每次调用都会将一个线程加入到就绪队列*/pool.execute(target);/*本方法的参数就是你要执行的业务，也就是目标业务类对象*/}}
}
//同步锁问题解决方案笔记：1.4.1从26行复制到58行，TicketR2改成TicketR3
//1.创建自定义多线程类
class TicketR3 implements Runnable {//3.定义成员变量，保存票数int tickets = 100;//创建锁对象Object o = new Object();//2.实现接口中未实现的方法，run()中放着的是我们的业务@Overridepublic void run() {//4.通过循环结构完成业务while (true) {/*3.同步代码块：synchronized(锁对象){会出现安全隐患的所有代码}* 同步代码块在同一时刻，同一资源只会被一个线程独享*//*这种写法不对，相当于每个线程进来的时候都会new一个锁对象，线程间使用的并不是同一把锁*///synchronized (new Object()){//修改同步代码块的锁对象为成员变量o,因为锁对象必须唯一synchronized (o) {//同步代码块解决的是重卖的问题//如果票数>0就卖票if (tickets > 0) {try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}//4.1打印当前正在售票的线程名以及票数-1System.out.println(Thread.currentThread().getName() + "=" + tickets--);}//4.2退出死循环--没票的时候就结束if (tickets <= 0) break;}}}
}

单例模式volatile

Hashmap为什么是2的n次幂？初始长度为啥是16？为什么不是17，15的呢？

为了提高hashmap的存储效率，减少hash碰撞，是数据均匀分布。因为存的时候先对象key计算hashcode嘛，然后在二次hash后的值与数组长度-1进行取模按位与运算。16-1=15,二进制1111，而扩容变32，32-1=31 而二进制为11111。63的二进制是111111，每次扩容两个两差多了1，这样就可以数据均匀分布，有效的减少hash碰撞概率。
为运算的时候是要数组长度-1。如果是17，或15，那么-1就变偶数了，转成二进制都是余数为0。照成数据分布不均，增加hash碰撞的概率吧。

链表

链表优化的思想方式？怎么优化？

采用跳表查询的方式优化，设置一个范围查，比如查一个值a，链表长度为10，分成三部分查，123，456，78910等范围来查。

多线程的实现方式？

Java多线程实现的方式有四种
1.继承Thread类，重写run方法
2.实现Runnable接口，重写run方法，实现Runnable接口的实现类的实例对象作为Thread构造函数的target
3.通过Callable和FutureTask创建线程
4.通过线程池创建线程
前面两种可以归结为一类：无返回值，原因很简单，通过重写run方法，run方式的返回值是void，所以没有办法返回结果。
后面两种可以归结成一类：有返回值，通过Callable接口，就要实现call方法，这个方法的返回值是Object，所以返回的结果可以放在Object对象中。

缓存穿透、缓存击穿、缓存雪崩区别和解决方案

缓存处理流程

前台请求，后台先从缓存中取数据，取到直接返回结果，取不到时从数据库中取，数据库取到更新缓存，并返回结果，数据库也没取到，那直接返回空结果。

缓存穿透

缓存穿透是指缓存和数据库中都没有的数据，而用户不断发起请求，如发起为id为“-1”的数据或id为特别大不存在的数据。这时的用户很可能是攻击者，攻击会导致数据库压力过大。
解决方案：
接口层增加校验，如用户鉴权校验，id做基础校验，id<=0的直接拦截；
从缓存取不到的数据，在数据库中也没有取到，这时也可以将key-value对写为key-null，缓存有效时间可以设置短点，如30秒（设置太长会导致正常情况也没法使用）。这样可以防止攻击用户反复用同一个id暴力攻击

缓存击穿

缓存击穿是指缓存中没有但数据库中有的数据（一般是缓存时间到期），这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压力
设置热点数据永远不过期。
加互斥锁，互斥锁参考代码如下：

说明：
1）缓存中有数据，直接走上述代码13行后就返回结果了
2）缓存中没有数据，第1个进入的线程，获取锁并从数据库去取数据，没释放锁之前，其他并行进入的线程会等待100ms，再重新去缓存取数据。这样就防止都去数据库重复取数据，重复往缓存中更新数据情况出现。
3）当然这是简化处理，理论上如果能根据key值加锁就更好了，就是线程A从数据库取key1的数据并不妨碍线程B取key2的数据，上面代码明显做不到这点。

缓存雪崩

缓存雪崩是指缓存中数据大批量到过期时间，而查询数据量巨大，引起数据库压力过大甚至down机。和缓存击穿不同的是， 缓存击穿指并发查同一条数据，缓存雪崩是不同数据都过期了，很多数据都查不到从而查数据库
解决方案：
缓存数据的过期时间设置随机，防止同一时间大量数据过期现象发生。
如果缓存数据库是分布式部署，将热点数据均匀分布在不同搞得缓存数据库中。
设置热点数据永远不过期。

ConcurrentHashMap的底层实现原理？

DK1.7 中的 ConcurrentHashMap 是由 Segment 数组结构和 HashEntry 数组结构组成，即 ConcurrentHashMap 把哈希桶数组切分成小数组（Segment ），每个小数组有 n 个 HashEntry 组成。
如下图所示，首先将数据分为一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一段数据时，其他段的数据也能被其他线程访问，实现了真正的并发访问。


Segment 继承了 ReentrantLock，所以 Segment 是一种可重入锁，扮演锁的角色。Segment 默认为 16，也就是并发度为 16。

存放元素的 HashEntry，也是一个静态内部类，主要的组成如下：

其中，用 volatile 修饰了 HashEntry 的数据 value 和 下一个节点 next，保证了多线程环境下数据获取时的可见性！

jdk

在数据结构上， JDK1.8 中的ConcurrentHashMap 选择了与 HashMap 相同的Node数组+链表+红黑树结构；在锁的实现上，抛弃了原有的 Segment 分段锁，采用CAS + synchronized实现更加细粒度的锁。

将锁的级别控制在了更细粒度的哈希桶数组元素级别，也就是说只需要锁住这个链表头节点（红黑树的根节点），就不会影响其他的哈希桶数组元素的读写，大大提高了并发度。

再来看JDK1.8

大致可以分为以下步骤：

根据 key 计算出 hash 值；

判断是否需要进行初始化；

定位到 Node，拿到首节点 f，判断首节点 f：

如果为 null ，则通过 CAS 的方式尝试添加；

如果为 f.hash = MOVED = -1 ，说明其他线程在扩容，参与一起扩容；

如果都不满足 ，synchronized 锁住 f 节点，判断是链表还是红黑树，遍历插入；

当在链表长度达到 8 的时候，数组扩容或者将链表转换为红黑树。

synchronized 和 Lock 有什么区别？你经常用的是哪种锁?

jvm类的加载机制？

JVM内存模型

spring的理解

我们一般说 Spring 框架指的都是 Spring Framework，它是很多模块的集合，这些模块是：核心容器、数据访问/集成,、Web、AOP（面向切面编程）、工具、消息和测试模块。主要是为了简化后台开发，降低耦合性。接触到最多的还是IOC和AOP两大特性。
IOC（Inverse of control）指的控制反转，指的就是控制反转，就是把创建对象的权利交给spring去管理，spring通过工厂模式、反射等相关技术为我们管理对象的作用域，生命周期等问题。以往我们都是都是通过new或者set注入，而使用spring以后，我们可以通过autowired或者resource注解即可注入对象，其实就是从spring中的map中去拿对象，体现了容器的特点。
AOP（Aspect-Oriented Programming）指的 面向切面编程，可以看成是面向对象的拓展或者补充。举一个简单的例子。
比如我们的增删改里面都需要事务，以往我们需要对可能报错的代码进行try 操作 ，设置事务手动提交，catch里面去回滚事务。这种操作是重复性的，如果每个方法去写就显得很冗余。因此是使用AOP思想，通过代理模式对这类业务方法进行拓展或加强即可完成操作，简化了代码。当然基于这种 思想还可以实现全局的异常捕捉，日志，权限等相关的操作。这就是我 理解的spri i ng。

再配置文件中配置数据库得最大连接数

在添加jdbc，mybaits依赖之后springboot会自动帮我们添加连接池对象

String为什么是被final修饰的？

被final修饰的类不能被继承，被final修饰的方法不能被重写， final修饰的String，代表了String的不可继承性，保证了String的不可变性。因为只有当字符串是不可变的，字符串池才有可能实现。字符串池的实现可以在运行时节约很多heap空间，因为不同的字符串变量都指向池中的同一个字符串。为了线程安全， 因为字符串是不可变的，所以是多线程安全的，同一个字符串实例可以被多个线程共享。这样便不用因为线程安全问题而使用同步。字符串自己便是线程安全的。为了实现String可以创建HashCode不可变性， 因为字符串是不可变的，所以在它创建的时候HashCode就被缓存了，不需要重新计算。这就使得字符串很适合作为Map中的键，字符串的处理速度要快过其它的键对象。这就是HashMap中的键往往都使用字符串。

什么是上下文切换?

CPU给每个线程分配CPU时间片的过程，当前任务在执行完 CPU 时间片切换到另一个任务之前会先保存自己的状态,以便下次再切换回这个任务时,可以再加载这个任务的状态。任务从保存到再加载的过程就是一次上下文切换。

1.线程创建方式？

LinkList和Arraylist新增数据使用有哪些区别呢？

Arraylist它底层是基于我们的数组实现的，数组当然容量满时时需要扩容的。LinkList它底层时基于我们的链表数据结果来实现的，而链表是不需要扩容的，他存放数据的只需要点next,点next。把我们的数据直接存放到尾节点就可以了，我们的链表数据结构它是没有容量限制的，只有你服务器内存足够它是可以无限的一直存放，它是不需要做控的。相对于Arraylist在做新增的时候效率是要高非常多的。

LinkList和Arraylist查询数据使用有哪些区别呢？

java面试之每天五题相关推荐

1. 如何短时间突击 Java面试？附刷题神器

   你是不是正在找工作,或正准备找工作?是不是没有太多时间准备面试?该如何做呢? 划重点:如果时间有限,能做的就是多加温习并巩固自己的理论知识,临时磨刀不快也会发光!!! 从今年大家找工作反馈的情况来看, ...

2. 2022最新大厂Java面试集合，五面拿下阿里飞猪offer

   开头 关于程序员,除了做项目.看视频来提高自身的技术之外,还有一种提升自己的专业技能就是:多!看!书!MySQL俨然已经成为了IT技术人员必须掌握的核心技能之一! <MySQL从入门到精通> ...

3. Java 面试知识点解析(五)——网络协议篇

   前言: 在遨游了一番 Java Web 的世界之后,发现了自己的一些缺失,所以就着一篇深度好文:知名互联网公司校招 Java 开发岗面试知识点解析 ,来好好的对 Java 知识点进行复习和学习一番,大 ...

4. 金三银四跳槽季，java面试突击（100题）进大厂就这么简单

   1.谈谈对面向对象思想的理解 首先,谈谈"面向过程"vs"面向对象" 我觉得这两者是思考角度的差异,面向过程更多是以"执行者"的角度来思考问 ...

5. Java面试手写编程题（面试官经常让人手写）

   代码与编程题 135.写一个Singleton出来 Singleton模式主要作用是保证在Java应用程序中,一个类Class只有一个实例存在. 一般Singleton模式通常有几种种形式: 第一种形 ...

6. Java面试遇到的智力题

   出处:https://blog.csdn.net/zhangerqing/article/details/8138296 文章很好,加以转载. ps:改动和修正了一些答案,因为部分答案有缺失或者个人认 ...

7. java面试突击（100题）进大厂就这么简单

   1.谈谈对面向对象思想的理解 首先,谈谈"面向过程"vs"面向对象" 我觉得这两者是思考角度的差异,面向过程更多是以"执行者"的角度来思考问 ...

8. java面试时候算法题多吗,Java面试必问算法题

   面试的时候,栈和队列经常会成对出现来考察.本文包含栈和队列的如下考试内容: (1)栈的创建 (2)队列的创建 (3)两个栈实现一个队列 (4)两个队列实现一个栈 (5)设计含最小函数min()的栈,要 ...

9. 面试准备每日五题：C++（二）——mallocnew、宏、volatile、constvolatile、(a)和(a)

   文章目录 1.C语言的 malloc 和 C++ 中的 new 有什么区别 2. 写一个 "标准"宏MIN 3. 介绍 volatile 及其作用 4. 一个参数可以既是const ...

最新文章

1. Swift3.0语言教程使用字符串创建和初始化字符串
2. 网络营销助力之下国内可穿戴设备市场进一步打开迎来发展机遇
3. Python基础教程：赋值语句和布尔值
4. Codeforces Round #529 (Div. 3) E. Almost Regular Bracket Sequence （括号配对，前缀和）
5. VC ADO连接ACCESS步骤及错误处理
6. SAP Leonardo 机器学习插件的安装
7. 经典实用SQL语句大全汇总
8. python3.5.2安装pygame_【闲来无事，py写game】Mac-Python3.5安装pygame 1.9.2 小计
9. 基于 CNN 和迁移学习的农作物病害识别方法研究
10. Linux命令行上传本地文件到服务器 、 下载服务器文件到本地
11. 如何注册CSDN博客
12. kindle刷机ttl_#原创新人#艰难的TTL刷机路--新固件斐讯 K1 无线路由刷机教程
13. 随机森林（Random Forest）算法原理总结
14. 入门GTD时间管理系统必读（链接必读--很完整的一个GTD系统）
15. mysql 中外码和主码_数据库原理与应用（6）——关系的候选码、主码和外码、关系完整性、关系代数、元组关系的演算、域关系演算...
16. textarea 相关设置
17. excel查找出不来了_Excel查找明明存在的数据却查不到，是什么原因？|excel表格数据为什么搜查不到...
18. K8S：Volume
19. python使用pyechart快速绘制各类可视化表格-包括带平均线的折线图、雷达图等等，超实用！（不断更新）
20. Java堆内存Heap与非堆内存Non-Heap

热门文章

1. python的imaplib实现搜索邮件
2. SpringBoot整合MongoDB 及 基本使用
3. [Spring] 注入Bean属性
4. 颜色错位HP CM1312nfi MFP打印机 CM1015 1017 CM1312 CP1518等彩色激光打印机颜色校准步骤方法
5. HP1020 硒鼓加粉完全拆解图解
6. SEC官员：ICO指南即将发布
7. jvm- STW的疑惑
8. 食堂老板给北大教授上的MBA课
9. 多线程卖票深刻分析：为什么会出现只有一个窗口卖票的现象
10. linux+pid的管理,Linux 进程管理