01面试题----英斯特

时间 2019-11-19

原文原文链接

英斯特笔试：html

1.进程和线程的区别vue

一个程序下至少有一个进程，一个进程下至少有一个线程，一个进程下也能够有多个线程来增长程序的执行速度。

2.线程的生命周期，多线程并发会有什么影响java

当线程被建立并启动之后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。 
在线程的生命周期中，它要通过新建(New)、就绪（Runnable）、运行（Running）、阻塞 (Blocked)和死亡(Dead)5种状态。

多线程并发的影响：
多线程并发时会不安全，多线程同时操做对象的属性或者状态时，会由于线程之间的信息不一样步，A线程读取到的状态已通过时，而A线程并不知道。

3.队列和栈的特性。在什么实际案例中见过？web

堆栈的特性：先进后出，后进先出
队列的特性：先进先出，后进后出

4.synchroized的做用，java中还有那些经常使用的锁？面试

synchronized 它能够把任意一个非 NULL 的对象看成锁。他属于独占式的悲观锁，同时属于可重入锁。
1. 做用于方法时，锁住的是对象的实例(this)；
2. 看成用于静态方法时，锁住的是Class实例， 会锁全部调用该方法的线程； 
3. synchronized 做用于一个对象实例时，锁住的是全部以该对象为锁的代码块。
Java中常见的锁还有乐观锁、悲观锁、自旋锁

5.synchronized 和 volatile 的区别是什么？redis

1.volatile本质是在告诉jvm当前变量在寄存器（工做内存）中的值是不肯定的，须要从主存中读取； synchronized则是锁定当前变量，只有当前线程能够访问该变量，其余线程被阻塞住。
2.volatile仅能使用在变量级别；synchronized则可使用在变量、方法、和类级别的
3.volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则能够保证变量的修改可见性和原子性
4.volatile不会形成线程的阻塞；synchronized可能会形成线程的阻塞。
5.volatile标记的变量不会被编译器优化；synchronized标记的变量能够被编译器优化

6.spring的Bean的做用域和生命周期算法

Bean的做用域:单例(singleton)、原型（prototype）、请求（request）、会话（session）、全局会话（global session）	
Bean的生命周期流程：
1.首先容器启动后，会对scope为singleton且非懒加载的bean进行实例化，
2.按照Bean定义信息配置信息，注入全部的属性，
3.若是Bean实现了BeanNameAware接口，会回调该接口的setBeanName()方法，传入该Bean的id，此时该Bean就得到了本身在配置文件中的id，
4.若是Bean实现了BeanFactoryAware接口,会回调该接口的setBeanFactory()方法，传入该Bean的BeanFactory，这样该Bean就得到了本身所在的BeanFactory，
5.若是Bean实现了ApplicationContextAware接口,会回调该接口的setApplicationContext()方法，传入该Bean的ApplicationContext，这样该Bean就得到了本身所在的ApplicationContext，
6.若是有Bean实现了BeanPostProcessor接口，则会回调该接口的postProcessBeforeInitialzation()方法，
7.若是Bean实现了InitializingBean接口，则会回调该接口的afterPropertiesSet()方法，
8.若是Bean配置了init-method方法，则会执行init-method配置的方法，
9.若是有Bean实现了BeanPostProcessor接口，则会回调该接口的postProcessAfterInitialization()方法，
10.通过流程9以后，就能够正式使用该Bean了,对于scope为singleton的Bean,Spring的ioc容器中会缓存一份该bean的实例，而对于scope为prototype的Bean,
   每次被调用都会new一个新的对象，期生命周期就交给调用方管理了，再也不是Spring容器进行管理了
11.容器关闭后，若是Bean实现了DisposableBean接口，则会回调该接口的destroy()方法，
12.若是Bean配置了destroy-method方法，则会执行destroy-method配置的方法，至此，整个Bean的生命周期结束。4

7.spring经常使用的六个注解以及做用spring

@Component(value)
配置类，当使用该注解时，SpringIOC会将这个类自动扫描成一个bean实例
不写的时候，默认是类名，且首字母小写
@Autowired
自动装配，会根据类型寻找指定的Bean，required:表示假如说在bean目录下找不到指定的注解还需不须要注入，默认是true 修改成false时，表示假如说没有找到能够容许不注入。
@ImportResource({"classpath:xxx.xml"})
可以读取多个xml文件，这样就能够引入多个xml定义的bean
@Service
标注于业务层组件上表示定义一个bean，自动根据所标注的组件名称实例化一个首字母为小写的bean。
@RequestBody
用来传对象参数
@Resource
用来自动装配Bean，激活一个命名资源的依赖注入。@Resource属性name能够定义被自动装配Bean的名称

