常見面試問題總結

【Java】

 1. 容器

   1）隊列(queue): 若Blocking:阻塞put/take  offer/peek poll 異常element/remove

    a. PriorityQueue:comparator  堆排序

                b. Deque：雙向隊列  linkedList  addFirst()

                c. DelayQueue：相似timeTask，延遲期滿才能提取元素

                d. ConcurrentLinkedQueue：線程安全

   2）數組(Array):注意左右邊界校驗，如arr!=null&&arr.length>1;

   3）List：有序可重複，可接受null，索引方便，.subList（）視圖。

     a. LinkedList,  ArrayList

                 b. CopyOnWriteArrayList:讀寫分離，寫時複製加鎖。開闢新空間，內存消耗多

   4）Set：去重，必須實現equals方法。

     a.hashSet，LinkedHashSet：快速查找，後者則是爲了保證次序

                 b.SortedSet：如treeSet，底層實現的紅黑樹，保證有序

                 c. Collections.newSetFromMap：實現線程安全

   5）Map：hashCode 數組 + equals linkedList put get

     a. HashMap,LinkedHashMap:後者是爲了保證次序

                 b.sortedMap:如treeMap，key保持排序狀態

                 c. ConcurrentHashMap：鎖分段技術，讀寫分析，寫的時候，Segment加鎖保護其名下的HashEntry，讀的時候不加鎖。

   6）遍歷：Iterator：指向第一個元素前一個，故要next。Foreach，實現Iterator便可用，單不可增刪，會引發modCount變化，拋異常。

      Comparablet內比較器  comparator 外比較器 策略模式

                 

 2. 併發

   1）線程實現方法：Thread  runnable接口  callable接口

   2）線程池：減小損耗（一開始就建立好），好管理

      類別：newSiggleThreadPool(),newFixedThreadPool(workQueue長度不可控),newCachedThreadPool(線程數不可控),newScheduledThreadPool()，

                  內部：ThreadPoolExecutor(corePoolSize,maximumPoolSize,keepAliveTime,unit,workQueue(直接/有界/無界),ThreadFactory(worker線程),handler(DiscardPolicy/CallerRunPolicy))

                  方法：execute/submit Future.get FutureTask   shutdown/shutdownNow

   3）常見類：ThreadLocal，內部ThradLocalMap，CountDownLatch, CyclicBarrier, Semaphore

   4）Synchronized和Lock的區別

      Lock：AQS AbstractQueuedSynchronized   jdk類，可衝入，不可中斷，非公平

                  Synchronized: object final 1. jvm關鍵字 可衝入，可判斷鎖狀態，可公平，大量同步，finally要釋放鎖。在不斷優化，鎖消除，鎖粗化，monitorenter,monitorexist映射在內核上，影響開銷

   5）性能調優：

     Atomic原子類，免鎖容器，ConcurrentHashMap在java8使用CAS無鎖算法，ReentrantReadWriteLock讀寫鎖，  CAS，衝突檢測，數據更新

                 

 3. IO

    1. 字節流：OutputStream/InputStream,直接IO， 字符流：Writer/Reader,間接IO，需flush  字符字節轉換，須要指定編碼格式

                2. 基本概念：while((read=inputStream.read(byteArr))>0) 硬盤-（阻塞）-> 內核  -（同步）-> 用戶

                3. FileLock Charset

                4. IO和NIO的區別：觀察者模式--> 事件機制 --> reactor設計模式 --> nio --> netty對nio進行了簡單封裝  jetty或tomcat

                   面向緩衝：ByteBuffer等，稍後處理，可移動，靈活  mark position limit capacity

                   非阻塞：FileChannel（阻塞）沒法和Selcetor使用；ServerSocketChannel中設置,可配合Selcetor。Reactor模式

                   選擇器 Selector selector = Selector.open()， register(selector, SelectionKey.OP_ACCPECT)

    5. 實現案例：Netty EventLoopGroup ServerBootstrap group channel childHandler

               

 4. 內存管理&JVM

    1）GC內存模型：堆(新生代/老年代) 調整-Xms  方法區：永久代 j8用元空間代替； 棧：JVM棧（引用類型） Native棧

                2）JVM內存模型：volatile 不能保證原子性，能夠保證可見性，有序性  主內存，工做內存

                3）清理：引用計數法，GCRoot：標記-清除  標記-複製  標記-整理 

                4）性能：JDK工具jconsole Jps Jstack Jmap;  內存泄露：jmeter+jps+MAT  CPU衝高：ps -ef | grep   jstack pid  top-Hp pid

               

 5. 反射

    1）反射：getClass .class Class.forName，getFields(); 提升性能，反射+緩存

                2）雙親委派模型：BootStrap lib Extension lib\ext Application \lib  自定義

    3）類加載器：classLoader  findClass  defineClass loadClass  代理加強

                   Apache tomcat  OSGI  javaAgent探針，main以前攔截  Java字節碼  熱部署等

               

 6. Java8

   1）lamada閉包：

       匿名函數捕獲一個外部變量（自由變量），那麼它就是一個closure。

                   閉包是自帶運行環境的函數final，當一個函數在定義它的做用域意外的地方被調用時，他訪問的依然是定義它時的做用域。這種現象稱之爲閉包

   2）Stream API:

      Java8中的Stream是對集合（Collection）對象功能的加強，它專一於對集合對象進行各類很是便利、高效的聚合操做（aggregate operation）,或者大批量數據操做（bulk data operation）

      藉助於lamada表達式 java.util.stream，函數式語言+多核時代

      .stream().parallelStream().map().readuce()，對stream的使用就是實現一個filter-map-reduce過程，產生一個最終結果

       Stream.of("one","two","three","for"),filter(e->e.length()>3).peek(e->System.out.println("Filtered value:"+e)).map(String::toUpperCase).peek(e->System.out.pringtln("Mapped value:"+e)).collect(Collectors.toList());

                  

 【設計模式】

 1. 代理模式

    真實類在代理類裏註冊，代理類根據註冊new一個真實類Object並運轉

 2. 觀察者模式

    當對象間存在一對多關係時，使用觀察者模式。好比，當一個對象唄修改，則會自動通知它的依賴對象。行爲型模式

                client->Subjec（被觀察者state容器註冊，notifyUpdate）->Observer abstract ->o1,o2,o3(update方法)

 3. 適配器模式

 4. 裝飾器模式

 

 【框架】

 1. Spring

    IOC：主業務，自動注入而非本身維護 DI和DL（JNDI）

                 動態工廠Bean/靜態工廠bean Bean的做用域 單例，原型 Bean後處理器（採用動態代理，對bean加強）。

                  2. Spring的IOC和DI

    1）bean的裝配：動態工廠：factory-bean="someFactory"   factory-method="getSomeService"     靜態工廠：class=""  factory-method="getSomeService"

    2）bean的做用域：singleton  prototype

    3）bean後處理器：對bean建立的先後對bean進行加強

    4）bean的生命週期  構造方法-> set值 -> BeanNameAware -> beanFactoryAware -> 執行後護理器前 -> InitializingBean-afterPropertiesSet -> initPost --> 執行後處理器後 -> 執行方法 --> DisposableBean-destroy -> destroy

    5）xml方式

       property/constructor-arg  name  value/ref

       array/list/set/map/props

       autowire

       parent

    6）註解方式

       <context:compont-sacn base-package="com.huawei.ztj.di01">

      @Compont

      @Scope

      @Value   @Resource

      MyJavaConfig   @Configuration   @Bean  構造器

                AOP：系統業務，織入而非混入

                 1. Proxy代理  java.lang.reflect.Proxy  使用：ISomeService target = new SomeServiceImpl(); ISomeService proxy = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHander(){

   @Override

   public Object invoke(Object proxy, Method method, Object[] args) throwable {

      ..;  Object result = method.invoke(target, args);  ..;

   }

});

                2. 代理設計模式 ： 代理類和目標類實現同一接口，代理類是對目標類的加強（仍包含目標類的邏輯）。好處：控制目標對象的訪問，加強目標對象的功能。區別於：適配器模式（改變），裝飾器模式（加強，方式不同）。

                3. AOP

                                1. 通知Advice 加強的系統功能  MethodBeforeAdvice AfterReturningAdvice  MethodInterceptor(aopalliance中的包)  ThrowsAdvice   CGLIB  無實現InvocationHandler

        2. 顧問Advisor  切入點

        <bean id="afterAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">  NameMatchMethodPointcutAdvisor

           <property name="advice" ref="beforeAdvice"/>

           <property name="patterns" value=".*Sec.*/.*T.*">  mappedName

        </bean>

 

       3.配置

    <bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">     <bean class="org.springframework.aop.framework.autoproxy.advisorAutoProxyCreator"/>

       <property name="target" ref="someService"/>

       <property name="interfaces" value="com.huawei.ztj.di01.ISomeService"/>

       <property name="interceptorNames" value="beforeAdvice"/>

    </bean>

 

    4. AspectJ

    註解："execution(" * *..ISomeService.doSome(..)")"   通知+顧問

    XML：<aop:config>

             <aop:pointcut expression="execution(* *..ISomeService.doSome(..))" id="doSomePointcut"/>

                 <aop:aspect ref="myAspect">

                       <aop:before method="myBefore" pointcut-ref="doSomePointcut"/>

                 </aop:aspect>

             </aop:aspect>

         </aop:config>

    1. spring-aop包源碼解讀

          外層：  Advice各個接口

     support包：  Advisor 切入點，如NameMatchMethodPointcutAdvisor、RegexpMethodPointcutAdvisor

   framework包：  攔截器

                1）autoproxy：DefaultAdvisorAutoProxyCreator、BeanNameAutoProxyCreator

                2）ProxyFactoryBean

                3）JdkDynamicAopProxy、CglibAopProxyFactory  重點

   下一步計劃：core beans context    aspectJ aop:config  aop:pointcut  aop:aspect  aop:before  pointcut-ref  <aop:pointcut expression="execution(* *..ISomeService.doSome(..))" id="doSomePointcut"/>

  

 2. SpringMVC

   DispatcherServlet--> 映射處理器  處理適配器ModelAndView  視圖解析（view）  視圖渲染（Model）

   一、DispatcherServlet前端控制器接收發過來的請求，交給HandlerMapping處理器映射器

   二、HandlerMapping處理器映射器，根據請求路徑找到相應的HandlerAdapter處理器適配器（處理器適配器就是那些攔截器或Controller）

   三、HandlerAdapter處理器適配器，處理一些功能請求，返回一個ModelAndView對象（包括模型數據、邏輯視圖名）

   四、ViewResolver視圖解析器，先根據ModelAndView中設置的View解析具體視圖

   五、而後再將Model模型中的數據渲染到View上

 3. MyBatis

  

 4. OSGI

 5. SOA架構

    1. RMI：https://www.cnblogs.com/ygj0930/p/6542811.html   學習參考：http://www.blogjava.net/zhenyu33154/articles/320245.html

   RMI:stub  skeleton  接口Remote  註冊：java.rmi.Naming.rebind("rmi://10.74.226.146:11099/demoService", demoService);  rmic生成樁和框架 JVM  rmiregistry註冊程序運行

                                                                       調用：IHello hello = (IHello) Naming.lookup("rmi://localhost:1099/hello");

   RPC:系統網絡服務，客戶端和服務端句柄。

   JNDI：Java Naming and Directory Interface 是一個應用程序設計的API 

   採用java的序列化   頭疼的防火牆滲透

                2. Spring HttpInvoker  它基於HTTP之上提供RPC,同時又使用了Java的對象序列化機制。

   學習參考：https://www.cnblogs.com/lpc-xx/p/8556827.html

                3. Hessian：Hessian是一個輕量級的remoting onhttp工具，使用簡單的方法提供了RMI的功能   二進制

   web.xml註冊   <servlet-class>com.caucho.hessian.server.HessianServlet</servlet-class>

   調用：HessianProxyFactory factory = new HessianProxyFactory();  HessianService hs = (HessianService)factory.create(HessianService.class, url);

   私有的序列化機制  解決防火牆問題

                4. Burlap：https://www.cnblogs.com/javalouvre/p/3730597.html  集中遠程服務的區別   https://www.cnblogs.com/maybo/p/5190012.html 

   私有的序列化機制  解決防火牆問題

                5. Http服務和RFC服務的區別：https://blog.csdn.net/wangyunpeng0319/article/details/78651998  看下客戶端請求是否有http打頭

                6. 使用和發佈web服務： https://blog.csdn.net/gray_li/article/details/78460213 

                7. 使用Spring MVC建立Rest API：

     1) 【Spring集成】-SpringMVC建立REST API https://blog.csdn.net/fxkcsdn/article/details/80932349  n

 

 【MySQL】

   1）參考：https://blog.csdn.net/zhugewendu/article/details/73550414

   2）

   SQL和索引優化

   優化數據庫對象

   優化InnoDB

   磁盤優化

 【TCP/IP】

 

 【消息通知】

      ActiveMQ:java， java系統配合默契  基於STOMP協議 Simple Text Orientated Message Protocol

                  RabbitMQ:Erlang  性能更強  基於AMQP(Advanced Message Queue Protocol)  而「語言中立」則意味着只要遵循 AMQP 的協議，任何一種語言均可以開發消息組件乃至中間件自己

                           基於Erlang,支持多種協議的消息Broker，經過插件支持STOMP協議   admin/Changeme_123   jms

      HornetQ:基於JBoss

               

  1. 總體架構

     private int getCalledTimes(long minTime) {

                                int i = 0;

                                List<Long> removeList = new ArrayList<Long>();

                                for (int k = callTimes.size() - 1; k > 0; k--)

                                {

                                    Long time = callTimes.get(k);

                                                if (time > minTime)

                                                {

                                                                i++;

                                                }

                                                else

                                                {

                                                    removeList.add(time);

                                                }

                                               

                                }

                                callTimes.removeAll(removeList);

                                return i;

                }

 

  【途徑】

  1. 書：Java編程思想，Java併發編程實戰，effective java, Spring實戰,

  2. 網絡： MOOC課程，Java技術棧， ImportNew