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.設計一個秒殺的結構圖