8.解释什么是事务，多线程事务并发会产生哪些问题，简述事务的四种隔离性sql

事务是应用程序中一系列严密的操做，全部操做必须成功完成，不然在每一个操做中所做的全部更改都会被撤消。
也就是事务具备原子性，一个事务中的一系列的操做要么所有成功，要么一个都不作。 
事务的结束有两种，当事务中的因此步骤所有成功执行时，事务提交。若是其中一个步骤失败，将发生回滚操做，撤消撤消以前到事务开始时的因此操做。 

并发问题可概括为如下几类: 
A.丢失更新
B.脏读
C.不可重复读
D. 覆盖更新
E.虚读（幻读）

事务的四种隔离性：
A.Serializable（串行化）：一个事务在执行过程当中彻底看不到其余事务对数据库所作的更新
（事务执行的时候不容许别的事务并发执行。事务串行化执行，事务只能一个接着一个地执行，而不能并发执行。）。
B.Repeatable Read（可重复读）：一个事务在执行过程当中能够看到其余事务已经提交的新插入的记录，可是不能看到其余其余事务对已有记录的更新。
C.Read Commited（读已提交数据）：一个事务在执行过程当中能够看到其余事务已经提交的新插入的记录，并且能看到其余事务已经提交的对已有记录的更新。
D.Read Uncommitted（读未提交数据）：一个事务在执行过程当中能够看到其余事务没有提交的新插入的记录，并且能看到其余事务没有提交的对已有记录的更新。

9.什么是aop，spring的几种通知方式数据库

aop是面向切面编程，在整个系统中，动态横向添加新的功能还不改变原来的业务流程的编程

spring的几种通知方式：
1.前置通知（方法调用前通知）
2.后置通知（方法调用后正常返回的时候通知，能够获取返回值，发生异常的时候不会执行）
3.最终通知（不管程序是否发生异常都会执行的）
4.异常通知（发生异常的执行）
5.环绕通知（方法执行的时候执行）

10.画出jvm的内存运行图并解释其做用

首先Java源代码文件(.java后缀)会被Java编译器编译为字节码文件(.class后缀)，
而后由JVM中的类加载器加载各个类的字节码文件，加载完毕以后，交由JVM执行引擎执行。
在整个程序执行过程当中，JVM会用一段空间来存储程序执行期间须要用到的数据和相关信息，
这段空间通常被称做为Runtime Data Area（运行时数据区），也就是咱们常说的JVM内存。
所以，在Java中咱们经常说到的内存管理就是针对这段空间进行管理

11.手写快速排序算法

StreamApi
第一种排序:sorted()，天然排序
 @Test
    public void test8() {
        List<String> list = Arrays.asList("aaa","bbb","ccc","ddd");
        list.stream().sorted().forEach(System.out::println);
    }

第二种排序:sorted(Comparator com)-定制排序
public void test8() {
        List<String> list = Arrays.asList("qqq","aaa","bbb","ccc","ddd");
        list.stream().sorted().forEach(System.out::println);
       	deptList.stream().sorted((x,y) -> {
           if(x.getDeptno().equals(y.getDeptno())) {
               return x.getDname().compareTo(y.getDname());
           }else {
               return x.getLoc().compareTo(y.getLoc());
           }
        });
    }
// 第三种按Map排序

//建立一个Map，并填入数据

Map<String, Integer> codes = new HashMap<>();
codes.put("United States", 1);
codes.put("Germany", 49);
codes.put("France", 33);
codes.put("China", 86);
codes.put("Pakistan", 92);

// 按照Map的键进行排序
Map<String, Integer> sortedMap = codes.entrySet().stream() 
　　　　　　　　.sorted(Map.Entry.comparingByKey())
　　　　　　　　.collect(
　　　　　　　　Collectors.toMap(
　　　　　　　　Map.Entry::getKey, 
　　　　　　　　Map.Entry::getValue,
　　　　　　　　(oldVal, newVal) -> oldVal,
　　　　　　　　LinkedHashMap::new
　　　　　　　　)
　　　　　　　　);

// 将排序后的Map打印
sortedMap.entrySet().forEach(System.out::println);
//按照value排序
　　Map<String, Integer> sortedMap2 = codes.entrySet().stream()
　　　　　　　　　　　　.sorted(Map.Entry.comparingByValue())
　　　　　　　　　　　　.collect(Collectors.toMap(
　　　　　　　　　　　　Map.Entry::getKey,
　　　　　　　　　　　　Map.Entry::getValue,
　　　　　　　　　　　　(oldVal, newVal) -> oldVal,
　　　　　　　　　　　　LinkedHashMap::new));

//排序之后打印

sortedMap2.entrySet().forEach(System.out::println);

12.手写线程安全的单例模式

https://www.runoob.com/design-pattern/singleton-pattern.html

//懒汉式，线程安全
public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
    public static synchronized Singleton getInstance() {  
    　　if (instance == null) {  
       　　instance = new Singleton();  
    　　}  
    return instance;  
    }  
}

//饿汉式
public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    　　return instance;  
    }  
} 

//双检锁/双重校验锁（DCL，即double-checked locking），JDK1.5起
public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
        　　if (singleton == null) {  
           　　singleton = new Singleton();  
        　　}  
        }  
    }  
    return singleton;  
    }  
}

//登记式/静态内部类
public class Singleton {  
    private static class SingletonHolder {  
    private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    　　return SingletonHolder.INSTANCE;  
    }  
}

//枚举，JDK1.5起
public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
} 

经验之谈：通常状况下，不建议使用懒汉方式，建议使用饿汉方式。只有在要明确实现lazy loading 效果时，才会
使用登记方式。若是涉及到反序列化建立对象时，能够尝试使用枚举方式。若是有其余特殊的需求，能够考虑使用双检
锁方式。

13.设计一个秒杀的结构图

华为总部面试：
主要都是一些底层的东西，今天两个华为项目组，大概的题目是。
①基本数据类型和他们包装类之间（主要是有基本数据类型，为何还要有包装类，基本数据类型和包装类在做为形参的时候有什么区别）
②jvm的内存模型【线程私有的线程共有的分别有哪些，分别存放什么，java8方法区改为了什么（改为了元数据区，又问他们有什么区别），什么又叫Java内存泄漏（怎么避免内存泄漏--主要是对象的引用类型）】，垃圾回收机制（新生代老年代的划分，他们分别用什么回收算法，常见的垃圾回收器，他们有什么特色，client和server模式下运行时他们的垃圾回收器是否相同（扯出来什么叫client，server模式，什么叫jit））。第二条很重要，两个项目组都问了
③hashmap 在1.7和1.8的底层实现有什么区别，这些改进有什么优势（以及引伸出的桶排序（最快的排序，牺牲内存，保证性能），红黑树他的总体结构，四个规则）两个项目组都问了，第二个问的更深。
④spring经过bean建立对象时，怎么确保他的线程安全的
⑤因为我项目上写了websocket，http和https的区别（主要就是后者的加密，他的加密是基于什么的），当两我的之间通信时，如何确保信息不会被伪造，篡改，截获（主要可逆加密中的对称加密和非对称加密，以及他们之间的配合使用），还有就是信任链当中的证书问题。
⑥抽象类和接口的区别
⑦你使用过哪些线程安全的类，为何他们是线程安全的，若是给你一个线程不安全的类，你怎么将他改为线程安全的。
⑧构建一个大体的vue
⑨执行一个jar中的某个方法怎么执行。(主要是有一个MANIFEST.MF文件，在这里面配置main class.而后经过java -jar abc.jar)
⑩一台服务器近期cpu和内存忽然使用率变高，怎么排查。
①说一下单点登陆的具体实现
②我说我大学学过c和java，他问我java8有一个新特性叫lambda，他和c语言中的什么类似。

绿和：
1.几年工做经验？
2.用的什么框架？
3.是否是先后端分离
4.用不用vue？用的话经常使用的指令有哪些？
5.js和jq熟悉吗
6.springmvc工做流程
7.ArrayList和LinkedList的区别
8.redis支持的数据类型
9.线程问题
10.介绍一下项目
11.vue的路由
12.为何用elk+kafka
13.mycat分了哪些表
14.Rabbitmq怎么实现的

易九：
介绍项目
找一个模块的业务逻辑讲一下
介绍一下中台架构
Es是什么

拜客科技：
Final
1.接口和抽象
2.String能被继承吗，为何
3.流
4.异常和throw的区别
5.事务的实现
6.Mybatis延时原理
7.数据库优化，回答了以后，他会问他就要在where中对字段进行null判断怎么解决
8.Dubbo功能
9.Dubbo怎么部署，几种方式
10.Redis支持的数据类型，在什么状况下用
11.Reids的持久化，怎么实现
12.并行与并发的区别
13.什么是死锁
14.怎么防止死锁
15.同步关键字的实现原理
16.Springboot的注解，和里面包含的注解以及做用
17.Sleep和wait的区别
18.#{}和${}区别
19.Struts
20.本身设计一个shiro流程

一些笔试题：
1.有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数
2.给定一个整数N，按如下模式打印2*N行。若是N=4则
1
2*3
4*5*6
7*8*9*10
7*8*9*10
4*5*6
2*3
1
输入：n—>表示行数的整数
输出：按指定行数打印出该模式
3.谈谈你对webService的见解
4.谈谈你对存储过程的见解
5.已知表（Sales）

1>写出求每一个Company的Amout的合计在10000以上的数据的SQL语句。
2>过滤掉Company、Amout重复的数据。只保留一条。以上述数据为例。执行结果应该为：

6.以下代码有错么？错在哪里？请说明状况。
List list=null；
System.out.println(list.length);
7.谈谈你对java集合类的见解。List，Set，Map是否继承自Collection接口？
8.abstract class 和 interface有什么区别？
9.启动一个线程使用run()仍是start()？
10.应用服务器有哪些？
11.如何理解transaction事务的概念？
12.String时最基本的数据类型吗？String和StringBuffer的区别？
13.int 和 Integer有什么区别？
14.运行时异常与通常异常有何异同？
15.说出Servlet的生命周期，并说出Servlet和CGI的区别？
16.说出ArrayList，Vector，LinkedList的存储性能和特性
17.条件：
学生表student：学号sno，姓名name
课程成绩表student_score：学号sno，学科stype，分数score
(1)查询全部同窗的学生编号，学生姓名，选课总数，全部课程的总成绩
(2)检索“01”课程分数小于60，按分数降序排列的学生信息
(3)查询至少有一门课与学号为"01"的同窗所学相同的同窗的信息
编写新增学生信息的rest接口，包括用到的注解
(1).controller
(2).service
(3).dao
(4).xml,sql层

------------恢复内容结束------------

英斯特笔试：
1.进程和线程的区别

进程:是系统进行分配和管理资源的基本单位

线程:进程的一个执行单元, 是进程内调度的实体、是CPU调度和分派的基本单位, 是比进程更小的独立运行的基本单位。线程也被称为轻量级进程, 线程是程序执行的最小单位。

 一个程序至少一个进程, 一个进程至少一个线程。

 进程有本身的独立地址空间, 每启动一个进程, 系统就会为它分配地址空间, 创建数据表来维护代码段、堆栈段和数据段， 这种操做很是昂贵。

而线程是共享进程中的数据的, 使用相同的地址空间, 所以CPU切换一个线程的花费远比进程要小不少, 同时建立一个线程的开销啊也比进程要小不少。

 线程之间的通讯更方便, 同一进程下的线程共享全局变量、静态变量等数据, 而进程之间的通讯须要以通讯的方式进行。

 如何处理好同步与互斥是编写多线程程序的难点。

 多进程程序更健壮, 进程有独立的地址空间, 一个进程崩溃后, 在保护模式下不会对其它进程产生影响,

而线程只是一个进程中的不一样执行路径。线程有本身的堆栈和局部变量, 但线程之间没有独立的空间, 因此可能一个线程出现问题, 进而致使整个程序出现问题

2.线程的生命周期，多线程并发会有什么影响
3.队列和栈的特性。在什么实际案例中见过？
4.synchroized的做用，java中还有那些经常使用的锁？
5.synchronized 和 volatile 的区别是什么？
6.spring的Bean的做用域和生命周期
7.spring经常使用的六个注解以及做用
8.解释什么是事务，多线程事务并发会产生哪些问题，简述事务的四种隔离性
9.什么是aop，spring的几种通知方式
10.画出jvm的内存运行图并解释其做用
11.手写快速排序算法
12.手写线程安全的单例模式
13.设计一个秒杀的结构图

易九：
介绍项目
找一个模块的业务逻辑讲一下
介绍一下中台架构
Es是什么

1>写出求每一个Company的Amout的合计在10000以上的数据的SQL语句。
2>过滤掉Company、Amout重复的数据。只保留一条。以上述数据为例。执行结果应该为：