java后端开发面试

@TOC





 

ThreadLocal(线程变量副本) 
Synchronized实现内存共享,ThreadLocal为每个线程维护一个本地变量。
采用空间换时间,它用于线程间的数据隔离,为每一个使用该变量的线程提供一个副本,每个线程都可以独立地改变自己的副本,而不会和其他线程的副本冲突。
ThreadLocal类中维护一个Map,用于存储每一个线程的变量副本,Map中元素的键为线程对象,而值为对应线程的变量副本。
ThreadLocal在Spring中发挥着巨大的作用,在管理Request作用域中的Bean、事务管理、任务调度、AOP等模块都出现了它的身影。
Spring中绝大部分Bean都可以声明成Singleton作用域,采用ThreadLocal进行封装,因此有状态的Bean就能够以singleton的方式在多线程中正常工作了。
友情链接:深入研究java.lang.ThreadLocal类


Java内存模型:
Java虚拟机规范中将Java运行时数据分为六种。
1.程序计数器:是一个数据结构,用于保存当前正常执行的程序的内存地址。Java虚拟机的多线程就是通过线程轮流切换并分配处理器时间来实现的,为了线程切换后能恢复到正确的位置,每条线程都需要一个独立的程序计数器,互不影响,该区域为“线程私有”。
2.Java虚拟机栈:线程私有的,与线程生命周期相同,用于存储局部变量表,操作栈,方法返回值。局部变量表放着基本数据类型,还有对象的引用。
3.本地方法栈:跟虚拟机栈很像,不过它是为虚拟机使用到的Native方法服务。

注解:native关键字说明其修饰的方法是一个原生态方法,方法对应的实现不是在当前文件,而是在用其他语言(如C和C++)实现的文件中。Java语言本身不能对操作系统底层进行访问和操作,但是可以通过JNI接口调用其他语言来实现对底层的访问。

4.Java堆:所有线程共享的一块内存区域,对象实例几乎都在这分配内存。:线程共享
5.方法区:各个线程共享的区域,储存虚拟机加载的类信息,常量,静态变量,编译后的代码。:线程共享

6.运行时常量池:代表运行时每个class文件中的常量表。包括几种常量:编译时的数字常量、方法或者域的引用。在方法区中

Java中的常量池实际上分为两种形态:

final修饰的成员变量表示常量,值一旦给定就无法改变!

final修饰的变量有三种:静态变量、实例变量和局部变量,分别表示三种类型的常量。

Java中的常量池,实际上分为两种形态:静态常量池运行时常量池。

  静态常量池:即*.class文件中的常量池,class文件中的常量池不仅仅包含字符串(数字)字面量,还包含类、方法的信息,占用class文件绝大部分空间。

 运行时常量池:则是jvm虚拟机在完成类装载操作后,将class文件中的常量池载入到内存中,并保存在方法区中,我们常说的常量池,就是指方法区中的运行时常量池。(每个类都会有一个)

  运行时常量池相对于Class文件常量池

1 . 会把翻译出来的直接引用也存储在运行时常量池中。

2 . 一个重要特征是具备动态性,Java语言并不要求常量一定只有编译期才会产生,也就是并非预置入Class文件中常量池的内容才能进入方法区运行时常量池,运行期间也可能将新的常量放入池中,这种特性被开发人员利用的比较多的便是String类的

intern()方法

public String intern()

返回字符串对象的规范化表示形式。

一个初始时为空的字符串池,它由类 String 私有地维护。

当调用 intern 方法时,如果池已经包含一个等于此 String 对象的字符串(该对象由 equals(Object) 方法确定),则返回池中的字符串。否则,将此 String 对象添加到池中,并且返回此 String 对象的引用

 1、什么是常量

final修饰的成员变量表示常量,值一旦给定就无法改变!

final修饰的变量有三种:静态变量、实例变量和局部变量,分别表示三种类型的常量。

Java中的常量池,实际上分为两种形态:静态常量池运行时常量池。

     1)所谓静态常量池,即*.class文件中的常量池,class文件中的常量池不仅仅包含字符串(数字)字面量,还包含类、方法的信息,占用class文件绝大部分空间。

    2) 而运行时常量池,则是jvm虚拟机在完成类装载操作后,将class文件中的常量池载入到内存中,并保存在方法区中,我们常说的常量池,就是指方法区中的运行时常量池。


友情链接: Java中JVM虚拟机详解


“你能不能谈谈,java GC是在什么时候,对什么东西,做了什么事情?”
在什么时候:
1.新生代有一个Eden区和两个survivor区,首先将对象放入Eden区,如果空间不足就向其中的一个survivor区上放,如果仍然放不下就会引发一次发生在新生代的minor GC,将存活的对象放入另一个survivor区中,然后清空Eden和之前的那个survivor区的内存。在某次GC过程中,如果发现仍然又放不下的对象,就将这些对象放入老年代内存里去。
2.大对象以及长期存活的对象直接进入老年区。
3.当每次执行minor GC的时候应该对要晋升到老年代的对象进行分析,如果这些马上要到老年区的老年对象的大小超过了老年区的剩余大小,那么执行一次Full GC以尽可能地获得老年区的空间。
对什么东西:从GC Roots搜索不到,而且经过一次标记清理之后仍没有复活的对象。

如果一个对象不可达,那么就是可以回收的;如果一个对象可达,那么这个对象就不可以回收。对于可达性分析算法,它是通过一系列称为“GC Roots” 的对象作为起始点,当一个对象到 GC Roots 没有任何引用链相接的时候,那么这个对象就是不可达,就可以被回收。

这个GC Root 对象可以是一些静态的对象,Java方法的local变量或参数, native 方法引用的对象,活着的线程。

做什么: 新生代:复制清理; 老年代:标记-清除和标记-压缩算法; 永久代:存放Java中的类和加载类的类加载器本身。
GC Roots都有哪些: 1. 虚拟机栈中的引用的对象 2. 方法区中静态属性引用的对象,常量引用的对象 3. 本地方法栈中JNI(即一般说的Native方法)引用的对象。

gc,jvm参数设置

-Xms初始堆大小。如:-Xms256m
-Xmx最大堆大小。如:-Xmx512m
-Xmn新生代大小。通常为 Xmx 的 1/3 或 1/4。新生代 = Eden + 2 个 Survivor 空间。实际可用空间为 = Eden + 1 个 Survivor,即 90%
-XssJDK1.5+ 每个线程堆栈大小为 1M,一般来说如果栈不是很深的话, 1M 是绝对够用了的。
-XX:NewRatio新生代与老年代的比例,如 –XX:NewRatio=2,则新生代占整个堆空间的1/3,老年代占2/3
-XX:SurvivorRatio新生代中 Eden 与 Survivor 的比值。默认值为 8。即 Eden 占新生代空间的 8/10,另外两个 Survivor 各占 1/10
-XX:PermSize永久代(方法区)的初始大小
-XX:MaxPermSize永久代(方法区)的最大值
-XX:+PrintGCDetails打印 GC 信息
-XX:+HeapDumpOnOutOfMemoryError让虚拟机在发生内存溢出时 Dump 出当前的内存堆转储快照,以便分析用

 


友情链接:Java GC的那些事(上)
友情链接:Java GC的那些事(下)
友情链接:CMS垃圾收集器介绍


 

注:synchronized的用法

A. 无论synchronized关键字加在方法上还是对象上,如果它作用的对象是非静态的,则它取得的锁是对象;如果synchronized作用的对象是一个静态方法或一个类,则它取得的锁是对类,该类所有的对象同一把锁。 
B. 每个对象只有一个锁(lock)与之相关联,谁拿到这个锁谁就可以运行它所控制的那段代码。 
C. 实现同步是要很大的系统开销作为代价的,甚至可能造成死锁,所以尽量避免无谓的同步控制。

异常详解

  • stackoverflow和outofmemory区别

  • 1、stackoverflow:

    <p>每当java程序启动一个新的线程时,java虚拟机会为他分配一个栈,java栈以帧为单位保持线程运行状态;当线程调用一个方法是,jvm压入一个新的栈帧到这个线程的栈中,只要这个方法还没返回,这个栈帧就存在。&nbsp;<br>
    如果方法的嵌套调用层次太多(如递归调用),随着java栈中的帧的增多,最终导致这个线程的栈中的所有栈帧的大小的总和大于-Xss设置的值,而产生生StackOverflowError溢出异常。</p>
    </li>
    <li>
    <p><strong>2、outofmemory:</strong></p>
    </li>
    <li>
    <p>2.1、栈内存溢出</p>
    
    <p>java程序启动一个新线程时,没有足够的空间为改线程分配java栈,一个线程java栈的大小由-Xss设置决定;JVM则抛出OutOfMemoryError异常。</p>
    </li>
    <li>
    <p>2.2、堆内存溢出</p>
    
    <p>java堆用于存放对象的实例,当需要为对象的实例分配内存时,而堆的占用已经达到了设置的最大值(通过-Xmx)设置最大值,则抛出OutOfMemoryError异常。</p>
    </li>
    <li>
    <p>2.3、方法区内存溢出</p>
    
    <p>方法区用于存放java类的相关信息,如类名、访问修饰符、常量池、字段描述、方法描述等。在类加载器加载class文件到内存中的时候,JVM会提取其中的类信息,并将这些类信息放到方法区中。&nbsp;<br>
    当需要存储这些类信息,而方法区的内存占用又已经达到最大值(通过-XX:MaxPermSize);将会抛出OutOfMemoryError异常对于这种情况的测试,基本的思路是运行时产生大量的类去填满方法区,直到溢出。这里需要借助CGLib直接操作字节码运行时,生成了大量的动态类。</p>
    </li>
    

       Exception--指程序需要捕获,需要处理的异常,是一种设计或实现方面的问题。 
            Exception分为两类:RuntimeException和CheckedException 
                 RuntimeException--运行时异常,由程序员错误导致,不需要捕获处理,直接由 
                            虚拟机接管,层层上抛,记录日志,程序员应尽量避免此种异常。 
                CheckedException--一般异常,需要进行catch,如IO异常和SQL异常等。 

Java的异常通过两种机制来处理

捕获:try-catch-finally

抛出:throw,throws

抛出异常: throw new Exception(); 即发生了异常之后会把这个异常丢到,即不会在继续执行接下来的语句.

捕获异常:trt{}catch(Exception e){} :发生异常之后,catch会捕获到这个异常并存于e变量中,然后再在catch语句块中进行逻辑处理,会继续执行

抛出异常有三种形式,一是throw,一个throws,还有一种系统自动抛异常。下面它们之间的异同。

自动抛异常:  当程序语句出现一些逻辑错误、主义错误或类型转换错误时,系统会自动抛出异常

throw:  throw是语句抛出一个异常,一般是在代码块的内部,当程序出现某种逻辑错误时由程序员主动抛出某种特定类型的异常

throws:  throws是方法可能抛出异常的声明。(用在声明方法时,表示该方法可能要抛出异常)

public void function() throws Exception{......}

当某个方法可能会抛出某种异常时用于throws 声明可能抛出的异常,然后交给上层调用它的方法程序处理

throw和throws的区别: 

    1.前者在方法体中使用,是一个语句,用于抛出具体的异常;后者在声明方法时使用,是一个方法,用于声明可能抛出的异常。 
    2.前者不能单独使用,要么和try-catch-finally配套,要么和throws配套;后者可单独使用。 
    3.使用前者,则一定会抛出异常,使用后者则可能会抛出异常 
    4.程序会在throw语句后立即终止,它后面的语句执行不到,然后在包含它的所有try块中(可能在上层调用函数中)从里向外寻找含有与其匹配的catch子句的try块。    
      

 throws:用于声明异常,例如,如果一个方法里面不想有任何的异常处理,则在没有任何代码进行异常处理的时候,必须对这个方法进行声明有可能产生的所有异常(其实就是,不想自己处理,那就交给别人吧,告诉别人我会出现什么异常,报自己的错,让别人处理去吧)。

throw:就是自己进行异常处理,处理的时候有两种方式,要么自己捕获异常(也就是try catch进行捕捉),要么声明抛出一个异常(就是throws 异常~~)。

 


 
  1. package com.xinkaipu.Exception;
  2. public class TestThrow
  3. {
  4. public static void main(String[] args)
  5. {
  6. try
  7. {
  8. //调用带throws声明的方法,必须显式捕获该异常
  9. //否则,必须在main方法中再次声明抛出
  10. throwChecked(- 3);
  11. }
  12. catch (Exception e)
  13. {
  14. System.out.println(e.getMessage());
  15. }
  16. //调用抛出Runtime异常的方法既可以显式捕获该异常,
  17. //也可不理会该异常
  18. throwRuntime( 3);
  19. }
  20. public static void throwChecked(int a)throws Exception
  21. {
  22. if (a > 0)
  23. {
  24. //自行抛出Exception异常
  25. //该代码必须处于try块里,或处于带throws声明的方法中
  26. throw new Exception( "a的值大于0,不符合要求");
  27. }
  28. }
  29. public static void throwRuntime(int a)//如果在这里向上抛出异常,在main函数中异常也需要向上抛出
  30. {
  31. if (a > 0)
  32. {
  33. //自行抛出RuntimeException异常,既可以显式捕获该异常
  34. //也可完全不理会该异常,把该异常交给该方法调用者处理
  35. throw new RuntimeException( "a的值大于0,不符合要求");
  36. }
  37. }
  38. }

编程习惯:
1.在写程序时,对可能会出现异常的部分通常要用try{...}catch{...}去捕捉它并对它进行处理;
2.用try{...}catch{...}捕捉了异常之后一定要对在catch{...}中对其进行处理,那怕是最简单的一句输出语句,或栈输入e.printStackTrace();
3.如果是捕捉IO输入输出流中的异常,一定要在try{...}catch{...}后加finally{...}把输入输出流关闭;
4.如果在函数体内用throw抛出了某种异常,最好要在函数名中加throws抛异常声明,然后交给调用它的上层函数进行处理。

sychronized和lock的区别

Synchronized 与Lock都是可重入锁,同一个线程再次进入同步代码的时候.可以使用自己已经获取到的锁。
Synchronized是悲观锁机制,独占锁。而Locks.ReentrantLock是,每次不加锁而是假设没有冲突而去完成某项操作,如果因为冲突失败就重试,直到成功为止。 ReentrantLock适用场景

  1. 某个线程在等待一个锁的控制权的这段时间需要中断
  2. 需要分开处理一些wait-notify,ReentrantLock里面的Condition应用,能够控制notify哪个线程,锁可以绑定多个条件。
  3. 具有公平锁功能,每个到来的线程都将排队等候。

1. lock是一个接口,而synchronized是java的一个关键字,synchronized是内置的语言实现;(具体实现上的区别在《Java虚拟机》中有讲解底层的CAS不同,以前有读过现在又遗忘了。)

2. synchronized在发生异常时候会自动释放占有的锁,因此不会出现死锁;而lock发生异常时候,不会主动释放占有的锁,必须手动unlock来释放锁,可能引起死锁的发生。(所以最好将同步代码块用try catch包起来,finally中写入unlock,避免死锁的发生。)

3. lock等待锁过程中可以用interrupt来终端等待,而synchronized只能等待锁的释放,不能响应中断;

4. lock可以通过trylock来知道有没有获取锁,而synchronized不能;

5. Lock可以提高多个线程进行读操作的效率。(可以通过readwritelock实现读写分离)

2、Thread的几个重要方法:

我们先了解一下Thread的几个重要方法。a、start()方法,调用该方法开始执行该线程;b、stop()方法,调用该方法强制结束该线程执行;c、join方法,调用该方法等待该线程结束。d、sleep()方法,调用该方法该线程进入等待。e、run()方法,调用该方法直接执行线程的run()方法,但是线程调用start()方法时也会运行run()方法,区别就是一个是由线程调度运行run()方法,一个是直接调用了线程中的run()方法!!

两者区别:

1.首先synchronized是java内置关键字,在jvm层面,Lock是个java类;

2.synchronized无法判断是否获取锁的状态,Lock可以判断是否获取到锁;

3.synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ;b 线程执行过程中发生异常会释放锁),Lock需在finally中手工释放锁(unlock()方法释放锁),否则容易造成线程死锁;

4.用synchronized关键字的两个线程1和线程2,如果当前线程1获得锁,线程2线程等待。如果线程1阻塞,线程2则会一直等待下去,而Lock锁就不一定会等待下去,如果尝试获取不到锁,线程可以不用一直等待就结束了;

5.synchronized的锁可重入、不可中断、非公平,而Lock锁可重入、可判断、可公平(两者皆可)

6.Lock锁适合大量同步的代码的同步问题,synchronized锁适合代码少量的同步问题。

友情链接: Synchronized关键字、Lock,并解释它们之间的区别

 

自动拆装箱

1.Java中Int与Integer的区别?

一、int 是基本类型,直接存数值;而integer引用数据类型。

二、Int的声明不需要实例化,且变量声明后的初始值为0;Integer的是一个类,初始值为null,需要进行实例化,才能对变量数据进行处理。

三、Integer类是int的包装类,实际开发中Integer被看成一个对象,可以进行数据转换等操作

Integer iii=5;相当于编译器执行了Integer iii = Integer.valueOf(5)

  1. Interge iii = new Interge(5)

  2. int iii2=iii;  /自动拆箱,实际上执行了 int iii2 = iii.intValue()

两个函数: 一个valueof ()(int到interge)    返回对象的原始值而非字符串的时候才调用它,尤其是转换为数字的时候

                     intvalue()   (interge到int)   输出int数据


 
  1. booleantruefalse
  2. byte:- 128127
  3. char0127
  4. short:- 128127
  5. int:- 128127
  6. long:- 128127
  • 并不是创建一个新对象而是使用缓存中的对象
  • java定义:在自动装箱时对于值从–128到127之间的值,它们被装箱为Integer对象后,会存在内存中被重用,始终只存在一个对象而如果超过了从–128到127之间的值,被装箱后的Integer对象并不会被重用,即相当于每次装箱时都新建一个 Integer对象;

 
  1. Integer num1 = 200;
  2. Integer num2 = 200;
  3. System.out.println( "num1==num2: "+(num1==num2));
  4. Integer num3 = 100;
  5. Integer num4 = 100;
  6. System.out.println( "num3==num4: "+(num3==num4));
  7. //输出结果:num1==num2:false 和num3==num4:true

StringBuffer是线程安全的,每次操作字符串,String会生成一个新的对象,而StringBuffer不会;StringBuilder是非线程安全的
友情链接:String、StringBuffer与StringBuilder之间区别

三者在执行速度方面的比较:StringBuilder >  StringBuffer  >  String

    对于三者使用的总结: 1.如果要操作少量的数据用 = String

                        2.单线程操作字符串缓冲区 下操作大量数据 = StringBuilder

                        3.多线程操作字符串缓冲区 下操作大量数据 = StringBuffer


fail-fast:机制是java集合(Collection)中的一种错误机制。当多个线程对同一个集合的内容进行操作时,就可能会产生fail-fast事件。
例如:当某一个线程A通过iterator去遍历某集合的过程中,若该集合的内容被其他线程所改变了;那么线程A访问集合时,就会抛出ConcurrentModificationException异常,产生fail-fast事件


happens-before:如果两个操作之间具有happens-before 关系,那么前一个操作的结果就会对后面一个操作可见。
1.程序顺序规则:一个线程中的每个操作,happens- before 于该线程中的任意后续操作。
2.监视器锁规则:对一个监视器锁的解锁,happens- before 于随后对这个监视器锁的加锁。
3.volatile变量规则:对一个volatile域的写,happens- before于任意后续对这个volatile域的读。
4.传递性:如果A happens- before B,且B happens- before C,那么A happens- before C。
5.线程启动规则:Thread对象的start()方法happens- before于此线程的每一个动作。


 

Volatile关键字:

JMM中的内存分为主内存和工作内存,其中主内存是所有线程共享的,而工作内存是每个线程独立分配的,各个线程的工作内存之间相互独立、互不可见。在线程启动的时候,虚拟机为每个内存分配了一块工作内存,不仅包含了线程内部定义的局部变量,也包含了线程所需要的共享变量的副本,当然这是为了提高执行效率,读副本的比直接读主内存更快。

那么对于volatile修饰的变量(共享变量)来说,在工作内存发生了变化后,必须要马上写到主内存中,而线程读取到是volatile修饰的变量时,必须去主内存中去获取最新的值,而不是读工作内存中主内存的副本,这就有效的保证了线程之间变量的可见性。

volatile特性一:内存可见性

volatile特性二:可以禁止指令重排序

 

Volatile和Synchronized四个不同点:
1 粒度不同,前者针对变量 ,后者锁对象和类
2 syn阻塞,volatile线程不阻塞
3 syn保证三大特性(可见性,原子性,有序性),volatile不保证原子性
4 syn编译器优化,volatile不优化 volatile具备两种特性:

1.保证此变量对所有线程的可见性,指一条线程修改了这个变量的值,新值对于其他线程来说是可见的,但并不是多线程安全的。
2.禁止指令重排序优化。

Volatile如何保证内存可见性:

1.当写一个volatile变量时,JMM会把该线程对应的本地内存中的共享变量刷新到主内存。
2.当读一个volatile变量时,JMM会把该线程对应的本地内存置为无效。线程接下来将从主内存中读取共享变量。

同步:就是一个任务的完成需要依赖另外一个任务,只有等待被依赖的任务完成后,依赖任务才能完成。
异步:不需要等待被依赖的任务完成,只是通知被依赖的任务要完成什么工作,只要自己任务完成了就算完成了,被依赖的任务是否完成会通知回来。(异步的特点就是通知)。 打电话和发短信来比喻同步和异步操作。
阻塞:CPU停下来等一个慢的操作完成以后,才会接着完成其他的工作。
非阻塞:非阻塞就是在这个慢的执行时,CPU去做其他工作,等这个慢的完成后,CPU才会接着完成后续的操作。
非阻塞会造成线程切换增加,增加CPU的使用时间能不能补偿系统的切换成本需要考虑。
友情链接:Java并发编程之volatile关键字解析


CAS(Compare And Swap) 无锁算法: CAS是乐观锁技术,当多个线程尝试使用CAS同时更新同一个变量时,只有其中一个线程能更新变量的值,而其它线程都失败,失败的线程并不会被挂起,而是被告知这次竞争中失败,并可以再次尝试。CAS有3个操作数,内存值V,旧的预期值A,要修改的新值B。当且仅当预期值A和内存值V相同时,将内存值V修改为B,否则什么都不做。

一、乐观锁

 总是认为不会产生并发问题,每次去取数据的时候总认为不会有其他线程对数据进行修改,因此不会上锁,但是在更新时会判断其他线程在这之前有没有对数据进行修改,一般会使用版本号机制或CAS操作实现。

一、悲观锁

 总是假设最坏的情况,每次取数据时都认为其他线程会修改,所以都会加锁(读锁、写锁、行锁等),当其他线程想要访问数据时,都需要阻塞挂起。可以依靠数据库实现,如行锁、读锁和写锁等,都是在操作之前加锁,在Java中,synchronized的思想也是悲观锁。

友情链接:非阻塞同步算法与CAS(Compare and Swap)无锁算法


线程池的作用: 在程序启动的时候就创建若干线程来响应处理,它们被称为线程池,里面的线程叫工作线程
第一:降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
第二:提高响应速度。当任务到达时,任务可以不需要等到线程创建就能立即执行。
第三:提高线程的可管理性。
常用线程池:ExecutorService 是主要的实现类,其中常用的有 Executors.newSingleThreadPool(),newFixedThreadPool(),newcachedTheadPool(),newScheduledThreadPool()。
友情链接:线程池原理
友情链接:线程池原理解析


类加载器工作机制:,它的整个生命周期包括:加载、验证、准备、解析、初始化、使用和卸载7个阶段
1.装载:将Java二进制代码导入jvm中,生成Class文件。
2.连接:a)校验:检查载入Class文件数据的正确性 b)准备:给类的静态变量分配存储空间 c)解析:将符号引用转成直接引用
3:初始化:对类的静态变量,静态方法和静态代码块执行初始化工作。
双亲委派模型:类加载器收到类加载请求,首先将请求委派给父类加载器完成 用户自定义加载器->应用程序加载器->扩展类加载器->启动类加载器。

   双亲委派模型的式作过程是:如果一个类加载器收到了类加载的请求,它首先不会自己去尝试加载这个类,而是把这个请求委派给父类加载器去完成,每一个层次的类加载器都是如此,因此所有的加载请求最终都应该传送到顶层的启动类加载器中,只有当父加载器反馈自己无法完全这个加载请求时,子加载器才会尝试自己去加载。
友情链接:深入理解Java虚拟机笔记—双亲委派模型 
友情链接:JVM类加载的那些事
友情链接:JVM(1):Java 类的加载机制


一致性哈希:
Memcahed缓存:
数据结构:key,value对
使用方法:get,put等方法
友情链接:hashcode(),equal()方法深入解析

https://www.sohu.com/a/158141377_479559


Redis数据结构: String—字符串(key-value 类型)
Hash—字典(hashmap) Redis的哈希结构可以使你像在数据库中更新一个属性一样只修改某一项属性值
List—列表 实现消息队列
Set—集合 利用唯一性
Sorted Set—有序集合 可以进行排序 可以实现数据持久化
友情链接: Spring + Redis 实现数据的缓存


java自动装箱拆箱深入剖析
谈谈Java反射机制
如何写一个不可变类?


注:小结

       B树:二叉树,每个结点只存储一个关键字,等于则命中,小于走左结点,大于走右结点;

       B-树:多路搜索树,每个结点存储M/2到M个关键字,非叶子结点存储指向关键字范围的子结点;

       所有关键字在整颗树中出现,且只出现一次,非叶子结点可以命中;

       B+树:在B-树基础上,为叶子结点增加链表指针,所有关键字都在叶子结点中出现,非叶子结点作为叶子结点的索引;B+树总是到叶子结点才命中;

       B*树:在B+树基础上,为非叶子结点也增加链表指针,将结点的最低利用率从1/2提高到2/3;

B树和B+树的区别

这都是由于B+树和B具有这不同的存储结构所造成的区别,以一个m阶树为例。

  1. 关键字的数量不同;B+树中分支结点有m个关键字,其叶子结点也有m个,其关键字只是起到了一个索引的作用,但是B树虽然也有m个子结点,但是其只拥有m-1个关键字。
  2. 存储的位置不同;B+树中的数据都存储在叶子结点上,也就是其所有叶子结点的数据组合起来就是完整的数据,但是B树的数据存储在每一个结点中,并不仅仅存储在叶子结点上。
  3. 分支结点的构造不同;B+树的分支结点仅仅存储着关键字信息和儿子的指针(这里的指针指的是磁盘块的偏移量),也就是说内部结点仅仅包含着索引信息。
  4. 查询不同;B树在找到具体的数值以后,则结束,而B+树则需要通过索引找到叶子结点中的数据才结束,也就是说B+树的搜索过程中走了一条从根结点到叶子结点的路径。

 

索引:B+,B-,全文索引
Mysql的索引是一个数据结构,旨在使数据库高效的查找数据。
常用的数据结构是B+Tree,每个叶子节点不但存放了索引键的相关信息还增加了指向相邻叶子节点的指针,这样就形成了带有顺序访问指针的B+Tree,做这个优化的目的是提高不同区间访问的性能。
什么时候使用索引:

  1. 经常出现在group by,order by和distinc关键字后面的字段
  2. 经常与其他表进行连接的表,在连接字段上应该建立索引
  3. 经常出现在Where子句中的字段
  4. 经常出现用作查询选择的字段

友情链接:MySQL:InnoDB存储引擎的B+树索引算法
友情链接:MySQL索引背后的数据结构及算法原理


Spring IOC (控制反转,依赖注入)
Spring支持三种依赖注入方式,分别是属性(Setter方法)注入,构造注入和接口注入。

主要有四种注解可以注册bean,每种注解可以任意使用,只是语义上有所差异:

  1. @Component:可以用于注册所有bean
  2. @Repository:主要用于注册dao层的bean
  3. @Controller:主要用于注册控制层的bean
  4. @Service:主要用于注册服务层的bean

@Autowired 和 @Resourceq区别

 

不同点:

  @Autowired  默认按类型装配   

        依赖对象必须存在,如果要允许null值,可以设置它的required属性为false  

                             @Autowired(required=false)也可以使用名称装配,配合@Qualifier注解

      @Resource  默认按名称进行装配,通过name属性进行指定

大白话解释,@Autowired自动注解,举个例子吧,一个类,俩个实现类,Autowired就不知道注入哪一个实现类,而Resource有name属性,可以区分。

  1. 描述依赖关系主要有两种:
  2. @Resource:java的注解,默认以byName的方式去匹配与属性名相同的bean的id,如果没有找到就会以byType的方式查找,如果byType查找到多个的话,使用@Qualifier注解(spring注解)指定某个具体名称的bean。

 
  1. @Resource
  2. @Qualifier( "userDaoMyBatis")
  3. private IUserDao userDao;
  4. public UserService(){
  5. }
  1. @Autowired:spring注解,默认也是以byName的方式去匹配与属性名相同的bean的id,如果没有找到,就通过byType的方式去查找,如果查找到多个,用@Qualifier注解限定具体使用哪个。
  2. 
       
    1. @Autowired
    2. @Qualifier( "userDaoJdbc")
    3. private IUserDao userDao;
    <p>&nbsp;</p>
    </li>
    

在Spring中,那些组成应用的主体及由Spring IOC容器所管理的对象被称之为Bean。
Spring的IOC容器通过反射的机制实例化Bean并建立Bean之间的依赖关系。
简单地讲,Bean就是由Spring IOC容器初始化、装配及被管理的对象。
获取Bean对象的过程,首先通过Resource加载配置文件并启动IOC容器,然后通过getBean方法获取bean对象,就可以调用他的方法。
Spring Bean的作用域:
Singleton:Spring IOC容器中只有一个共享的Bean实例,一般都是Singleton作用域。
Prototype:每一个请求,会产生一个新的Bean实例。
Request:每一次http请求会产生一个新的Bean实例。

一、用@Configuration加载spring
1.1、@Configuration配置spring并启动spring容器
1.2、@Configuration启动容器+@Bean注册Bean
1.3、@Configuration启动容器+@Component注册Bean

@Bean

1、凡是子类及带属性、方法的类都注册Bean到Spring中,交给它管理;

2、@Bean 用在方法上,告诉Spring容器,你可以从下面这个方法中拿到一个Bean

友情链接: Spring框架IOC容器和AOP解析
友情链接:浅谈Spring框架注解的用法分析
友情链接:关于Spring的69个面试问答——终极列表

注解集合:

使用注解前需要开启自动扫描功能,其中base-package为需要扫描的包(含子包)。

<context:component-scan base-package="cn.test"/>
 


 

1声明Bean注解

1

@Component

 注解在类上,可以作用在任何层次。

泛指组件,当组件不好归类的时候,我们可以使用这个注解进行标注。

		<p>是一个泛化的概念,仅仅表示一个组件 (Bean) ,将一个实体类,放入bean中。</p>
		</td>
	</tr><tr><td>2</td>
		<td>
		<p><a href="https://my.oschina.net/service" rel="nofollow" target="_blank">@Service</a></p>
		</td>
		<td>注解在类上</td>
		<td>用于标注业务层组件</td>
	</tr><tr><td>3</td>
		<td>
		<p><a href="https://my.oschina.net/u/1774615" rel="nofollow" target="_blank">@Controller</a></p>
		</td>
		<td>注解在类上</td>
		<td>用于标注控制层组件(如struts中的action)</td>
	</tr><tr><td>4</td>
		<td>
		<p><a href="https://my.oschina.net/u/3055569" rel="nofollow" target="_blank">@Repository</a></p>
		</td>
		<td>注解在类上</td>
		<td>用于标注数据访问组件,即DAO组件。</td>
	</tr></tbody></table></div><h2 id="h2_5"><a name="t11"></a><a name="t1" target="_blank"></a>2注入Bean注解&nbsp;</h2>
1

@Autowired

可以对成员变量、方法、构造函数、类,进行注释。默认按类型装配

		<p>&nbsp;</p>
		</td>
		<td>注解在set方法上或属性上
		<p>如果我们想使用按名称装配,可以结合@Qualifier注解一起使用。</p>

		<p>如:@Autowired @Qualifier("personDaoBean") 存在多个实例配合使用</p>
		</td>
	</tr><tr><td>2</td>
		<td>
		<p>@Resource&nbsp;</p>
		</td>
		<td>&nbsp;</td>
		<td>默认按名称装配,当找不到与名称匹配的bean才会按类型装配。</td>
	</tr><tr><td>3</td>
		<td>
		<p>@Inject</p>
		</td>
		<td>JSR-330提供的注解</td>
		<td>&nbsp;</td>
	</tr></tbody></table></div><h2 id="h2_9"><a name="t12"></a><a name="t2" target="_blank"></a>3Java配置</h2>
1

@Configuration

注解在类上

声明当前类是一个配置类,相当于一个Spring配置的xml文件。把一个类作为一个IoC容器

		<p>和@Bean搭配使用,某个方法头上如果注册了@Bean,就会作为这个Spring容器中的Bean。</p>
		</td>
	</tr><tr><td>2</td>
		<td>
		<p>@Bean</p>
		</td>
		<td>
		<p>注解在方法上</p>
		</td>
		<td>
		<p>声明当前方法的返回值为一个Bean。</p>
		</td>
	</tr><tr><td>3</td>
		<td>
		<p>@ComponentScan</p>
		</td>
		<td>
		<p>注解在类上</p>
		</td>
		<td>
		<p>自动什么包名下所有使用@Service、@Compent、@Repository、@Controller的类,并注册为Bean。</p>
		</td>
	</tr><tr><td>&nbsp;</td>
		<td>&nbsp;</td>
		<td>&nbsp;</td>
		<td>&nbsp;</td>
	</tr><tr><td>4</td>
		<td>
		<p>@Lazy(true)</p>
		</td>
		<td>&nbsp;</td>
		<td>表示延迟初始化</td>
	</tr><tr><td>5</td>
		<td>
		<p>@Primary</p>
		</td>
		<td>&nbsp;</td>
		<td>自动装配时当出现多个Bean候选者时,被注解为@Primary的Bean将作为首选者,否则将抛出异常</td>
	</tr></tbody></table></div><h2 id="h2_15"><a name="t13"></a><a name="t3" target="_blank"></a>3AOP</h2>
1

@Aspect

注解在类上声明是一个切面。
2

@After

注解在方法上声明建言
3

@Before

注解在方法上声明建言
4

@Around

注解在方法上声明建言
5

@PointCut

注解在方法上定义拦截规则,声明切点。

4常用配置

4.1Bean的Scope

1

@Scope

注解在类上

用于指定scope作用域的

		<p>描述的是Spring容器如何新建Bean的实例的。实例:Scope("Prototype")</p>

		<div class="table-box"><table><tbody><tr><td>1</td>
					<td>Singleton</td>
					<td>一个spring容器中只要一个Bean的实例,此为Spring的默认配置,全容器共享一个实例。</td>
				</tr><tr><td>2</td>
					<td>Prototype</td>
					<td>每次调用新建一个Bean实例</td>
				</tr><tr><td>3</td>
					<td>Request</td>
					<td>Web项目中,给每一个http request新建一个Bean实例。</td>
				</tr><tr><td>4</td>
					<td>Session</td>
					<td>Web项目中,给每一个http session新建一个Bean实例。</td>
				</tr><tr><td>5</td>
					<td>GlobalSession</td>
					<td>这个只在portal应用中有用,给每一个global http session 新建一个Bean实例。</td>
				</tr></tbody></table></div></td>
	</tr></tbody></table></div><h3 id="h3_24"><a name="t16"></a><a name="t6" target="_blank"></a>4.2Spring EL 和 资源调用</h3>
1

@Value

注解在变量上调用资源(普通文件,网址,配置文件,系统环境变量等)
2

@PropertySource

注解在类上注入配置文件是来指定文件地址。

4.3Bean的初始化和销毁

1

@Bean

注解在方法上

@Bean(initMethod="init",destroyMethod="destory")

		<p>在构造函数执行后执行,在Bean销毁之前执行。</p>
		</td>
	</tr><tr><td>2</td>
		<td>
		<p>@PostConstruct</p>
		</td>
		<td>注解在方法上</td>
		<td>在构造函数执行后执行</td>
	</tr><tr><td>3</td>
		<td>
		<p>@PreDestroy</p>
		</td>
		<td>注解在方法上</td>
		<td>在Bean销毁之前执行</td>
	</tr><tr><td>4</td>
		<td>
		<p>@DependsOn</p>
		</td>
		<td>注解在方法上</td>
		<td>定义Bean初始化及销毁时的顺序</td>
	</tr></tbody></table></div><h3 id="h3_32"><a name="t18"></a><a name="t8" target="_blank"></a>4.4Profile</h3>
1

@Profile

注解在类、方法上在不同情况下选择实例化不同的Bean。

4.5事件

4.6多线程

1

@EnableAsync

注解在配置类上开启对异步任务的支持
2

@Async

在实际执行的Bean的方法中声明这是一个异步任务

4.7计划任务(定时任务)

1

@EnableScheduling 

注解在配置类上开启对j计划任务(定时任务)的支持
2

@Scheduled 

在实际执行的方法上

在要执行计划任务的方法上通过@Scheduled 声明这是一个计划任务。

		<p>包含:cron 、fixDelay、fixRate等类型</p>

		<div class="table-box"><table><tbody><tr><td>cron</td>
					<td>@Scheduled (cron="0 25 11 ? * *")</td>
					<td>cron是linux和unix系统下的定时任务</td>
				</tr><tr><td>fixDelay</td>
					<td>@Scheduled (fixedDelay=5000)</td>
					<td>延迟5秒执行</td>
				</tr><tr><td>fixRate</td>
					<td>@Scheduled (fixedRate=5000)</td>
					<td>每隔5秒执行一次</td>
				</tr></tbody></table></div></td>
	</tr></tbody></table></div><h3 id="h3_41"><a name="t22"></a><a name="t12" target="_blank"></a>4.8条件注解</h3>
1

@Conditional

用在配置类中根据满足某一个特定条件创建一个特定的Bean。(Spring4提供)

 4.9元注解

元注解:用来注解别的注解的注解。

组合注解:被注解的注解。

组合注解具备注解其上的元注解的功能。

@WiselyConfiguration=@Configuration+@CompontScan

5.0 @Enable*注解

1

@EnableAspectJAutoProxy

作用在配置类上开启对AspectJ自动代理的支持。
2

@EnableAsync

注解在配置类上开启对异步任务的支持
3

@EnableScheduling

注解在配置类上开启对j计划任务(定时任务)的支持
4

@EnableWebMvc

 开启web mvc的配置支持
5

@EnbaleConfigurationProperties

 开启对@ConfigurationProperties注解配置Bean的支持。
6

@EnableJpaRepositories

 开启对Spring Data JPA Repository的支持
7

@EnableTransactionManagement

 开启注解式事务的支持
8

@EnableCaching

 开启注解式的缓存支持

Spring4.2新特性:

@Order:调整配置类加载顺序。

SpringMVC注解:

1

@Controller

作用在类上

表面这个类是SpringMVC里面的Controller,将其声明为Spring的一个Bean,Dispatcher Servlet会自动扫描注解了此注解的类,并将Web请求映射到@RequestMappin的方法上。

		<p>注意:</p>

		<p>在声明普通Bean的时候,使用@Service,@Component,@Repository,@Controller是等同的,因为@Service,@Repository,@Controller都组合了@Component。</p>

		<p>但是在SpringMVC声明控制器Bean的时候,只能使用@Controller</p>
		</td>
	</tr><tr><td>2</td>
		<td>
		<p>@RequestMapping</p>
		</td>
		<td>类,方法上</td>
		<td>
		<p>用来映射Web请求(访问路径和参数)、处理类和方法的。</p>

		<p>注解在方法上的@RequestMapping路径会继承注解在类上的路径,@RequestMapping支持Servlet的request和reponse作为参数,也支持对request和response的媒体类型进行配置。</p>

		<p>@RequestMapping 既可以作用在类级别,也可以作用在方法级别。当它定义在类级别时,标明该控制器处理所有的请求都被映射到 /favsoft 路径下。</p>

		<p>@RequestMapping中可以使用 method 属性标记其所接受的方法类型,如果不指定方法类型的话,可以使用 HTTP GET/POST 方法请求数据,但是一旦指定方法类型,就只能使用该类型获取数据。</p>

		<p>@RequestMapping 可以使用 @Validated与BindingResult联合验证输入的参数,在验证通过和失败的情况下,分别返回不同的视图。</p>

		<p>@RequestMapping支持使用URI模板访问URL。URI模板像是URL模样的字符串,由一个或多个变量名字组成,当这些变量有值的时候,它就变成了URI。</p>
		</td>
	</tr><tr><td>3</td>
		<td>
		<p>@ResponseBody</p>
		</td>
		<td>类,返回值前,方法上</td>
		<td>
		<p>@ResponseBody:它的作用是将返回类型直接输入到HTTP response body中。</p>

		<p>@ResponseBody:输出JSON格式的数据</p>
		</td>
	</tr><tr><td>4</td>
		<td>
		<p>@RequestBody</p>
		</td>
		<td>参数前</td>
		<td>
		<p>request的参数在请求体内</p>

		<pre class="has" name="code" onclick="hljs.copyCode(event)">

 

		<pre class="has" name="code" onclick="hljs.copyCode(event)"><code class="language-java hljs"><ol class="hljs-ln" style="width:500px"><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="1"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"><span class="hljs-meta">@RequestMapping</span>(value =&nbsp;<span class="hljs-string">"/something"</span>, method = RequestMethod.PUT)</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="2"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"> </div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="3"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"><span class="hljs-function"><span class="hljs-keyword">public</span>&nbsp;<span class="hljs-keyword">void</span>&nbsp;<span class="hljs-title">handle</span><span class="hljs-params">(@RequestBody String body, Writer writer)</span>&nbsp;<span class="hljs-keyword">throws</span>&nbsp;IOException&nbsp;</span>{</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="4"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"> </div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="5"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">writer.write(body);</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="6"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"> </div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="7"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">}</div></div></li></ol></code><div class="hljs-button {2}" data-title="复制"></div></pre>

		<ol><li>
			<p><code>如果觉得@RequestBody不如@RequestParam趁手,我们可以使用 HttpMessageConverter将request的body转移到方法参数上, HttMessageConverser将 HTTP请求消息在Object对象之间互相转换,但一般情况下不会这么做。事实证明,@RequestBody在构建REST架构时,比@RequestParam有着更大的优势。</code></p>
			</li>
		</ol>
		&nbsp;

		<pre class="has" name="code" onclick="hljs.copyCode(event)">

 

		<pre class="has" name="code" onclick="hljs.copyCode(event)"><code class="language-java hljs"><ol class="hljs-ln" style="width:566px"><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="1"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"><span class="hljs-meta">@RequestMapping</span>(value =&nbsp;<span class="hljs-string">"/something"</span>, method = RequestMethod.PUT)</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="2"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"> </div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="3"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"><span class="hljs-function"><span class="hljs-keyword">public</span>&nbsp;<span class="hljs-keyword">void</span>&nbsp;<span class="hljs-title">handle</span><span class="hljs-params">(@RequestBody&nbsp;String body, Writer writer)</span>&nbsp;<span class="hljs-keyword">throws</span>&nbsp;IOException&nbsp;</span>{</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="4"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"> </div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="5"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">writer.write(body);</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="6"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"> </div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="7"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">}</div></div></li></ol></code><div class="hljs-button {2}" data-title="复制"></div></pre>

		<ol><li>
			<p><code>如果觉得@RequestBody不如@RequestParam趁手,我们可以使用 HttpMessageConverter将request的body转移到方法参数上, HttMessageConverser将 HTTP请求消息在Object对象之间互相转换,但一般情况下不会这么做。事实证明,@RequestBody在构建REST架构时,比@RequestParam有着更大的优势。</code></p>
			</li>
		</ol><p>如果觉得@RequestBody不如@RequestParam趁手,我们可以使用HttpMessageConverter将request的body转移到方法参数上,HttMessageConverser将HTTP请求消息在Object</p>

		<p>&nbsp;对象之间互相转换,但一般情况下不会这么做。事实证明,@RequestBody在构建REST架构时,比@RequestParam有着更大的优势。</p>
		</td>
	</tr><tr><td>5</td>
		<td>
		<p>@PathVariable</p>
		</td>
		<td>参数前</td>
		<td>
		<p>接收路径参数。</p>

		<p>在Spring MVC中,可以使用 @PathVariable 注解方法参数并将其绑定到URI模板变量的值上。</p>

		<p>@PathVariable 可以有多个注解</p>

		<p>@PathVariable中的参数可以是任意的简单类型,如int, long, Date等等。Spring会自动将其转换成合适的类型或者抛出 TypeMismatchException异常。当然,我们也可以注册支持额外的数据类型。</p>

		<p>如果@PathVariable使用Map&lt;String, String&gt;类型的参数时, Map会填充到所有的URI模板变量中。</p>

		<p>@PathVariable支持使用正则表达式,这就决定了它的超强大属性,它能在路径模板中使用占位符,可以设定特定的前缀匹配,后缀匹配等自定义格式。&nbsp;</p>

		<p>@PathVariable还支持矩阵变量</p>
		</td>
	</tr><tr><td>6</td>
		<td>
		<p>@RestController</p>
		</td>
		<td>类</td>
		<td>
		<p>组合注解 =@Controller+@ResponseBody</p>

		<p>我们经常见到一些控制器实现了REST的API,只为服务于JSON,XML或其它自定义的类型内容。</p>

		<p>@RestController就是这样一种类型,它避免了你重复的写@RequestMapping与@ResponseBody。</p>

		<p>@RestController用来创建REST类型的控制器。</p>
		</td>
	</tr><tr><td>7</td>
		<td>
		<p>@EnableWebMvc</p>
		</td>
		<td>类</td>
		<td>
		<p>开启对SpringMVC的配置支持,可以重写这个类的方法,配置拦截器,配置静态资源映射</p>
		</td>
	</tr><tr><td>8</td>
		<td>
		<p>@ControllerAdvice</p>
		</td>
		<td>类</td>
		<td>
		<p>1.将对于控制器的全局配置放在同一个位置</p>

		<p>2.注解了@Controller的类的方法可以使用@ExceptionHandler,@InitBinder,@ModelAttribute注解到方法上,这对所有注解了@RequestMapping的控制器内的方法有效。</p>
		</td>
	</tr><tr><td>&nbsp;</td>
		<td>
		<p>@ExceptionHandler</p>
		</td>
		<td>&nbsp;</td>
		<td>
		<p>用于全局处理控制器里的异常。</p>
		</td>
	</tr><tr><td>&nbsp;</td>
		<td>
		<p>@InitBinder</p>
		</td>
		<td>&nbsp;</td>
		<td>
		<p>用来设置WebDataBinder,WebDataBinder用来自动绑定前台请求参数到Model中。</p>
		</td>
	</tr><tr><td>&nbsp;</td>
		<td>
		<p>@ModelAttribute</p>
		</td>
		<td>&nbsp;</td>
		<td>
		<p>本来的作用是绑定键值对到Model里,此处是让全局的@RequestMapping都能获得在此处设置的键值对。</p>
		</td>
	</tr><tr><td>9</td>
		<td>
		<p>@RequestParam</p>
		</td>
		<td>参数中</td>
		<td>
		<p>@RequestParam将请求的参数绑定到方法中的参数上,如下面的代码所示。</p>

		<p>其实,即使不配置该参数,注解也会默认使用该参数。如果想自定义指定参数的话,如果将@RequestParam的 required 属性设置为false(@RequestParam(value="id",required=false))。</p>
		</td>
	</tr><tr><td>10</td>
		<td>
		<p>@ModelAttribute</p>
		</td>
		<td>方法或方法参数上</td>
		<td>
		<p>当它作用在方法上时,标明该方法的目的是添加一个或多个模型属性(model attributes)。该方法支持与@RequestMapping一样的参数类型,但并不能直接映射成请求。控制器中的@ModelAttribute方法会在@RequestMapping方法调用之前而调用,示例如下</p>

		<p>@ModelAttribute方法用来在model中填充属性,如填充下拉列表、宠物类型或检索一个命令对象比如账户(用来在HTML表单上呈现数据)。</p>

		<p>@ModelAttribute方法有两种风格:一种是添加隐形属性并返回它。另一种是该方法接受一个模型并添加任意数量的模型属性。用户可以根据自己的需要选择对应的风格。</p>

		<p>&nbsp;</p>

		<p>当@ModelAttribute作用在方法参数上时,表明该参数可以在方法模型中检索到。如果该参数不在当前模型中,该参数先被实例化然后添加到模型中。一旦模型中有了该参数,该参数的字段应该填充所有请求参数匹配的名称中。这是Spring MVC中重要的数据绑定机制,它省去了单独解析每个表单字段的时间。</p>

		<p>@ModelAttribute是一种很常见的从数据库中检索属性的方法,它通过@SessionAttributes使用request请求存储。在一些情况下,可以很方便的通过URI模板变量和类型转换器检索属性。</p>

		<p>&nbsp;</p>
		</td>
	</tr><tr><td>11</td>
		<td>
		<p>@HttpEntity</p>
		</td>
		<td>&nbsp;</td>
		<td>
		<p>HttpEntity除了能获得request请求和response响应之外,它还能访问请求和响应头,如下所示:</p>

		<p>&nbsp;</p>
		</td>
	</tr></tbody></table></div><p><br>

  

springboot注解:

1

@ComponentScan(basePackages = "com.xzc.")

 
2

@SpringBootApplication

SpringBoot的核心注解,主要作用是开启自动配置。

		<p>@SpringBootApplication=@ComponentScan+@Configuration+@EnableAutoConfiguration</p>

		<p>关闭特定的自动配置:@SpringBootApplication注解的exclude参数。</p>

		<p>例如:@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class} )</p>
		</td>
	</tr><tr><td>3</td>
		<td>
		<p>@PropertySource({"classpath:application.properties", "classpath:xzc.properties"})</p>
		</td>
		<td>&nbsp;</td>
	</tr><tr><td>4</td>
		<td>
		<p>@ImportResource("classpath:ws-client.xml")</p>
		</td>
		<td>加载xml配置。</td>
	</tr><tr><td>5</td>
		<td>
		<p>@EnableRedisHttpSession</p>
		</td>
		<td>&nbsp;</td>
	</tr><tr><td>&nbsp;</td>
		<td>
		<p>&nbsp;</p>
		</td>
		<td>&nbsp;</td>
	</tr><tr><td>7</td>
		<td>
		<p>@EnableCaching</p>
		</td>
		<td>&nbsp;</td>
	</tr><tr><td>8</td>
		<td>
		<p>@EnableAsync</p>
		</td>
		<td>&nbsp;</td>
	</tr><tr><td>9</td>
		<td>
		<p>@Configuration</p>
		</td>
		<td>&nbsp;</td>
	</tr><tr><td>10</td>
		<td>
		<p>@EnableScheduling</p>
		</td>
		<td>
		<p>启动定时任务</p>
		</td>
	</tr><tr><td>11</td>
		<td>
		<p>@Entity</p>
		</td>
		<td>
		<p>注释指明这是一个实体Bean</p>
		</td>
	</tr></tbody></table></div><h1 id="h1_82">&nbsp;</h1>

Lombok:简化java代码注解

1

@Data

注解在类上;提供类所有属性的 getting 和 setting 方法,此外还提供了equals、canEqual、hashCode、toString 方法
2

@Setter

注解在属性上;为属性提供 setting 方法
3

@Getter

注解在属性上;为属性提供 getting 方法
4

@NoArgsConstructor

注解在类上;为类提供一个无参的构造方法
5

@AllArgsConstructor

注解在类上,为类提供一个全参的构造方法
6

@Log4j

注解在类上;为类提供一个 属性名为log 的 log4j 日志对象
 

 

----JSR-250----

1

@PostConstruct

用于指定初始化方法(用在方法上)
2

@PreDestory

用于指定销毁方法(用在方法上)
3

@Resource 

默认按名称装配,当找不到与名称匹配的bean才会按类型装配。

----------

 


代理的共有优点:业务类只需要关注业务逻辑本身,保证了业务类的重用性。
Java静态代理:
代理对象和目标对象实现了相同的接口,目标对象作为代理对象的一个属性,具体接口实现中,代理对象可以在调用目标对象相应方法前后加上其他业务处理逻辑。
缺点:一个代理类只能代理一个业务类。如果业务类增加方法时,相应的代理类也要增加方法。
Java动态代理:
Java动态代理是写一个类实现InvocationHandler接口,重写Invoke方法,在Invoke方法可以进行增强处理的逻辑的编写,这个公共代理类在运行的时候才能明确自己要代理的对象,同时可以实现该被代理类的方法的实现,然后在实现类方法的时候可以进行增强处理。
实际上:代理对象的方法 = 增强处理 + 被代理对象的方法

JDK和CGLIB生成动态代理类的区别:
JDK动态代理只能针对实现了接口的类生成代理(实例化一个类)。此时代理对象和目标对象实现了相同的接口,目标对象作为代理对象的一个属性,具体接口实现中,可以在调用目标对象相应方法前后加上其他业务处理逻辑
CGLIB是针对类实现代理,主要是对指定的类生成一个子类(没有实例化一个类),覆盖其中的方法 。
Spring AOP应用场景
性能检测,访问控制,日志管理,事务等。
默认的策略是如果目标类实现接口,则使用JDK动态代理技术,如果目标对象没有实现接口,则默认会采用CGLIB代理


SpringMVC运行原理

  1. 客户端请求提交到DispatcherServlet
  2. 由DispatcherServlet控制器查询HandlerMapping,找到并分发到指定的Controller中。
  3. Controller调用业务逻辑处理后,返回ModelAndView
  4. DispatcherServlet查询一个或多个ViewResoler视图解析器,找到ModelAndView指定的视图
  5. 视图负责将结果显示到客户端

前端控制器(DispatcherServlet):接收请求,响应结果,相当于电脑的CPU。

处理器映射器(HandlerMapping):根据URL去查找处理器

处理器(Handler):(需要程序员去写代码处理逻辑的)

处理器适配器(HandlerAdapter):会把处理器包装成适配器,这样就可以支持多种类型的处理器,类比笔记本的适配器(适配器模式的应用)

视图解析器(ViewResovler):进行视图解析,多返回的字符串,进行处理,可以解析成对应的页面

SpringMVC流程

1、  用户发送请求至前端控制器DispatcherServlet。

2、  DispatcherServlet收到请求调用HandlerMapping处理器映射器。

3、  处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找),生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。

4、  DispatcherServlet调用HandlerAdapter处理器适配器。

5、  HandlerAdapter经过适配调用具体的处理器(Controller,也叫后端控制器)。

6、  Controller执行完成返回ModelAndView。

7、  HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。

8、  DispatcherServlet将ModelAndView传给ViewReslover视图解析器。

9、  ViewReslover解析后返回具体View。

10、DispatcherServlet根据View进行渲染视图(即将模型数据填充至视图中)。

11、 DispatcherServlet响应用户。

友情链接:Spring:基于注解的Spring MVC(上)
友情链接: Spring:基于注解的Spring MVC(下) 
友情链接:SpringMVC与Struts2区别与比较总结
友情链接:SpringMVC与Struts2的对比


一个Http请求
DNS域名解析 –> 发起TCP的三次握手 –> 建立TCP连接后发起http请求 –> 服务器响应http请求,浏览器得到html代码 –> 浏览器解析html代码,并请求html代码中的资源(如javascript、css、图片等) –> 浏览器对页面进行渲染呈现给用户

设计存储海量数据的存储系统:设计一个叫“中间层”的一个逻辑层,在这个层,将数据库的海量数据抓出来,做成缓存,运行在服务器的内存中,同理,当有新的数据到来,也先做成缓存,再想办法,持久化到数据库中,这是一个简单的思路。主要的步骤是负载均衡,将不同用户的请求分发到不同的处理节点上,然后先存入缓存,定时向主数据库更新数据。读写的过程采用类似乐观锁的机制,可以一直读(在写数据的时候也可以),但是每次读的时候会有个版本的标记,如果本次读的版本低于缓存的版本,会重新读数据,这样的情况并不多,可以忍受。

友情链接: HTTP与HTTPS的区别
友情链接: HTTPS 为什么更安全,先看这些 
友情链接: HTTP请求报文和HTTP响应报文
友情链接: HTTP 请求方式: GET和POST的比较


Session与Cookie:Cookie可以让服务端跟踪每个客户端的访问,但是每次客户端的访问都必须传回这些Cookie,如果Cookie很多,则无形的增加了客户端与服务端的数据传输量,
而Session则很好地解决了这个问题,同一个客户端每次和服务端交互时,将数据存储通过Session到服务端,不需要每次都传回所有的Cookie值,而是传回一个ID,每个客户端第一次访问服务器生成的唯一的ID,客户端只要传回这个ID就行了,这个ID通常为NAME为JSESSIONID的一个Cookie。这样服务端就可以通过这个ID,来将存储到服务端的KV值取出了。
Session和Cookie的超时问题,Cookie的安全问题

 http是无状态的协议,客户每次读取web页面时,服务器都打开新的会话,而且服务器也不会自动维护客户的上下文信息。session就是一种保存上下文信息的机制,她是针对每一个用户的,session的内容在服务器端,通过sessionId来区分不同的客户,session是以cookie或url重写为基础的,默认用cookie来实现,系统会创造一个JSESSIONID的输出cookie,我们成为session cookie,以区分persistent coookies,注意session cookie是存储于浏览器内存中的,并不是写到硬盘上的;我们通常是看不见JSESSIONID的,但是当我们禁用浏览器的cookie后,web服务器会采用url重写的方式传递sessionid,我们就可以在浏览器看到sessionid=HJHADKSFHKAJSHFJ之类的字符串;session cookie针对某一次会话而言,会话结束session cookie也就消失了 

cookie 和session 的区别:

1、cookie数据存放在客户的浏览器上,session数据放在服务器上。

2、cookie不是很安全,别人可以分析存放在本地的COOKIE并进行COOKIE欺骗
   考虑到安全应当使用session。

3、session会在一定时间内保存在服务器上。当访问增多,会比较占用你服务器的性能
   考虑到减轻服务器性能方面,应当使用COOKIE。

4、单个cookie保存的数据不能超过4K,很多浏览器都限制一个站点最多保存20个cookie。

5、所以个人建议:
   将登陆信息等重要信息存放为SESSION
   其他信息如果需要保留,可以放在COOKIE中


分布式Session框架

  1. 配置服务器,Zookeeper集群管理服务器可以统一管理所有服务器的配置文件
  2. 共享这些Session存储在一个分布式缓存中,可以随时写入和读取,而且性能要很好,如Memcache,Tair。
  3. 封装一个类继承自HttpSession,将Session存入到这个类中然后再存入分布式缓存中
  4. 由于Cookie不能跨域访问,要实现Session同步,要同步SessionID写到不同域名下。

适配器模式:将一个接口适配到另一个接口,Java I/O中InputStreamReader将Reader类适配到InputStream,从而实现了字节流到字符流的准换。
装饰者模式:保持原来的接口,增强原来有的功能。
FileInputStream 实现了InputStream的所有接口,BufferedInputStreams继承自FileInputStream是具体的装饰器实现者,将InputStream读取的内容保存在内存中,而提高读取的性能。


Spring事务配置方法:
1.切点信息,用于定位实施事物切面的业务类方法
2.控制事务行为的事务属性,这些属性包括事物隔离级别,事务传播行为,超时时间,回滚规则。

Spring通过aop/tx Schema 命名空间和@Transaction注解技术来进行声明式事物配置。

@Transaction 事务隔离级别,事务传播行为,事务超时,事务只读属性


Mybatis
每一个Mybatis的应用程序都以一个SqlSessionFactory对象的实例为核心。首先用字节流通过Resource将配置文件读入,然后通过SqlSessionFactoryBuilder().build方法创建SqlSessionFactory,然后再通过SqlSessionFactory.openSession()方法创建一个SqlSession为每一个数据库事务服务。
经历了Mybatis初始化 –>创建SqlSession –>运行SQL语句,返回结果三个过程


Servlet和Filter的区别:
整的流程是:Filter对用户请求进行预处理,接着将请求交给Servlet进行处理并生成响应,最后Filter再对服务器响应进行后处理。

   1、servlet:servlet是一种运行服务器端的java应用程序,具有独立于平台和协议的特性,并且可以动态的生成web页面,它工作在客户端请求与服务器响应的中间层。
 
   2、filter:filter是一个可以复用的代码片段,可以用来转换HTTP请求、响应和头信息。Filter不像Servlet,它不能产生一个请求或者响应,它只是修改对某一资源的请求,或者修改从某一的响应。
 

Filter有如下几个用处:
Filter可以进行对特定的url请求和相应做预处理和后处理。
在HttpServletRequest到达Servlet之前,拦截客户的HttpServletRequest。
根据需要检查HttpServletRequest,也可以修改HttpServletRequest头和数据。
在HttpServletResponse到达客户端之前,拦截HttpServletResponse。
根据需要检查HttpServletResponse,也可以修改HttpServletResponse头和数据。

实际上Filter和Servlet极其相似,区别只是Filter不能直接对用户生成响应。实际上Filter里doFilter()方法里的代码就是从多个Servlet的service()方法里抽取的通用代码,通过使用Filter可以实现更好的复用。

Filter和Servlet的生命周期:
1.Filter在web服务器启动时初始化
2.如果某个Servlet配置了 1 该Servlet也是在Tomcat(Servlet容器)启动时初始化。
3.如果Servlet没有配置1,该Servlet不会在Tomcat启动时初始化,而是在请求到来时初始化。
4.每次请求, Request都会被初始化,响应请求后,请求被销毁。
5.Servlet初始化后,将不会随着请求的结束而注销。
6.关闭Tomcat时,Servlet、Filter依次被注销。


HashMap与HashTable的区别。
1、HashMap是非线程安全的,HashTable是线程安全的。
2、HashMap的键和值都允许有null值存在,而HashTable则不行。
3、因为线程安全的问题,HashMap效率比HashTable的要高。

HashMap的实现机制:

  1. 维护一个每个元素是一个链表的数组,而且链表中的每个节点是一个Entry[]键值对的数据结构。
  2. 实现了数组+链表的特性,查找快,插入删除也快。
  3. 对于每个key,他对应的数组索引下标是 int i = hash(key.hashcode)&(len-1);
  4. 每个新加入的节点放在链表首,然后该新加入的节点指向原链表首

多线程的hashmap在扩容时可能会造成死循环的问题。

HashMap和TreeMap区别

1、实现 
TreeMap:SortMap接口,基于红黑树 
HashMap:基于哈希散列表实现 

2、存储 
TreeMap:默认按键的升序排序 
HashMap:随机存储 
3、遍历 
TreeMap:Iterator遍历是排序的 
HashMap:Iterator遍历是随机的 
4、性能损耗 
TreeMap:插入、删除 
HashMap:基本无 
5、键值对 
TreeMap:键、值都不能为null 
HashMap:只允许键、值均为null 
6、安全 
TreeMap:非并发安全Map 
HashMap:非并发安全Map 
7、效率 
TreeMap:低 
HashMap:高
友情链接: Java中HashMap和TreeMap的区别深入理解

HashMap冲突
友情链接: HashMap冲突的解决方法以及原理分析
友情链接: HashMap的工作原理
友情链接: HashMap和Hashtable的区别
友情链接: 2种办法让HashMap线程安全


HashMap,ConcurrentHashMap与LinkedHashMap的区别

  1. ConcurrentHashMap是使用了锁分段技术技术来保证线程安全的,锁分段技术:首先将数据分成一段一段的存储,然后给每一段数据配一把锁,当一个线程占用锁访问其中一个段数据的时候,其他段的数据也能被其他线程访问
  2. ConcurrentHashMap 是在每个段(segment)中线程安全的
  3. LinkedHashMap维护一个双链表,可以将里面的数据按写入的顺序读出

Hashmap的扩容需要满足两个条件:当前数据存储的数量(即size())大小必须大于等于阈值;当前加入的数据是否发生了hash冲突

ConcurrentHashMap应用场景
1:ConcurrentHashMap的应用场景是高并发,但是并不能保证线程安全,而同步的HashMap和HashMap的是锁住整个容器,而加锁之后ConcurrentHashMap不需要锁住整个容器,只需要锁住对应的Segment就好了,所以可以保证高并发同步访问,提升了效率。
2:可以多线程写。
ConcurrentHashMap把HashMap分成若干个Segmenet
1.get时,不加锁,先定位到segment然后在找到头结点进行读取操作。而value是volatile变量,所以可以保证在竞争条件时保证读取最新的值,如果读到的value是null,则可能正在修改,那么就调用ReadValueUnderLock函数,加锁保证读到的数据是正确的。
2.Put时会加锁,一律添加到hash链的头部。
3.Remove时也会加锁,由于next是final类型不可改变,所以必须把删除的节点之前的节点都复制一遍。
4.ConcurrentHashMap允许多个修改操作并发进行,其关键在于使用了锁分离技术。它使用了多个锁来控制对Hash表的不同Segment进行的修改。

ConcurrentHashMap的应用场景是高并发,但是并不能保证线程安全,而同步的HashMap和HashTable的是锁住整个容器,而加锁之后ConcurrentHashMap不需要锁住整个容器,只需要锁住对应的segment就好了,所以可以保证高并发同步访问,提升了效率。

 size、containsValue

ConcurrentHashMap能够保证每一次调用都是原子操作,但是并不保证多次调用之间也是原子操作。

这些方法都是基于整个ConcurrentHashMap来进行操作的,他们的原理也基本类似:首先不加锁循环执行以下操作:循环所有的Segment(通过Unsafe的getObjectVolatile()以保证原子读语义),获得对应的值以及所有Segment的modcount之和。如果连续两次所有Segment的modcount和相等,则过程中没有发生其他线程修改ConcurrentHashMap的情况,返回获得的值。

当循环次数超过预定义的值时,这时需要对所有的Segment依次进行加锁,获取返回值后再依次解锁。值得注意的是,加锁过程中要强制创建所有的Segment,否则容易出现其他线程创建Segment并进行put,remove等操作。代码如下:
友情链接:Java集合—ConcurrentHashMap原理分析


Vector和ArrayList的区别
友情链接:Java中Vector和ArrayList的区别


ExecutorService service = Executors…. ExecutorService service = new ThreadPoolExecutor() ExecutorService service = new ScheduledThreadPoolExecutor();

ThreadPoolExecutor线程池参数设置技巧

一、ThreadPoolExecutor的重要参数

  • corePoolSize:核心线程数
    • 核心线程会一直存活,及时没有任务需要执行
    • 当线程数小于核心线程数时,即使有线程空闲,线程池也会优先创建新线程处理
    • 设置allowCoreThreadTimeout=true(默认false)时,核心线程会超时关闭
  • queueCapacity:任务队列容量(阻塞队列)
    • 当核心线程数达到最大时,新任务会放在队列中排队等待执行
  • maxPoolSize:最大线程数
    • 当线程数>=corePoolSize,且任务队列已满时。线程池会创建新线程来处理任务
    • 当线程数=maxPoolSize,且任务队列已满时,线程池会拒绝处理任务而抛出异常
  • keepAliveTime:线程空闲时间
    • 当线程空闲时间达到keepAliveTime时,线程会退出,直到线程数量=corePoolSize
    • 如果allowCoreThreadTimeout=true,则会直到线程数量=0
  • allowCoreThreadTimeout:允许核心线程超时
  • rejectedExecutionHandler:任务拒绝处理器
    • 两种情况会拒绝处理任务:
      • 当线程数已经达到maxPoolSize,切队列已满,会拒绝新任务
      • 当线程池被调用shutdown()后,会等待线程池里的任务执行完毕,再shutdown。如果在调用shutdown()和线程池真正shutdown之间提交任务,会拒绝新任务
    • 线程池会调用rejectedExecutionHandler来处理这个任务。如果没有设置默认是AbortPolicy,会抛出异常
    • ThreadPoolExecutor类有几个内部实现类来处理这类情况:
      • AbortPolicy 丢弃任务,抛运行时异常
      • CallerRunsPolicy 执行任务
      • DiscardPolicy 忽视,什么都不会发生
      • DiscardOldestPolicy 从队列中踢出最先进入队列(最后一个执行)的任务
    • 实现RejectedExecutionHandler接口,可自定义处理器

二、ThreadPoolExecutor执行顺序:

     线程池按以下行为执行任务

  1. 当线程数小于核心线程数时,创建线程。
  2. 当线程数大于等于核心线程数,且任务队列未满时,将任务放入任务队列。
  3. 当线程数大于等于核心线程数,且任务队列已满
    1. 若线程数小于最大线程数,创建线程
    2. 若线程数等于最大线程数,抛出异常,拒绝任务

ThreadPoolExecutor源码分析

线程池本身的状态:

等待任务队列和工作集:

线程池的主要状态锁:

线程池的存活时间和大小:

1.2 ThreadPoolExecutor 的内部工作原理
有了以上定义好的数据,下面来看看内部是如何实现的 。 Doug Lea 的整个思路总结起来就是 5 句话:

  1. 如果当前池大小 poolSize 小于 corePoolSize ,则创建新线程执行任务。
  2. 如果当前池大小 poolSize 大于 corePoolSize ,且等待队列未满,则进入等待队列
  3. 如果当前池大小 poolSize 大于 corePoolSize 且小于 maximumPoolSize ,且等待队列已满,则创建新线程执行任务。
  4. 如果当前池大小 poolSize 大于 corePoolSize 且大于 maximumPoolSize ,且等待队列已满,则调用拒绝策略来处理该任务。
  5. 线程池里的每个线程执行完任务后不会立刻退出,而是会去检查下等待队列里是否还有线程任务需要执行,如果在 keepAliveTime 里等不到新的任务了,那么线程就会退出。

Executor包结构

CopyOnWriteArrayList : 写时加锁,当添加一个元素的时候,将原来的容器进行copy,复制出一个新的容器,然后在新的容器里面写,写完之后再将原容器的引用指向新的容器,而读的时候是读旧容器的数据,所以可以进行并发的读,但这是一种弱一致性的策略。
使用场景:CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里,比如缓存。


Linux常用命令:cd,cp,mv,rm,ps(进程),tar,cat(查看内容),chmod,vim,find,ls


死锁的必要条件

  1. 互斥 至少有一个资源处于非共享状态
  2. 占有并等待
  3. 非抢占
  4. 循环等待

解决死锁,第一个是死锁预防,就是不让上面的四个条件同时成立。二是,合理分配资源。
三是使用银行家算法,如果该进程请求的资源操作系统剩余量可以满足,那么就分配。


进程间的通信方式

  1. 管道( pipe ):管道是一种半双工的通信方式,数据只能单向流动,而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。
  2. 有名管道 (named pipe) : 有名管道也是半双工的通信方式,但是它允许无亲缘关系进程间的通信。
  3. 信号量( semophore ) : 信号量是一个计数器,可以用来控制多个进程对共享资源的访问。它常作为一种锁机制,防止某进程正在访问共享资源时,其他进程也访问该资源。因此,主要作为进程间以及同一进程内不同线程之间的同步手段。
  4. 消息队列( message queue ) : 消息队列是由消息的链表,存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。
  5. 信号 ( sinal ) : 信号是一种比较复杂的通信方式,用于通知接收进程某个事件已经发生。
  6. 共享内存( shared memory ) :共享内存就是映射一段能被其他进程所访问的内存,这段共享内存由一个进程创建,但多个进程都可以访问。共享内存是最快的 IPC 方式,它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制,如信号量,配合使用,来实现进程间的同步和通信。
  7. 套接字( socket ) : 套解口也是一种进程间通信机制,与其他通信机制不同的是,它可用于不同机器间的进程通信。

进程与线程的区别和联系
操作系统的进程调度算法
计算机系统的层次存储结构详解


数据库事务是指作为单个逻辑工作单元执行的一系列操作。

友情链接:数据库事务的四大特性以及事务的隔离级别

原子性,一致性,隔离性,持久性。


MySQL数据库优化总结
MYSQL 优化常用方法
MySQL存储引擎--MyISAM与InnoDB区别
关于SQL数据库中的范式


Hibernate的一级缓存是由Session提供的,因此它只存在于Session的生命周期中,当程序调用save(),update(),saveOrUpdate()等方法 及调用查询接口list,filter,iterate时,如Session缓存中还不存在相应的对象,Hibernate会把该对象加入到一级缓存中,当Session关闭的时候缓存也会消失。

Hibernate的一级缓存是Session所内置的,不能被卸载,也不能进行任何配置一级缓存采用的是key-value的Map方式来实现的,在缓存实体对象时,对象的主关键字ID是Map的key,实体对象就是对应的值。

Hibernate二级缓存:把获得的所有数据对象根据ID放入到第二级缓存中。Hibernate二级缓存策略,是针对于ID查询的缓存策略,删除、更新、增加数据的时候,同时更新缓存。

进程和线程的区别:

进程:每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销,一个进程包含1–n个线程。

线程:同一类线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(PC),线程切换开销小。

线程和进程一样分为五个阶段:创建、就绪、运行、阻塞、终止。

多进程是指操作系统能同时运行多个任务(程序)。

多线程是指在同一程序中有多个顺序流在执行。

在java中要想实现多线程,有三种手段,一种是继续Thread类,另外一种是实现Runable接口,还有就是实现Callable接口。

不同点:

  1. 两者最大的不同点是:实现Callable接口的任务线程能返回执行结果;而实现Runnable接口的任务线程不能返回结果;
  2. Callable接口的call()方法允许抛出异常;而Runnable接口的run()方法的异常只能在内部消化,不能继续上抛;

Switch能否用string做参数?

a.在 Java 7 之前, switch 只能支持byte,short,char,int 或者其对应的封装类以及 Enum 类型。在Java 7中,String 支持被加上了。


Object有哪些公用方法?

a.方法equals测试的是两个对象是否相等

b.方法clone进行对象拷贝

c.方法getClass返回和当前对象相关的Class对象

d.方法notify,notifyall,wait都是用来对给定对象进行线程同步的


Java的四种引用,强弱软虚,以及用到的场景

a.利用软引用和弱引用解决OOM问题:用一个HashMap来保存图片的路径和相应图片对象关联的软引用之间的映射关系,在内存不足时,JVM会自动回收这些缓存图片对象所占用的空间,从而有效地避免了OOM的问题。

b.通过软可及对象重获方法实现Java对象的高速缓存:比如我们创建了一Employee的类,如果每次需要查询一个雇员的信息。哪怕是几秒中之前刚刚查询过的,都要重新构建一个实例,这是需要消耗很多时间的。我们可以通过软引用和 HashMap 的结合,先是保存引用方面:以软引用的方式对一个Employee对象的实例进行引用并保存该引用到HashMap 上,key 为此雇员的 id,value为这个对象的软引用,另一方面是取出引用,缓存中是否有该Employee实例的软引用,如果有,从软引用中取得。如果没有软引用,或者从软引用中得到的实例是null,重新构建一个实例,并保存对这个新建实例的软引用。

c.强引用:如果一个对象具有强引用,它就不会被垃圾回收器回收。即使当前内存空间不足,JVM也不会回收它,而是抛出 OutOfMemoryError 错误,使程序异常终止。如果想中断强引用和某个对象之间的关联,可以显式地将引用赋值为null,这样一来的话,JVM在合适的时间就会回收该对象。

d.软引用:在使用软引用时,如果内存的空间足够,软引用就能继续被使用,而不会被垃圾回收器回收,只有在内存不足时,软引用才会被垃圾回收器回收。

e.弱引用:具有弱引用的对象拥有的生命周期更短暂。因为当 JVM 进行垃圾回收,一旦发现弱引用对象,无论当前内存空间是否充足,都会将弱引用回收。不过由于垃圾回收器是一个优先级较低的线程,所以并不一定能迅速发现弱引用对象。

f.虚引用:顾名思义,就是形同虚设,如果一个对象仅持有虚引用,那么它相当于没有引用,在任何时候都可能被垃圾回收器回收。

 

 


Hashcode的作用,与 equal 有什么区别?

a.同样用于鉴定2个对象是否相等的,java集合中有 list 和 set 两类,其中 set不允许元素重复实现,那个这个不允许重复实现的方法,如果用 equal 去比较的话,如果存在1000个元素,你 new 一个新的元素出来,需要去调用1000次 equal 去逐个和他们比较是否是同一个对象,这样会大大降低效率。hashcode实际上是返回对象的存储地址,如果这个位置上没有元素,就把元素直接存储在上面,如果这个位置上已经存在元素,这个时候才去调用equal方法与新元素进行比较,相同的话就不存了,散列到其他地址上。


Override和Overload的含义以及区别
a.Overload顾名思义是重新加载,它可以表现类的多态性,可以是函数里面可以有相同的函数名但是参数名、返回值、类型不能相同;或者说可以改变参数、类型、返回值但是函数名字依然不变。
b.就是ride(重写)的意思,在子类继承父类的时候子类中可以定义某方法与其父类有相同的名称和参数,当子类在调用这一函数时自动调用子类的方法,而父类相当于被覆盖(重写)了。
具体可前往C++中重载、重写(覆盖)的区别实例分析查看


抽象类和接口的区别

a.一个类只能继承单个类,但是可以实现多个接口

b.抽象类中可以有构造方法,接口中不能有构造方法

c.抽象类中的所有方法并不一定要是抽象的,你可以选择在抽象类中实现一些基本的方法。而接口要求所有的方法都必须是抽象的

d.抽象类中可以包含静态方法,接口中不可以

e.抽象类中可以有普通成员变量,接口中不可以

解析XML的几种方式的原理与特点:DOM、SAX、PULL

a.DOM:消耗内存:先把xml文档都读到内存中,然后再用DOM API来访问树形结构,并获取数据。这个写起来很简单,但是很消耗内存。要是数据过大,手机不够牛逼,可能手机直接死机

b.SAX:解析效率高,占用内存少,基于事件驱动的:更加简单地说就是对文档进行顺序扫描,当扫描到文档(document)开始与结束、元素(element)开始与结束、文档(document)结束等地方时通知事件处理函数,由事件处理函数做相应动作,然后继续同样的扫描,直至文档结束。

c.PULL:与 SAX 类似,也是基于事件驱动,我们可以调用它的next()方法,来获取下一个解析事件(就是开始文档,结束文档,开始标签,结束标签),当处于某个元素时可以调用XmlPullParser的getAttributte()方法来获取属性的值,也可调用它的nextText()获取本节点的值。


wait()和sleep()的区别

sleep来自Thread类,和wait来自Object类

调用sleep()方法的过程中,线程不会释放对象锁。而 调用 wait 方法线程会释放对象锁

sleep睡眠后不出让系统资源,wait让出系统资源其他线程可以占用CPU

sleep(milliseconds)需要指定一个睡眠时间,时间一到会自动唤醒


JAVA 中堆和栈的区别,说下java 的内存机制

a.基本数据类型比变量和对象的引用都是在栈分配的

b.堆内存用来存放由new创建的对象和数组

c.类变量(static修饰的变量),程序在一加载的时候就在堆中为类变量分配内存,堆中的内存地址存放在栈中

d.实例变量:当你使用java关键字new的时候,系统在堆中开辟并不一定是连续的空间分配给变量,是根据零散的堆内存地址,通过哈希算法换算为一长串数字以表征这个变量在堆中的”物理位置”,实例变量的生命周期–当实例变量的引用丢失后,将被GC(垃圾回收器)列入可回收“名单”中,但并不是马上就释放堆中内存

e.局部变量: 由声明在某方法,或某代码段里(比如for循环),执行到它的时候在栈中开辟内存,当局部变量一但脱离作用域,内存立即释放


JAVA多态的实现原理

a.抽象的来讲,多态的意思就是同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用)

b.实现的原理是动态绑定,程序调用的方法在运行期才动态绑定,追溯源码可以发现,JVM 通过参数的自动转型来找到合适的办法。

动态绑定具体的调用过程为:

    1.首先会找到被调用方法所属类的全限定名(JVM管理下的一个重要的数据结构——方法表,方法表以数组的形式记录当前类及其所有父类的可见方法字节码在内存中的直接地址。)

    2.在此类的方法表中寻找被调用方法,如果找到,会将方法表中此方法的索引项记录到常量池中(这个过程叫常量池解析)(在jvm规范中,每个类型都有自己的常量池。常量池是某类型所用常量的一个有序集合,包括直接常量(基本类型,String)和对其他类型、字段、方法的符号引用。之所以是符号引用而不是像c语言那样,编译时直接指定其他类型,是因为java是动态绑定的,只有在运行时根据某些规则才能确定具体依赖的类型实例,这正是java实现多态的基础。),如果没有,编译失败。

    3.根据具体实例化的对象找到方法区中此对象的方法表,再找到方法表中的被调用方法,最后通过直接地址找到字节码所在的内存空间。

java对方法动态绑定的实现方法主要基于方法表,但是这里分两种调用方式invokevirtual和invokeinterface,即类引用调用和接口引用调用。类引用调用只需要修改方法表的指针就可以实现动态绑定(具有相同签名的方法,在父类、子类的方法表中具有相同的索引号),而接口引用调用需要扫描整个方法表才能实现动态绑定(因为,一个类可以实现多个接口,另外一个类可能只实现一个接口,无法具有相同的索引号。

intern

 

方式一:String a = “aaa” ;

方式二:String b = new String(“aaa”);

  • 两种方式都能创建字符串对象,但方式一要比方式二更优。
  • 因为字符串是保存在常量池中的,而通过new创建的对象会存放在堆内存中。

一:常量池中已经有字符串常量”aaa”

  • 通过方式一创建对象,程序运行时会在常量池中查找”aaa”字符串,将找到的”aaa”字符串的地址赋给a。
  • 通过方式二创建对象,无论常量池中有没有”aaa”字符串,程序都会在堆内存中开辟一片新空间存放新对象。

一:常量池中没有字符串常量”aaa”

  • 通过方式一创建对象,程序运行时会将”aaa”字符串放进常量池,再将其地址赋给a。
  • 通过方式二创建对象,程序会在堆内存中开辟一片新空间存放新对象,同时会将”aaa”字符串放入常量池,相当于创建了两个对象。

 

网络编程::

0. java Web开发流程

1、Servlet 
Servlet是用来处理客户端请求的动态资源,也就是当我们在浏览器中键入一个地址回车跳转后,请求就会被发送到对应的Servlet上进行处理。 

 .servlet的自动加载

      如果web服务器不重启的话,servlet对象会在第一次创建,而且要执行完构造方法和init方法之后才执行service方法,如果前两个方法逻辑复杂的话,首次访问就会很慢,

所以可以自动加载,也就是把创建对象的时机提前到web服务器启动的时候,这样可以加快初次访问的速递,在web.xml的servlet配置中添加<load-on-startup>1<load-on-startup>的配置就可以提前加载了,数值越低优先级越高。

Servlet的任务有:

  1. 接收请求数据:我们都知道客户端请求会被封装成HttpServletRequest对象,里面包含了请求头、参数等各种信息。
  2. 处理请求:通常我们会在service、doPost或者doGet方法进行接收参数,并且调用业务层(service)的方法来处理请求。
  3. 完成响应:处理完请求后,我们一般会转发(forward)或者重定向(redirect)到某个页面,转发是HttpServletRequest中的方法,重定向是HttpServletResponse中的方法,两者是有很大区别的。

Servlet的创建:Servlet可以在第一次接收请求时被创建,也可以在在服务器启动时就被创建,这需要在web.xml的< servlet>中添加一条配置信息 < load-on-startup>5< /load-on-startup>,当值为0或者大于0时,表示容器在应用启动时就加载这个servlet,当是一个负数时或者没有指定时,则指示容器在该servlet被请求时才加载。 
Servlet的生命周期方法:


 
  1. > void init(ServletConfig)

servlet的初始化方法,只在创建servlet实例时候调用一次,Servlet是单例的,整个服务器就只创建一个同类型Servlet


 
  1. > void service(ServletRequest,ServletResponse)

servlet的处理请求方法,在servle被请求时,会被马上调用,每处理一次请求,就会被调用一次。ServletRequest类为请求类,ServletResponse类为响应类


 
  1. > void destory()

servlet销毁之前执行的方法,只执行一次,用于释放servlet占有的资源,通常Servlet是没什么可要释放的,所以该方法一般都是空的

Servlet的其他重要方法:

> ServletConfig getServletConfig()

 

获取servlet的配置信息的方法,所谓的配置信息就是WEB-INF目录下的web.xml中的servlet标签里面的信息

> String getServletInfo()

 

获取servlet的信息方法

Servlet的配置:


 
  1. <servlet>
  2. <servlet-name>LoginServlet </servlet-name>
  3. <servlet-class>com.briup.estore.web.servlet.LoginServlet </servlet-class>
  4. </servlet>
  5. <servlet-mapping>
  6. <servlet-name>LoginServlet </servlet-name>
  7. <url-pattern>/login </url-pattern>
  8. </servlet-mapping>

2、Filter 
filter与servlet在很多的方面极其相似,但是也有不同,例如filter和servlet一样都又三个生命周期方法,同时他们在web.xml中的配置文件也是差不多的、 但是servlet主要负责处理请求,而filter主要负责拦截请求,和放行。 

filter四种拦截方式

  • REQUEST:直接访问目标资源时执行过滤器。包括:在地址栏中直接访问、表单提交、超链接、重定向,只要在地址栏中可以看到目标资源的路径,就是REQUEST;
  • FORWARD:转发访问执行过滤器。包括RequestDispatcher#forward()方法、< jsp:forward>标签都是转发访问;
  • INCLUDE:包含访问执行过滤器。包括RequestDispatcher#include()方法、< jsp:include>标签都是包含访问;
  • ERROR:当目标资源在web.xml中配置为< error-page>中时,并且真的出现了异常,转发到目标资源时,会执行过滤器。

url-mapping的写法 
匹配规则有三种:

  • 精确匹配 —— 如/foo.htm,只会匹配foo.htm这个URL
  • 路径匹配 —— 如/foo/*,会匹配以foo为前缀的URL
  • 后缀匹配 —— 如*.htm,会匹配所有以.htm为后缀的URL
  • < url-pattern>的其他写法,如/foo/ ,/.htm ,/foo 都是不对的。

执行filter的顺序 
如果有多个过滤器都匹配该请求,顺序决定于web.xml filter-mapping的顺序,在前面的先执行,后面的后执行 
3、Listener 
Listener就是监听器,我们在JavaSE开发或者Android开发时,经常会给按钮加监听器,当点击这个按钮就会触发监听事件,调用onClick方法,本质是方法回调。在JavaWeb的Listener也是这么个原理,但是它监听的内容不同,它可以监听Application、Session、Request对象,当这些对象发生变化就会调用对应的监听方法。 
应用域监听: 
Ø ServletContext(监听Application)

¨ 生命周期监听:ServletContextListener,它有两个方法,一个在出生时调用,一个在死亡时调用;


 
  1. void contextInitialized(ServletContextEvent sce):创建Servletcontext时
  2. void contextDestroyed (ServletContextEvent sce):销毁Servletcontext时

¨ 属性监听:ServletContextAttributeListener,它有三个方法,一个在添加属性时调用,一个在替换属性时调用,最后一个是在移除属性时调用。


 
  1. void attributeAdded(ServletContextAttributeEvent event):添加属性时;
  2. void attributeReplaced( ServletContextAttributeEvent event):替换属性时;
  3. void attributeRemoved( ServletContextAttributeEvent event):移除属性时;

Ø HttpSession(监听Session)

¨ 生命周期监听:HttpSessionListener,它有两个方法,一个在出生时调用,一个在死亡时调用;


 
  1. voidsessionCreated(HttpSessionEvent se):创建session时
  2. void sessionDestroyed(HttpSessionEvent se):销毁session时

¨ 属性监听:HttpSessioniAttributeListener,它有三个方法,一个在添加属性时调用,一个在替换属性时调用,最后一个是在移除属性时调用。


 
  1. void attributeAdded(HttpSessionBindingEvent event):添加属性时;
  2. void attributeReplaced( HttpSessionBindingEvent event):替换属性时
  3. void attributeRemoved( HttpSessionBindingEvent event):移除属性时

Ø ServletRequest(监听Request)

¨ 生命周期监听:ServletRequestListener,它有两个方法,一个在出生时调用,一个在死亡时调用;


 
  1. voidrequestInitialized(ServletRequestEvent sre):创建 request
  2. void requestDestroyed(ServletRequestEvent sre):销毁 request

¨ 属性监听:ServletRequestAttributeListener,它有三个方法,一个在添加属性时调用,一个在替换属性时调用,最后一个是在移除属性时调用。


 
  1. voidattributeAdded(ServletRequestAttributeEvent srae):添加属性时
  2. void attributeReplaced(ServletRequestAttributeEvent srae):替换属性时
  3. void attributeRemoved (ServletRequestAttributeEvent srae):移除属性时

感知Session监听: 
1:HttpSessionBindingListener监听 
⑴在需要监听的实体类实现HttpSessionBindingListener接口 
⑵重写valueBound()方法,这方法是在当该实体类被放到Session中时,触发该方法 
⑶重写valueUnbound()方法,这方法是在当该实体类从Session中被移除时,触发该方法 
2:HttpSessionActivationListener监听 
⑴在需要监听的实体类实现HttpSessionActivationListener接口 
⑵重写sessionWillPassivate()方法,这方法是在当该实体类被序列化时,触发该方法 
⑶重写sessionDidActivate()方法,这方法是在当该实体类被反序列化时,触发该方法

1.网络编程时的同步、异步、阻塞、非阻塞?

同步:函数调用在没得到结果之前,没有调用结果,不返回任何结果。
异步:函数调用在没得到结果之前,没有调用结果,返回状态信息。
阻塞:函数调用在没得到结果之前,当前线程挂起。得到结果后才返回。
非阻塞:函数调用在没得到结果之前,当前线程不会挂起,立即返回结果。

2.Java如何实现无阻塞方式的Socket编程?

NIO有效解决了多线程服务器存在的线程开销问题。

在NIO中使用多线程主要目的不是为了应对每个客户端请求而分配独立的服务线程,而是通过多线程充分利用多个CPU的处理能力和处理中的等待时间,达到提高服务能力的目的。

3.什么是java 的序列化(串行化)?

简单说就是为了保存在内存中的各种对象的状态(也就是实例变量,不是方法),

并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保存object states,但是Java给你提供一种应该比你自己好的保存对象状态的机制,那就是序列化。

4.什么情况下需要序列化?序列化的注意事项,如何实现java 序列化(串行化)?

· 当你想把的内存中的对象状态保存到一个文件中或者数据库中时候;

· 当你想用套接字在网络上传送对象的时候;

· 当你想通过RMI传输对象的时候;

序列化注意事项

1、如果子类实现Serializable接口而父类未实现时,父类不会被序列化,但此时父类必须有个无参构造方法,否则会抛InvalidClassException异常。

2、静态变量不会被序列化,那是类的“菜”,不是对象的。串行化保存的是对象的状态,即非静态的属性,即实例变量。不能保存类变量。

3、transient关键字修饰变量可以限制序列化。对于不需要或不应该保存的属性,应加上transient修饰符。要串行化的对象的类必须是公开的(public)。

4、虚拟机是否允许反序列化,不仅取决于类路径和功能代码是否一致,一个非常重要的一点是两个类的序列化 ID是否一致,就是 private static final long serialVersionUID = 1L。

5、Java 序列化机制为了节省磁盘空间,具有特定的存储规则,当写入文件的为同一对象时,并不会再将对象的内容进行存储,而只是再次存储一份引用。反序列化时,恢复引用关系。

6、序列化到同一个文件时,如第二次修改了相同对象属性值再次保存时候,虚拟机根据引用关系知道已经有一个相同对象已经写入文件,因此只保存第二次写的引用,所以读取时,都是第一次保存的对象。

5.java中有几种类型的流?JDK为每种类型的流提供了一些抽象类以供继承,请说出他们分别是哪些类?

JDK提供的流继承了四大类:

InputStream(字节输入流),OutputStream(字节输出流),Reader(字符输入流),Writer(字符输出流)。

按流向分类:

输入流: 程序可以从中读取数据的流。
输出流: 程序能向其中写入数据的流。

按数据传输单位分类:

字节流:以字节(8位二进制)为单位进行处理。主要用于读写诸如图像或声音的二进制数据。
字符流:以字符(16位二进制)为单位进行处理。
都是通过字节流的方式实现的。字符流是对字节流进行了封装,方便操作。在最底层,所有的输入输出都是字节形式的。
后缀是Stream是字节流,而后缀是Reader,Writer是字符流。

按功能分类:

节点流:从特定的地方读写的流类,如磁盘或者一块内存区域。
过滤流:使用节点流作为输入或输出。过滤流是使用一个已经存在的输入流或者输出流连接创建的。

6.用JAVA SOCKET 编程,读服务器几个 字符,再写入本地显示。

客户端向服务器端发送连接请求后,就被动地等待服务器的响应。

典型的TCP客户端要经过下面三步操作:

1、创建一个Socket实例:构造函数向指定的远程主机和端口建立一个TCP连接;
2、通过套接字的I/O流与服务端通信;
3、使用Socket类的close方法关闭连接。

服务端的工作是建立一个通信终端,并被动地等待客户端的连接。

典型的TCP服务端执行如下两步操作:

1、创建一个ServerSocket实例并指定本地端口,用来监听客户端在该端口发送的TCP连接请求;
2、重复执行:
1)调用ServerSocket的accept()方法以获取客户端连接,并通过其返回值创建一个Socket实例;
2)为返回的Socket实例开启新的线程,并使用返回的Socket实例的I/O流与客户端通信;
3)通信完成后,使用Socket类的close()方法关闭该客户端的套接字连接。

7.TCP/IP在连接时有几次握手?释放时有几次握手?

TCP三次握手连接的建立过程:

 

TCP四次挥手的释放过程:

50道Java线程面试题

  下面是Java线程相关的热门面试题,你可以用它来好好准备面试。

1) 什么是线程?

  线程是操作系统能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位。程序员可以通过它进行多处理器编程,你可以使用多线程对运算密集型任务提速。比如,如果一个线程完成一个任务要100毫秒,那么用十个线程完成改任务只需10毫秒。Java在语言层面对多线程提供了卓越的支持,它也是一个很好的卖点。欲了解更多详细信息请点击这里

2) 线程和进程有什么区别?

  线程是进程的子集,一个进程可以有很多线程,每条线程并行执行不同的任务。不同的进程使用不同的内存空间,而所有的线程共享一片相同的内存空间。别把它和栈内存搞混,每个线程都拥有单独的栈内存用来存储本地数据。更多详细信息请点击这里

3) 如何在Java中实现线程?

  在语言层面有两种方式。java.lang.Thread 类的实例就是一个线程但是它需要调用java.lang.Runnable接口来执行,由于线程类本身就是调用的Runnable接口所以你可以继承java.lang.Thread 类或者直接调用Runnable接口来重写run()方法实现线程。更多详细信息请点击这里.

4) 用Runnable还是Thread?

  这个问题是上题的后续,大家都知道我们可以通过继承Thread类或者调用Runnable接口来实现线程,问题是,那个方法更好呢?什么情况下使用它?这个问题很容易回答,如果你知道Java不支持类的多重继承,但允许你调用多个接口。所以如果你要继承其他类,当然是调用Runnable接口好了。更多详细信息请点击这里

6) Thread 类中的start() 和 run() 方法有什么区别?

  这个问题经常被问到,但还是能从此区分出面试者对Java线程模型的理解程度。start()方法被用来启动新创建的线程,而且start()内部调用了run()方法,这和直接调用run()方法的效果不一样。当你调用run()方法的时候,只会是在原来的线程中调用,没有新的线程启动,start()方法才会启动新线程。更多讨论请点击这里

7) Java中Runnable和Callable有什么不同?

  Runnable和Callable都代表那些要在不同的线程中执行的任务。Runnable从JDK1.0开始就有了,Callable是在JDK1.5增加的。它们的主要区别是Callable的 call() 方法可以返回值和抛出异常,而Runnable的run()方法没有这些功能。Callable可以返回装载有计算结果的Future对象。我的博客有更详细的说明。

8) Java中CyclicBarrier 和 CountDownLatch有什么不同?

  CyclicBarrier 和 CountDownLatch 都可以用来让一组线程等待其它线程。与 CyclicBarrier 不同的是,CountdownLatch 不能重新使用。点此查看更多信息和示例代码

9) Java内存模型是什么?

  Java内存模型规定和指引Java程序在不同的内存架构、CPU和操作系统间有确定性地行为。它在多线程的情况下尤其重要。Java内存模型对一个线程所做的变动能被其它线程可见提供了保证,它们之间是先行发生关系。这个关系定义了一些规则让程序员在并发编程时思路更清晰。比如,先行发生关系确保了:

  • 线程内的代码能够按先后顺序执行,这被称为程序次序规则。
  • 对于同一个锁,一个解锁操作一定要发生在时间上后发生的另一个锁定操作之前,也叫做管程锁定规则。
  • 前一个对volatile的写操作在后一个volatile的读操作之前,也叫volatile变量规则。
  • 一个线程内的任何操作必需在这个线程的start()调用之后,也叫作线程启动规则。
  • 一个线程的所有操作都会在线程终止之前,线程终止规则。
  • 一个对象的终结操作必需在这个对象构造完成之后,也叫对象终结规则。
  • 可传递性

  我强烈建议大家阅读《Java并发编程实践》第十六章来加深对Java内存模型的理解。

10) Java中的volatile 变量是什么?

  volatile是一个特殊的修饰符,只有成员变量才能使用它。在Java并发程序缺少同步类的情况下,多线程对成员变量的操作对其它线程是透明的。volatile变量可以保证下一个读取操作会在前一个写操作之后发生,就是上一题的volatile变量规则。点击这里查看更多volatile的相关内容。

11) 什么是线程安全?Vector是一个线程安全类吗? (详见这里)

  如果你的代码所在的进程中有多个线程在同时运行,而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的,而且其他的变量的值也和预期的是一样的,就是线程安全的。一个线程安全的计数器类的同一个实例对象在被多个线程使用的情况下也不会出现计算失误。很显然你可以将集合类分成两组,线程安全和非线程安全的。Vector 是用同步方法来实现线程安全的, 而和它相似的ArrayList不是线程安全的。

12) Java中什么是竞态条件? 举个例子说明。

  竞态条件会导致程序在并发情况下出现一些bugs。多线程对一些资源的竞争的时候就会产生竞态条件,如果首先要执行的程序竞争失败排到后面执行了,那么整个程序就会出现一些不确定的bugs。这种bugs很难发现而且会重复出现,因为线程间的随机竞争。一个例子就是无序处理,详见答案

13) Java中如何停止一个线程?

  Java提供了很丰富的API但没有为停止线程提供API。JDK 1.0本来有一些像stop(), suspend() 和 resume()的控制方法但是由于潜在的死锁威胁因此在后续的JDK版本中他们被弃用了,之后Java API的设计者就没有提供一个兼容且线程安全的方法来停止一个线程。当run() 或者 call() 方法执行完的时候线程会自动结束,如果要手动结束一个线程,你可以用volatile 布尔变量来退出run()方法的循环或者是取消任务来中断线程。点击这里查看示例代码。

在java中有以下3种方法可以终止正在运行的线程:

  1. 使用退出标志,使线程正常退出,也就是当run方法完成后线程终止。vialate,使用     while(violate)

 
  1. public volatile boolean flag = true;
  2. public void run() {
  3. System.out.println( "第" + Thread.currentThread().getName() + "个线程创建");
  4. try {
  5. Thread.sleep( 1000L);
  6. } catch (InterruptedException e) {
  7. e.printStackTrace();
  8. }
  9. //退出标志生效位置
  10. while (flag) {
  11. }
  12. System.out.println( "第" + Thread.currentThread().getName() + "个线程终止");

 

  1. 使用stop方法强行终止,但是不推荐这个方法,因为stop和suspend及resume一样都是过期作废的方法。
  2. 使用interrupt方法中断线程。
    
       
    1. try {
    2. sleep( 1000);
    3. } catch (InterruptedException e) {
    4. System.out.println( "week up from blcok...");
    5. stop = true; // 在异常处理代码中修改共享变量的状态
    6. }
    <p>&nbsp;</p>
    </li>
    

14) 一个线程运行时发生异常会怎样?

  这是我在一次面试中遇到的一个很刁钻的Java面试题,

简单的说,如果异常没有被捕获该线程将会停止执行。Thread.UncaughtExceptionHandler是用于处理未捕获异常造成线程突然中断情况的一个内嵌接口。

当一个未捕获异常将造成线程中断的时候JVM会使用Thread.getUncaughtExceptionHandler()来查询线程的UncaughtExceptionHandler并将线程和异常作为参数传递给handler的uncaughtException()方法进行处理。

所以这里存在两种情形: 
① 如果该异常被捕获或抛出,则程序继续运行。 
② 如果异常没有被捕获该线程将会停止执行。 
Thread.UncaughtExceptionHandler是用于处理未捕获异常造成线程突然中断情况的一个内嵌接口。当一个未捕获异常将造成线程中断的时候JVM会使用Thread.getUncaughtExceptionHandler()来查询线程的UncaughtExceptionHandler,并将线程和异常作为参数传递给handler的uncaughtException()方法进行处理。

15) 如何在两个线程间共享数据?

解决方案:

有两种方法来解决此类问题:

  • 将共享数据封装成另外一个对象中封装成另外一个对象中,然后将这个对象逐一传递给各个Runnable对象,每个线程对共享数据的操作方法也分配到那个对象身上完成,这样容易实现针对数据进行各个操作的互斥和通信
  • 将Runnable对象作为偶一个类的内部类,共享数据作为这个类的成员变量,每个线程对共享数据的操作方法也封装在外部类,以便实现对数据的各个操作的同步和互斥,作为内部类的各个Runnable对象调用外部类的这些方法。

16) Java中notify 和 notifyAll有什么区别?

  这又是一个刁钻的问题,因为多线程可以等待单监控锁,Java API 的设计人员提供了一些方法当等待条件改变的时候通知它们,但是这些方法没有完全实现。notify()方法不能唤醒某个具体的线程,唤醒哪个主要看其优先级,所以只有一个线程在等待的时候它才有用武之地。而notifyAll()唤醒所有线程并允许他们争夺锁确保了至少有一个线程能继续运行。我的博客有更详细的资料和示例代码。

17) 为什么wait, notify 和 notifyAll这些方法不在thread类里面?

  这是个设计相关的问题,它考察的是面试者对现有系统和一些普遍存在但看起来不合理的事物的看法。回答这些问题的时候,你要说明为什么把这些方法放在Object类里是有意义的,还有不把它放在Thread类里的原因。一个很明显的原因是JAVA提供的锁是对象级的而不是线程级的,每个对象都有锁,通过线程获得。如果线程需要等待某些锁那么调用对象中的wait()方法就有意义了。如果wait()方法定义在Thread类中,线程正在等待的是哪个锁就不明显了。简单的说,由于wait,notify和notifyAll都是锁级别的操作,所以把他们定义在Object类中因为锁属于对象。你也可以查看这篇文章了解更多。

18) 什么是ThreadLocal变量?

  ThreadLocal是Java里一种特殊的变量。每个线程都有一个ThreadLocal就是每个线程都拥有了自己独立的一个变量,竞争条件被彻底消除了。它是为创建代价高昂的对象获取线程安全的好方法,比如你可以用ThreadLocal让SimpleDateFormat变成线程安全的,因为那个类创建代价高昂且每次调用都需要创建不同的实例所以不值得在局部范围使用它,如果为每个线程提供一个自己独有的变量拷贝,将大大提高效率。首先,通过复用减少了代价高昂的对象的创建个数。其次,你在没有使用高代价的同步或者不变性的情况下获得了线程安全。线程局部变量的另一个不错的例子是ThreadLocalRandom类,它在多线程环境中减少了创建代价高昂的Random对象的个数。查看答案了解更多。

19) 什么是FutureTask?

  在Java并发程序中FutureTask表示一个可以取消的异步运算。它有启动和取消运算、查询运算是否完成和取回运算结果等方法。只有当运算完成的时候结果才能取回,如果运算尚未完成get方法将会阻塞。一个FutureTask对象可以对调用了Callable和Runnable的对象进行包装,由于FutureTask也是调用了Runnable接口所以它可以提交给Executor来执行。

20) Java中interrupted 和 isInterruptedd方法的区别?

  interrupted() 和 isInterrupted()的主要区别是前者会将中断状态清除而后者不会。Java多线程的中断机制是用内部标识来实现的,调用Thread.interrupt()来中断一个线程就会设置中断标识为true。当中断线程调用静态方法Thread.interrupted()来检查中断状态时,中断状态会被清零。而非静态方法isInterrupted()用来查询其它线程的中断状态且不会改变中断状态标识。简单的说就是任何抛出InterruptedException异常的方法都会将中断状态清零。无论如何,一个线程的中断状态有有可能被其它线程调用中断来改变。

  1. interrupted()方法作用于当前线程,isInterrupted()是作用于调用改方法的线程对象所对应线程。eg:可以在线程A中去调用线程B的isInterrupted()
  2. 这两个方法都会调用同一个方法而参数不同一个是true一个是false

 

1.线程为什么会抛出InterruptedException?

然而;如果线程处于wait,sleep,join三个方法时候,则会抛出InterruptedException。

一般来说,有三种做法:

(1)不做处理,直接抛出

直接抛出并不会影响线程的状态,被中断的线程还是会提前结束中断状态,继续执行

(2)捕获异常,再次调用interrupt方法,将中断状态重新设置为true;Thread.currentThread().interrupt();

这样就保留了线程原有的状态,让线程继续等待下去
 

(3)捕获异常,不处理;(不推荐)

3.正常运行的线程如何对中断状态做处理

由1我们知道,正常运行的线程在调用了interrupt方法后将中断状态设置为true,但此时线程的执行并未收到影响,如果要对线程的运行采取一些干预措施,则需要使用isInterrupt方法;还有个比较危险的方法 interrrupted(),只清除中断状态

注意:

一旦方法抛出InterruptedException,当前调用该方法的线程的中断状态就会被jvm自动清除了,就是说我们调用该线程的isInterrupted 方法时是返回false。如果你想保持中断状态,可以再次调用interrupt方法设置中断状态。

如:if(thread.isInterrupt()){

//do Somethidng}

 

21) 为什么wait和notify方法要在同步块中调用?

  主要是因为Java API强制要求这样做,如果你不这么做,你的代码会抛出IllegalMonitorStateException异常。还有一个原因是为了避免wait和notify之间产生竞态条件。

官方的定义是如果程序运行顺序的改变会影响最终结果,这就是一个竞态条件(race condition).

22) 为什么你应该在循环中检查等待条件?即在while中调用wait()

  处于等待状态的线程可能会收到错误警报和伪唤醒,如果不在循环中检查等待条件,程序就会在没有满足结束条件的情况下退出。因此,当一个等待线程醒来时,不能认为它原来的等待状态仍然是有效的,在notify()方法调用之后和等待线程醒来之前这段时间它可能会改变。这就是在循环中使用wait()方法效果更好的原因,你可以在Eclipse中创建模板调用wait和notify试一试。如果你想了解更多关于这个问题的内容,我推荐你阅读《Effective Java》这本书中的线程和同步章节。

23) Java中的同步集合与并发集合有什么区别?

  同步集合与并发集合都为多线程和并发提供了合适的线程安全的集合,不过并发集合的可扩展性更高。在Java1.5之前程序员们只有同步集合来用且在多线程并发的时候会导致争用,阻碍了系统的扩展性。Java5介绍了并发集合像ConcurrentHashMap,不仅提供线程安全还用锁分离和内部分区等现代技术提高了可扩展性。更多内容详见答案

  简单来说,HashMap由数组+链表组成的,数组是HashMap的主体,链表则是主要为了解决哈希冲突而存在的,如果定位到的数组位置不含链表(当前entry的next指向null),那么对于查找,添加等操作很快,仅需一次寻址即可;如果定位到的数组包含链表,对于添加操作,其时间复杂度为O(n),首先遍历链表,存在即覆盖,否则新增;对于查找操作来讲,仍需遍历链表,然后通过key对象的equals方法逐一比对查找。所以,性能考虑,HashMap中的链表出现越少,性能才会越好。

 

ConcurrentHashMap:

ConcurrentHashMap中的分段锁称为Segment,它即类似于HashMap(JDK7与JDK8中HashMap的实现)的结构,即内部拥有一个Entry数组,数组中的每个元素又是一个链表;同时又是一个ReentrantLock(Segment继承了ReentrantLock)。ConcurrentHashMap中的HashEntry相对于HashMap中的Entry有一定的差异性:HashEntry中的value以及next都被volatile修饰,这样在多线程读写过程中能够保持它们的可见性,

CocurrentHashMap的操作

  • Segment的get操作是不需要加锁的。因为volatile修饰的变量保证了线程之间的可见性
  • Segment的put操作是需要加锁的,在插入时会先判断Segment里的HashEntry数组是否会超过容量(threshold),如果超过需要对数组扩容,翻一倍。然后在新的数组中重新hash,为了高效,CocurrentHashMap只会对需要扩容的单个Segment进行扩容
  • CocurrentHashMap获取size的时候要统计Segments中的HashEntry的和,如果不对他们都加锁的话,无法避免数据的修改造成的错误,但是如果都加锁的话,效率又很低。所以CoccurentHashMap在实现的时候,巧妙地利用了在累加过程中发生变化的几率很小的客观条件,在获取count时,不加锁的计算两次,如果两次不相同,在采用加锁的计算方法。采用了一个高效率的剪枝防止很大概率地减少了不必要额加锁。
  • ConcurrentHashMap的Put操作

    <p>由于put方法里需要对共享变量进行写入操作,所以为了线程安全,在操作共享变量时必须得加锁。Put方法首先定位到Segment,然后在Segment里进行插入操作。插入操作需要经历两个步骤,第一步判断是否需要对Segment里的HashEntry数组进行扩容,第二步定位添加元素的位置然后放在HashEntry数组里。</p>
    
    <p><strong>是否需要扩容?</strong>在插入元素前会先判断Segment里的HashEntry数组是否超过容量(threshold),如果超过阀值,数组进行扩容。值得一提的是,Segment的扩容判断比HashMap更恰当,因为HashMap是在插入元素后判断元素是否已经到达容量的,如果到达了就进行扩容,但是很有可能扩容之后没有新元素插入,这时HashMap就进行了一次无效的扩容。</p>
    
    <p><strong>如何扩容?</strong>扩容的时候首先会创建一个两倍于原容量的数组,然后将原数组里的元素进行再hash后插入到新的数组里。<strong>为了高效ConcurrentHashMap不会对整个容器进行扩容,而只对某个segment进行扩容。</strong></p>
    
    <p><strong>ConcurrentHashMap的size操作</strong>&nbsp;<br>
    如果我们要统计整个ConcurrentHashMap里元素的大小,就必须统计所有Segment里元素的大小后求和。Segment里的全局变量count是一个volatile变量,那么在多线程场景下,我们是不是直接把所有Segment的count相加就可以得到整个ConcurrentHashMap大小了呢?不是的,<strong>虽然相加时可以获取每个Segment的count的最新值,但是拿到之后可能累加前使用的count发生了变化,那么统计结果就不准了。</strong>所以最安全的做法,是在统计size的时候把所有Segment的put,remove和clean方法全部锁住,但是这种做法显然非常低效。&nbsp;<br>
    因为在累加count操作过程中,之前累加过的count发生变化的几率非常小,所以<strong>ConcurrentHashMap的做法是先尝试2次通过不锁住Segment的方式来统计各个Segment大小,如果统计的过程中,容器的count发生了变化,则再采用加锁的方式来统计所有Segment的大小。</strong>&nbsp;<br>
    那么ConcurrentHashMap是<strong>如何判断在统计的时候容器是否发生了变化呢?使用modCount变量,在put , remove和clean方法里操作元素前都会将变量modCount进行加1,那么在统计size前后比较modCount是否发生变化,从而得知容器的大小是否发生变化。</strong></p>
    </li>
    <li>
    <p>&nbsp;</p>
    </li>
    

24) Java中堆和栈有什么不同?

  为什么把这个问题归类在多线程和并发面试题里?因为栈是一块和线程紧密相关的内存区域。每个线程都有自己的栈内存,用于存储本地变量,方法参数和栈调用,一个线程中存储的变量对其它线程是不可见的。而堆是所有线程共享的一片公用内存区域。对象都在堆里创建,为了提升效率线程会从堆中弄一个缓存到自己的栈,如果多个线程使用该变量就可能引发问题,这时volatile 变量就可以发挥作用了,它要求线程从主存中读取变量的值。 更多内容详见答案

25) 什么是线程池? 为什么要使用它?

  创建线程要花费昂贵的资源和时间,如果任务来了才创建线程那么响应时间会变长,而且一个进程能创建的线程数有限。为了避免这些问题,在程序启动的时候就创建若干线程来响应处理,它们被称为线程池,里面的线程叫工作线程。从JDK1.5开始,Java API提供了Executor框架让你可以创建不同的线程池。比如单线程池,每次处理一个任务;数目固定的线程池或者是缓存线程池(一个适合很多生存期短的任务的程序的可扩展线程池)。更多内容详见这篇文章

26) 如何写代码来解决生产者消费者问题?

  在现实中你解决的许多线程问题都属于生产者消费者模型,就是一个线程生产任务供其它线程进行消费,你必须知道怎么进行线程间通信来解决这个问题。比较低级的办法是用wait和notify来解决这个问题,比较赞的办法是用Semaphore 或者 BlockingQueue来实现生产者消费者模型,这篇教程有实现它。

27) 如何避免死锁?

  Java多线程中的死锁 死锁是指两个或两个以上的进程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。这是一个严重的问题,因为死锁会让你的程序挂起无法完成任务,死锁的发生必须满足以下四个条件:

  • 互斥条件:一个资源每次只能被一个进程使用。
  • 请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放。
  • 不剥夺条件:进程已获得的资源,在末使用完之前,不能强行剥夺。
  • 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

避免死锁最简单的方法就是阻止循环等待条件,将系统中所有的资源设置标志位、排序,规定所有的进程申请资源必须以一定的顺序(升序或降序)做操作来避免死锁。这篇教程有代码示例和避免死锁的讨论细节。

28) Java中活锁和死锁有什么区别?

  这是上题的扩展,活锁和死锁类似,不同之处在于处于活锁的线程或进程的状态是不断改变的,活锁可以认为是一种特殊的饥饿。一个现实的活锁例子是两个人在狭小的走廊碰到,两个人都试着避让对方好让彼此通过,但是因为避让的方向都一样导致最后谁都不能通过走廊。简单的说就是,活锁和死锁的主要区别是前者进程的状态可以改变但是却不能继续执行。

29) 怎么检测一个线程是否拥有锁?

  我一直不知道我们竟然可以检测一个线程是否拥有锁,直到我参加了一次电话面试。在java.lang.Thread中有一个方法叫holdsLock(),它返回true如果当且仅当当前线程拥有某个具体对象的锁。你可以查看这篇文章了解更多。

30) 你如何在Java中获取线程堆栈?

  对于不同的操作系统,有多种方法来获得Java进程的线程堆栈。当你获取线程堆栈时,JVM会把所有线程的状态存到日志文件或者输出到控制台。在Windows你可以使用Ctrl + Break组合键来获取线程堆栈,Linux下用kill -3命令。你也可以用jstack这个工具来获取,它对线程id进行操作,你可以用jps这个工具找到id。

31)  JVM中哪个参数是用来控制线程的栈堆栈小的

  这个问题很简单, -Xss参数用来控制线程的堆栈大小。你可以查看JVM配置列表来了解这个参数的更多信息。

32) Java中synchronized 和 ReentrantLock 有什么不同?

  Java在过去很长一段时间只能通过synchronized关键字来实现互斥,它有一些缺点。比如你不能扩展锁之外的方法或者块边界,尝试获取锁时不能中途取消等。Java 5 通过Lock接口提供了更复杂的控制来解决这些问题。 ReentrantLock 类实现了 Lock,它拥有与 synchronized 相同的并发性和内存语义且它还具有可扩展性。你可以查看这篇文章了解更多

33) 有三个线程T1,T2,T3,怎么确保它们按顺序执行?

  在多线程中有多种方法让线程按特定顺序执行,你可以用线程类的join()方法在一个线程中启动另一个线程,另外一个线程完成该线程继续执行。为了确保三个线程的顺序你应该先启动最后一个(T3调用T2,T2调用T1),这样T1就会先完成而T3最后完成。你可以查看这篇文章了解更多。

34) Thread类中的yield方法有什么作用?

  Yield方法可以暂停当前正在执行的线程对象,让其它有相同优先级的线程执行。它是一个静态方法而且只保证当前线程放弃CPU占用而不能保证使其它线程一定能占用CPU,执行yield()的线程有可能在进入到暂停状态后马上又被执行。点击这里查看更多yield方法的相关内容。

35) Java中ConcurrentHashMap的并发度是什么?

  ConcurrentHashMap把实际map划分成若干部分来实现它的可扩展性和线程安全。这种划分是使用并发度获得的,它是ConcurrentHashMap类构造函数的一个可选参数,默认值为16,这样在多线程情况下就能避免争用。欲了解更多并发度和内部大小调整请阅读我的文章How ConcurrentHashMap works in Java

36) Java中Semaphore是什么?

  Java中的Semaphore是一种新的同步类,它是一个计数信号。从概念上讲,从概念上讲,信号量维护了一个许可集合。如有必要,在许可可用前会阻塞每一个 acquire(),然后再获取该许可。每个 release()添加一个许可,从而可能释放一个正在阻塞的获取者。但是,不使用实际的许可对象,Semaphore只对可用许可的号码进行计数,并采取相应的行动。信号量常常用于多线程的代码中,比如数据库连接池。更多详细信息请点击这里

37)如果你提交任务时,线程池队列已满。会时发会生什么?

  这个问题问得很狡猾,许多程序员会认为该任务会阻塞直到线程池队列有空位。事实上如果一个任务不能被调度执行那么ThreadPoolExecutor’s submit()方法将会抛出一个RejectedExecutionException异常。

38) Java线程池中submit() 和 execute()方法有什么区别?

  两个方法都可以向线程池提交任务,execute()方法的返回类型是void,它定义在Executor接口中, 而submit()方法可以返回持有计算结果的Future对象,它定义在ExecutorService接口中,它扩展了Executor接口,其它线程池类像ThreadPoolExecutor和ScheduledThreadPoolExecutor都有这些方法。更多详细信息请点击这里

39) 什么是阻塞式方法?

  阻塞式方法是指程序会一直等待该方法完成期间不做其他事情,ServerSocket的accept()方法就是一直等待客户端连接。这里的阻塞是指调用结果返回之前,当前线程会被挂起,直到得到结果之后才会返回。此外,还有异步和非阻塞式方法在任务完成前就返回。更多详细信息请点击这里

40) Swing是线程安全的吗? 为什么?

  你可以很肯定的给出回答,Swing不是线程安全的,但是你应该解释这么回答的原因即便面试官没有问你为什么。当我们说swing不是线程安全的常常提到它的组件,这些组件不能在多线程中进行修改,所有对GUI组件的更新都要在AWT线程中完成,而Swing提供了同步和异步两种回调方法来进行更新。点击这里查看更多swing和线程安全的相关内容。

41) Java中invokeAndWait 和 invokeLater有什么区别?

  这两个方法是Swing API 提供给Java开发者用来从当前线程而不是事件派发线程更新GUI组件用的。InvokeAndWait()同步更新GUI组件,比如一个进度条,一旦进度更新了,进度条也要做出相应改变。如果进度被多个线程跟踪,那么就调用invokeAndWait()方法请求事件派发线程对组件进行相应更新。而invokeLater()方法是异步调用更新组件的。更多详细信息请点击这里

42) Swing API中那些方法是线程安全的?

  这个问题又提到了swing和线程安全,虽然组件不是线程安全的但是有一些方法是可以被多线程安全调用的,比如repaint(), revalidate()。 JTextComponent的setText()方法和JTextArea的insert() 和 append() 方法也是线程安全的。

43) 如何在Java中创建Immutable对象?

  这个问题看起来和多线程没什么关系, 但不变性有助于简化已经很复杂的并发程序。Immutable对象可以在没有同步的情况下共享,降低了对该对象进行并发访问时的同步化开销。可是Java没有@Immutable这个注解符,要创建不可变类,要实现下面几个步骤:通过构造方法初始化所有成员、对变量不要提供setter方法、将所有的成员声明为私有的,这样就不允许直接访问这些成员、在getter方法中,不要直接返回对象本身,而是克隆对象,并返回对象的拷贝。我的文章how to make an object Immutable in Java有详细的教程,看完你可以充满自信。

44) Java中的ReadWriteLock是什么?

  一般而言,读写锁是用来提升并发程序性能的锁分离技术的成果。Java中的ReadWriteLock是Java 5 中新增的一个接口,一个ReadWriteLock维护一对关联的锁,一个用于只读操作一个用于写。在没有写线程的情况下一个读锁可能会同时被多个读线程持有。写锁是独占的,你可以使用JDK中的ReentrantReadWriteLock来实现这个规则,它最多支持65535个写锁和65535个读锁。

45) 多线程中的忙循环是什么?

  忙循环就是程序员用循环让一个线程等待,不像传统方法wait(), sleep() 或 yield() 它们都放弃了CPU控制,而忙循环不会放弃CPU,它就是在运行一个空循环。这么做的目的是为了保留CPU缓存,在多核系统中,一个等待线程醒来的时候可能会在另一个内核运行,这样会重建缓存。为了避免重建缓存和减少等待重建的时间就可以使用它了。你可以查看这篇文章获得更多信息。

46)volatile 变量和 atomic 变量有什么不同?

  这是个有趣的问题。首先,volatile 变量和 atomic 变量看起来很像,但功能却不一样。Volatile变量可以确保先行关系,即写操作会发生在后续的读操作之前, 但它并不能保证原子性。例如用volatile修饰count变量那么 count++ 操作就不是原子性的。而AtomicInteger类提供的atomic方法可以让这种操作具有原子性如getAndIncrement()方法会原子性的进行增量操作把当前值加一,其它数据类型和引用变量也可以进行相似操作。

47) 如果同步块内的线程抛出异常会发生什么?

  这个问题坑了很多Java程序员,若你能想到锁是否释放这条线索来回答还有点希望答对。无论你的同步块是正常还是异常退出的,里面的线程都会释放锁,所以对比锁接口我更喜欢同步块,因为它不用我花费精力去释放锁,该功能可以在finally block里释放锁实现。

48) 单例模式的双检锁是什么?

  这个问题在Java面试中经常被问到,但是面试官对回答此问题的满意度仅为50%。一半的人写不出双检锁还有一半的人说不出它的隐患和Java1.5是如何对它修正的。它其实是一个用来创建线程安全的单例的老方法,当单例实例第一次被创建时它试图用单个锁进行性能优化,但是由于太过于复杂在JDK1.4中它是失败的,我个人也不喜欢它。无论如何,即便你也不喜欢它但是还是要了解一下,因为它经常被问到。你可以查看how double checked locking on Singleton works这篇文章获得更多信息。

49) 如何在Java中创建线程安全的Singleton?

  这是上面那个问题的后续,如果你不喜欢双检锁而面试官问了创建Singleton类的替代方法,你可以利用JVM的类加载和静态变量初始化特征来创建Singleton实例,或者是利用枚举类型来创建Singleton,我很喜欢用这种方法。你可以查看这篇文章获得更多信息。

50) 写出3条你遵循的多线程最佳实践

  这种问题我最喜欢了,我相信你在写并发代码来提升性能的时候也会遵循某些最佳实践。以下三条最佳实践我觉得大多数Java程序员都应该遵循:

  • 给你的线程起个有意义的名字。 这样可以方便找bug或追踪。OrderProcessor, QuoteProcessor or TradeProcessor 这种名字比 Thread-1. Thread-2 and Thread-3 好多了,给线程起一个和它要完成的任务相关的名字,所有的主要框架甚至JDK都遵循这个最佳实践。
  • 避免锁定和缩小同步的范围 锁花费的代价高昂且上下文切换更耗费时间空间,试试最低限度的使用同步和锁,缩小临界区。因此相对于同步方法我更喜欢同步块,它给我拥有对锁的绝对控制权。
  • 多用同步类少用wait 和 notify 首先,CountDownLatch, Semaphore, CyclicBarrier 和 Exchanger 这些同步类简化了编码操作,而用wait和notify很难实现对复杂控制流的控制。其次,这些类是由最好的企业编写和维护在后续的JDK中它们还会不断优化和完善,使用这些更高等级的同步工具你的程序可以不费吹灰之力获得优化。
  • 多用并发集合少用同步集合 这是另外一个容易遵循且受益巨大的最佳实践,并发集合比同步集合的可扩展性更好,所以在并发编程时使用并发集合效果更好。如果下一次你需要用到map,你应该首先想到用ConcurrentHashMap。我的文章Java并发集合有更详细的说明。

51) 如何强制启动一个线程?

  这个问题就像是如何强制进行Java垃圾回收,目前还没有觉得方法,虽然你可以使用System.gc()来进行垃圾回收,但是不保证能成功。在Java里面没有办法强制启动一个线程,它是被线程调度器控制着且Java没有公布相关的API。

52) Java中的fork join框架是什么?

  fork join框架是JDK7中出现的一款高效的工具,Java开发人员可以通过它充分利用现代服务器上的多处理器。它是专门为了那些可以递归划分成许多子模块设计的,目的是将所有可用的处理能力用来提升程序的性能。fork join框架一个巨大的优势是它使用了工作窃取算法,可以完成更多任务的工作线程可以从其它线程中窃取任务来执行。你可以查看这篇文章获得更多信息。

53) Java多线程中调用wait() 和 sleep()方法有什么不同?

  Java程序中wait 和 sleep都会造成某种形式的暂停,它们可以满足不同的需要。wait()方法用于线程间通信,如果等待条件为真且其它线程被唤醒时它会释放锁,而sleep()方法仅仅释放CPU资源或者让当前线程停止执行一段时间,但不会释放锁。你可以查看这篇文章获得更多信息。

 

java Web面试题

1、Servlet 的生命周期,并说出 Servlet 与 CGI 的区别

Web 容器加载 Servlet 并将其实例化后,Servlet 生命周期开始,容器运行其 init 方法进行 Servlet 的初始化,请求到达时运行其 service 方法,service 方法自动派遣,运行请求的 doXXX 方法(doGet、doPost),当服务器决定将实例销毁的时候调用其 Destroy 方法。与 CGI 的区别在于,Servlet 处于服务器进程中,它通过多线程方式运行其 service 方法,一个实例可以运行多个请求,并且其实例一般不会销毁,而 CGI 对每个请求都产生新的进程,服务完成后就销毁,所以效率上低于 Servlet。

Servlet的生命周期分为5个阶段:
实例化:Servlet容器创建Servlet类的实例。
初始化:该容器调用init()方法,通常会申请资源。
服务:由容器调用service()方法,(也就是doGet()和doPost())。
破坏:在释放Servlet实例之前调用destroy()方法,通常会释放资源。
不可用:释放内存的实例。

 

概括来讲,Servlet可以完成和CGI相同的功能。 

CGI(Common Gateway Interface通用网关接口)程序来实现数据在Web上的传输,使用的是如Perl这样的语言编写的,它对于客户端作出的每个请求,必须创建CGI程序的一个新实例,这样占用大量的内存资源。由此才引入了Servlet技术。

Servlet是一个用java编写的应用程序,在服务器上运行,处理请求信息并将其发送到客户端。对于客户端的请求,只需要创建Servlet的实例一次,因此节省了大量的内存资源。Servlet在初始化后就保留在内存中,因此每次作出请求时无需加载。

 


  CGI应用开发比较困难,因为它要求程序员有处理参数传递的知识,这不是一种通用的技能。CGI不可移植,为某一特定平台编写的CGI应用只能运行于这一环境中。每一个CGI应用存在于一个由客户端请求激活的进程中,并且在请求被服务后被卸载。这种模式将引起很高的内存、CPU开销,而且在同一进程中不能服务多个客户。 

  Servlet提供了Java应用程序的所有优势——可移植、稳健、易开发。使用Servlet Tag技术,Servlet能够生成嵌于静态HTML页面中的动态内容。 

  Servlet对CGI的最主要优势在于一个Servlet被客户端发送的第一个请求激活,然后它将继续运行于后台,等待以后的请求。每个请求将生成一个新的线程,而不是一个完整的进程。多个客户能够在同一个进程中同时得到服务。一般来说,Servlet进程只是在Web Server卸载时被卸载。

2、forward 与 redirect 的区别

用户向服务器发送了一次HTTP请求,该请求可能会经过多个信息资源处理以后才返回给用户,各个信息资源使用请求转发机制相互转发请求,但是用户是感觉不到请求转发的。根据转发方式的不同,可以区分为直接请求转发(Forward)和间接请求转发(Redirect)

 Forward和Redirect代表了两种请求转发方式:直接转发和间接转发。

   直接转发方式(Forward),客户端和浏览器只发出一次请求,Servlet、HTML、JSP或其它信息资源,由第二个信息资源响应该请求,在请求对象request中,保存的对象对于每个信息资源是共享的。

  间接转发方式(Redirect)实际是两次HTTP请求,服务器端在响应第一次请求的时候,让浏览器再向另外一个URL发出请求,从而达到转发的目的。

举个通俗的例子:

  直接转发就相当于:“A找B借钱,B说没有,B去找C借,借到借不到都会把消息传递给A”;

  间接转发就相当于:"A找B借钱,B说没有,让A去找C借"。

forward 是控制权的转向,是服务器请求资源,服务器直接请求目标地址的 URL,把那个 URL 的响应内容读取过来,然后把这些内容再发给浏览器。浏览器不知道服务器发送的内容是哪儿来的,所以它的地址还是原来的地址。redirect 就是服务器端根据逻辑,发送一个状态码,告诉浏览器去请求一个新的地址,浏览器地址栏上显示的是新的请求地址。forward 更高效。有些情况下,如果需要使用其它服务器上的资源,则必须使用 redirect

 

3、JSP 中动态 include 与静态 include 的区别

动态 include 用 jsp:include 动作实现:<jsp:include page="test.jsjp" flush="true"/>,它总是检查所包含文件中的变化,适用于包含动态页面,并且可以带参数;静态 include 用 include 伪代码实现,它不会检查所含文件的变化,适用于包含静态页面:<%@ include file="test.html" %>

 

JSP中的include的两种用法

1.两种用法

<@inlcude file =”header.jsp”/>

此时引入的是静态的jsp文件,它将引入的jsp中的源代码原封不动地附加到当前文件中

<jsp:include page=”/user/test”flush=”true”/>

此时引入执行页面或生成的应答文本.jsp:include标签导入一个重用文件的时候,这个文件是经过编译的,通俗点说就是附加这个要导入文件经过编译后的效果,所以可以含有与当前jsp程序中重复的内容,因为在附加过来之前就会被解析掉。其中flush 表示在读入包含内容之前是否清空任何现有的缓冲区。

4、JSP 有哪些内置对象,作用是什么

request:同 Servlet 里的request

response:同 Servlet 里的response

session:同 request.getSession()

application:同 request.getServletContext

out:同 response.getWriter()

config:同 Servelt 的 init 方法里的 ServletConfig 参数

page:表示该页面产生的一个 Servlet 实例

exception:针对错误网页,未捕捉的除外

 

5、JSP 的常用指令

<%@ page language="java" pageEncoding="utf-8" contentType="text/html;charset=utf-8" %>

<%@ include file="test.html" %>

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/fmt" %>

 

6、JSP 有哪些动作,分别是什么

JSP 共有以下 6 种动作

jsp:include 在页面被请求时引用一个文件

jsp:useBean 寻找或实例化一个 JavaBean

jsp:setProperty 设置 JavaBean 的属性

jsjp:getProperty 输出某个 JavaBean 的属性

jsp:forward 转发

jsp:plugin 根据浏览器类型为 Java 插件生成 object 标记

 

7、GET 与 POST 的区别

form 中的 get 和 post 方法,在数据传输过程中分别对应了 http 协议中的  GET 与 POST 方法。

GET 是用来从服务器上获取数据,而 POST 是用来向服务器上传数据

GET 将表单中数据按 variable=value 的形式,添加到 action 所指向的 URL 后面,两者使用“?”连接,而多个变量之间使用“&”连接;POST 是将表单中的数据放在 form 的数据体中,按照变量和值相对应的方式,传递到 action 所指向的 URL

GET 是不安全的,因为在传输过程,数据被放在请求的 URL 中;POST 的所有操作对用户来说是不可见的

GET传输的数据量小,这主要是因为受 URL 长度限制;POST 可以传输大量的数据,所以上传文件只能使用 POST

GET 限制 form 表单的数据集必须为 ASCII 字符,而 POST 支持整个 ISO10646 字符集

GET 是 form 的默认方法

 

8、常用的 web 容器和开发工具

最常用的容器:tomcat、weblogic

开发工具:eclipse、jbuilder、ItelliJ IDEA

 

9、Web Application 的基本目录结构

webapps

    application

        jsp 页面

        WEB-INF

            classes

            lib

            web.xml

            jsp 页面

        META-INF

 

10、JSP 和 Servlet 有哪些相同点和不同点,它们之间的联系是什么

JSP 是 Servlet 技术的扩展,本质上是 Servlet 的简易方式,更强调应用的视图表达。JSP 编译后是“Servlet 类”。Servlet 和 JSP 最主要的不同点在于,Servlet 的应用逻辑是在 Java 文件中,并且完全从表示层中的 HTML 里分离开来。而 JSP 的情况是 Java 和 HTML 可以组合成一个扩展名为 .jsp 的文件。JSP 侧重于视图,Servlet 主要用于控制逻辑

 

11、JSP 的四种数据共享范围

pageContext 是代表与一个页面相关的对象和属性。一个页面由一个编译好的 Servlet 类(可以带有任何的 include 指令,没有 include 动作)表示。这既包括 Servlet 又包括被编译成 Servlet 的 JSP 页面

Request 是代码 web 客户机发出的一个请求相关的对象和属性。一个请求可能跨越多个页面,涉及多个 web 组件(由于 forward 指令和 include 动作的关系)

Session 是代表与用于某个 web 客户机的一个用户体验相关的对象和属性。一个 web 会话可以也经常或跨越多个客户机请求

Application 是代表与整个 web 应用程序相关的对象和属性。这实质上是跨越整个 web 应用程序,包括多个页面、请求和会话的一个全局作用域

 

12、对 MVC 的理解,MVC 有什么优缺点,结合Struts,说明在一个 Web 应用中如何去使用

基于 Java 的 Web 应用系统采用 MVC 架构模式,即 model(模型)、view(视图)、control(控制器)分离设计;这是目前 Web 应用服务系统的主流设计方向

MVC 设计模式:应用观察者模式的框架模式

model:处理业务逻辑的模块,每一种处理一个模块(模型,操作数据的业务处理层,并独立于表现层)

view:负责页面显示,显示 model 处理结果给用户,主要实现数据到页面转换过程(视图,通过客户端数据类型显示数据,并回显模型层的执行结果)

control:负责请求分发,把 form 数据传递给 model 处理,把处理结果的数据传递给 view 显示(控制器,视图层和模型层的桥梁,控制数据的流向,接受视图发出的事件,并重绘视图)

JSP + Servlet + JavaBean,以控制器为核心,JSP 只负责显示和收集数据,Servlet,连接视图和模型,将视图层数据发送给模型层,JavaBean,分为业务类和数据实体,业务类处理业务数据,数据实体承载数据,基本上大多数的项目都是使用这种 MVC 的实现模式

 

13、会话跟踪技术

Cookie、URL 重写、设置表单隐藏域

 

14、过滤器有哪些作用

 Filter也称之为过滤器,它是Servlet技术中最激动人心的技术,WEB开发人员通过Filter技术,对web服务器管理的所有web资源:例如Jsp, Servlet, 静态图片文件或静态 html 文件等进行拦截,从而实现一些特殊的功能。例如实现URL级别的权限访问控制、过滤敏感词汇、压缩响应信息等一些高级功能。
  Servlet API中提供了一个Filter接口,开发web应用时,如果编写的Java类实现了这个接口,则把这个java类称之为过滤器Filter。通过Filter技术,开发人员可以实现用户在访问某个目标资源之前,对访问的请求和响应进行拦截,如下所示:

Filter开发步骤

  Filter开发分为二个步骤:

  1. 编写java类实现Filter接口,并实现其doFilter方法。
  2. 在 web.xml 文件中使用<filter>和<filter-mapping>元素对编写的filter类进行注册,并设置它所能拦截的资源。

 
  1. //过滤器范例:
  2. package me.gacl.web.filter;
  3. import java.io.IOException;
  4. import javax.servlet.Filter;
  5. import javax.servlet.FilterChain;
  6. import javax.servlet.FilterConfig;
  7. import javax.servlet.ServletException;
  8. import javax.servlet.ServletRequest;
  9. import javax.servlet.ServletResponse;
  10. /**
  11. * @ClassName: FilterDemo01
  12. * @Description:filter的三种典型应用:
  13. * 1、可以在filter中根据条件决定是否调用chain.doFilter(request, response)方法,
  14. * 即是否让目标资源执行
  15. * 2、在让目标资源执行之前,可以对request\response作预处理,再让目标资源执行
  16. * 3、在目标资源执行之后,可以捕获目标资源的执行结果,从而实现一些特殊的功能
  17. * @author: 孤傲苍狼
  18. * @date: 2014-8-31 下午10:09:24
  19. */
  20. public class FilterDemo01 implements Filter {
  21. @Override
  22. public void init(FilterConfig filterConfig) throws ServletException {
  23. System.out.println( "----过滤器初始化----");
  24. }
  25. @Override
  26. public void doFilter(ServletRequest request, ServletResponse response,
  27. FilterChain chain) throws IOException, ServletException {
  28. //对request和response进行一些预处理
  29. request.setCharacterEncoding( "UTF-8");
  30. response.setCharacterEncoding( "UTF-8");
  31. response.setContentType( "text/html;charset=UTF-8");
  32. System.out.println( "FilterDemo01执行前!!!");
  33. chain.doFilter(request, response); //让目标资源执行,放行
  34. System.out.println( "FilterDemo01执行后!!!");
  35. }
  36. @Override
  37. public void destroy() {
  38. System.out.println( "----过滤器销毁----");
  39. }
  40. }
  41. <?xml version= "1.0" encoding= "UTF-8"?>
  42. <web-app version= "3.0"
  43. xmlns= "http://java.sun.com/xml/ns/javaee"
  44. xmlns:xsi= "http://www.w3.org/2001/XMLSchema-instance"
  45. xsi:schemaLocation= "http://java.sun.com/xml/ns/javaee
  46. http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
  47. <display-name></display-name>
  48. <welcome-file-list>
  49. <welcome-file>index.jsp</welcome-file>
  50. </welcome-file-list>
  51. <!--配置过滤器-->
  52. <filter>
  53. <filter-name>FilterDemo01</filter-name>
  54. <filter- class>me.gacl.web.filter.FilterDemo01</filter-class>
  55. </filter>
  56. <!--映射过滤器-->
  57. <filter-mapping>
  58. <filter-name>FilterDemo01</filter-name>
  59. <!--“/*”表示拦截所有的请求 -->
  60. <url-pattern>/*</url-pattern>
  61. </filter-mapping>
  62. </web-app>

有哪些作用:

验证客户是否来自可信网络

对客户提交的数据进行重新编码

过滤掉客户的某些不应该出现的词汇

验证用户是否可以登录

验证客户的浏览器是否支持当前的应用

记录系统日志

 

15、web.xml 的作用

web.xml文件是用来初始化配置信息:比如Welcome页面、servlet、servlet-mapping、filter、listener、启动加载级别等。

当你的web工程没用到这些时,你可以不用web.xml文件来配置你的Application。

 

16、常用的 JSTL 标签

<c:if>

<c:choose>、<c:when>、<c:otherwise>

<c:forEach>

<c:set>

JSP 教程

 

根据JSTL标签所提供的功能,可以将其分为5个类别。

  • 核心标签
  • 格式化标签
  • SQL 标签
  • XML 标签
  • JSTL 函数

使用任何库,你必须在每个JSP文件中的头部包含<taglib>标签。


核心标签

核心标签是最常用的JSTL标签。引用核心标签库的语法如下:


 
  1. <%@ taglib prefix="c"
  2. uri= "http://java.sun.com/jsp/jstl/core" %>
标签描述
<c:out>用于在JSP中显示数据,就像<%= ... >
<c:set>用于保存数据
<c:remove>用于删除数据
<c:catch>用来处理产生错误的异常状况,并且将错误信息储存起来
<c:if>与我们在一般程序中用的if一样
<c:choose>本身只当做<c:when>和<c:otherwise>的父标签
<c:when><c:choose>的子标签,用来判断条件是否成立
<c:otherwise><c:choose>的子标签,接在<c:when>标签后,当<c:when>标签判断为false时被执行
<c:import>检索一个绝对或相对 URL,然后将其内容暴露给页面
<c:forEach>基础迭代标签,接受多种集合类型
<c:forTokens>根据指定的分隔符来分隔内容并迭代输出
<c:param>用来给包含或重定向的页面传递参数
<c:redirect>重定向至一个新的URL.
<c:url>使用可选的查询参数来创造一个URL

格式化标签

JSTL格式化标签用来格式化并输出文本、日期、时间、数字。引用格式化标签库的语法如下:


 
  1. <%@ taglib prefix="fmt"
  2. uri= "http://java.sun.com/jsp/jstl/fmt" %>
标签描述
<fmt:formatNumber>使用指定的格式或精度格式化数字
<fmt:parseNumber>解析一个代表着数字,货币或百分比的字符串
<fmt:formatDate>使用指定的风格或模式格式化日期和时间
<fmt:parseDate>解析一个代表着日期或时间的字符串
<fmt:bundle>绑定资源
<fmt:setLocale>指定地区
<fmt:setBundle>绑定资源
<fmt:timeZone>指定时区
<fmt:setTimeZone>指定时区
<fmt:message>显示资源配置文件信息
<fmt:requestEncoding>设置request的字符编码

 

17、中间件

中间件就是程序中可植入的,可重用的,与业务逻辑无关的各种组件

中间件是基础软件的一大类,属于可复用软件的范畴。顾名思义,中间件处于操作系统软件与用户的应用软件的中间。中间件在操作系统、网络和数据库之上,应用软件的下层,总的作用是为处于自己上层的应用软件提供运行与开发的环境,帮助用户灵活、高效的开发和集成复杂的应用软件

中间件是一种独立的系统软件或服务程序,分布式应用软件借助这种软件在不同的技术之间共享资源,中间件位于客户机服务器的操作系统之上,管理计算资源和网络通信。

举例:

RMI(Remote Method Invocation)远程调用

Load Balancing 负载均衡,将访问符合分散到各个服务器中

Treasparent Fail-over 透明的故障切换

Clustering 集群,用多个小的服务器代替大型机

Back-end-Integration 后端集成,用现有的、新开发的系统如何去集成遗留的系统

Transaction 事务(全局事务:分布式事务)(局部事务:在同一数据库连接内的事务)

Dynamic Redeployment 动态重新部署,在不停止原系统的情况下,部署新的系统

System Managerment 系统管理

Threading 多线程处理

Message-oriented Middleware 面向消息的中间件(异步的调用编程)

Component Life Cycle 组件的生命周期管理

Resource pooling 资源池

Security 安全

Caching 缓存

 

18、如何输出某种编码的字符串

String str = new String("testABC".getBytes("iso-8859-1"), "utf-8");

 

19、J2EE 是技术还是平台还是框架

J2EE 本身是一个标准,一个为企业分布式应用开发提供的标准平台

J2EE 也是一个框架,包括 JDBC、JNDI、RMI、JMS、EJB、JTA 等技术

 

20、什么是 ORM

对象关系映射(Object-Relational Mapping)是一种为了解决面向对象与面向关系数据库存在的互不匹配的技术,简单说,ORM 是通过使用描述对象和数据库之间映射的元数据,将 Java 程序中的对象自动持久化到关系数据库中,本质上就是将数据从一种形式转换到另一种形式

 

21、Hibernate 的 5 个核心接口

Configuration:配置 Hibernate,根据其启动 Hibernate,创建 SessionFactory 对象

SessionFactory:初始化 Hibernate,充当数据存储源的代理,创建 session 对象,SessionFactory 是线程安全的,意味着它的同一个实例可以被应用的多个线程共享,是重量级、二级缓存

Session:负责保存、更新、删除、加载和查询对象,是线程不安全的,避免多个线程共享一个 session,是轻量级、一级缓存

Query 和 Criteria:执行数据库的查询

 

22、Hibernate 是如何处理事务的

Hibernate 的事务实际上是底层的 JDBC Transaction 的封装或者是 JTA Transaction 的封装,默认情况下使用 JDBC Transaction

 

23、Connection 类中有哪几个事务处理方法

setAutoCommit(boolean autoCommint):设置是否自动提交事务,默认为自动提交

commint():提交事务

rollback():回滚事务

 

24、JDBC 中访问数据库的步骤、Statement 和 PreparedStatement 的区别

Java 中访问数据库的步骤如下

1)注册驱动

2)建立连接

3)创建 Statement

4)执行 sql 语句

5)处理结果集(若 sql 语句为查询语句)

6)关闭连接

Statement、PreparedStatement 区别

1) 创建时的区别:

    Statement stm = con.createStatement();

    PreparedStatement pstm = con.prepareStatement(sql);

执行的时候:

    stm.execute(sql);

    pstm.execute();

2) PreparedStatement 一旦绑定了 SQL,此 pstm 就不能执行其它的 SQL,即只能执行一条 SQL 命令;Statement 可以执行多条 SQL 命令。

3) 对于执行同构的 SQL(只有参数值不同,其它SQL 结构都相同),用 PreparedStatement 的执行效率比较高,支持预编译,可以执行批量处理任务;对于异构的SQL 语句,Statement 的执行效率较高。

4) 代码的可读性和可维护性;(例如一个insert 的 SQL 语句,stm 在 SQL 中需要用字符形式写入传递的参数,pstm 提供方法传递参数,并且过滤掉SQL 中的特俗字符“ ’”,“-”)。

5) PreparedStatement 提高了安全性,防止了SQL 注入,但 Statement 不能实现,只能做判断和过滤。

 

25、Hibernate 中 Java 对象的三种状态,对象分别如何进入某种状态

1)临时状态(transient)

特征:

不处于 Session 缓存中

数据库中没有对象记录

Java 对象如果进入临时状态:

通过 new 语句创建一个对象时

当调用 session 的 delete() 方法,从 session 缓存删除一个对象时

2)持久化状态(persisted)

特征:

处于 session 缓存中

数据库中有对象记录

session 在特定时刻会保持二者同步

Java 对象如何进入持久化状态

session 的 save() 从临时状态到持久化状态

session 的 load(), get() 方法返回的对象

session 的 find() 返回的 list 集合中存放的对象

session 的 update(), saveOrUpdate() 使游离态到持久化状态

3)游离状态(detached)

特征:

不再位于 session 缓存中

游离对象由持久化状态转变而来,数据库中可能还有对应记录

Java 对象如何从持久化状态到游离状态

session 的 close() 方法

session 的 evict() 方法,从缓存中删除一个对象。 提高性能,少用。

 

26、JDBC 相对于 Hibernate 的优势

JDBC 效率高、直接操作数据库比较灵活

 

27、Hibernate 如何延时加载

当 Hibernate 在查询数据的时候,数据并没有存在内存中,当程序真正对数据进行操作时,对象才存在内存中,就实现了延时加载。节省了服务器的内存开销,从而提高了服务器的性能

 

28、session.load() 与 session.get() 的区别

都可以根据指定的实体类和 id 从数据库读取记录,并返回与之对应的实体对象

如果没有发现符合条件的记录,get 方法返回 null,而 load 方法会抛出一个 ObjectNotFundException

 

29、cookie 机制与 session 机制的区别

cookie 机制采用的是在客户端保持状态的方案,而 session 机制采用的是在服务器端保持状态的方案。由于服务器端保持状态的方案也需要在客户端保存一个标识,所以,session 机制可能需要借助于 cookie 机制来达到保存标识的目的

30 . Servlet类的匹配规则详解

一、概述

在利用servlet或Filter进行url请求的匹配时,很关键的一点就是匹配规则,但servlet容器中的匹配规则既不是简单的通配,也不是正则表达式,而是由自己的规则,比较容易混淆。本文来详细举例介绍下。下面的说明都是在tomcat服务器中得到验证的。

先介绍一下匹配的概念,上例子代码。在一个app(如名字为myapp)的web.xml文件中,有如下信息:

按 Ctrl+C 复制代码

<servlet>
    <servlet-name>MyServlet</servlet-name>
    <servlet-class>com.nau.MyServlet</servlet-class>
  </servlet>
  
  <servlet-mapping>
    <servlet-name>MyServlet</servlet-name>
    <url-pattern>xxxxxx</url-pattern>
   <url-pattern>yyyyyyy</url-pattern>
  </servlet-mapping>

上面的配置信息,其中<servlet>标签首先配置声明一个servlet,包括servlet的名字和对应的java类名。
其中<servlet-mapping>标签声明了与该servlet相应的匹配规则,每个<url-pattern>标签代表1个匹配规则。

当浏览器发起一个url请求后,该请求发送到servlet容器的时候,容器先会将请求的url减去当前应用上下文的路径作为servlet的映射url,比如url是http://10.43.11.143/myapp/kata/detail.html,其应用上下文是myapp,容器会将http://10.43.11.143/myapp去掉,剩下的/kata/detail.html部分拿来做servlet的映射匹配。这个映射匹配过程是有优先顺序的(具体的优先顺序规则后面介绍),而且当有一个servlet匹配成功以后,就不会去理会剩下的servlet了。

注意Filter的匹配规则与servlet一样,但对于filter,不会像servlet那样只匹配一个servlet,因为filter的集合是一个链,所以只会有处理的顺序不同,而不会出现只选择一个filter。Filter的处理顺序和filter-mapping在web.xml中定义的顺序相同。 

下面我们详细介绍各种匹配规则

二、精确匹配

<url-pattern>中配置的项必须与url完全精确匹配。

如配置信息如下:

 


 
  1. <servlet-mapping>
  2. <servlet-name>MyServlet </servlet-name>
  3. <url-pattern>/kata/detail.html </url-pattern>
  4. <url-pattern>/demo.html </url-pattern>
  5. <url-pattern>/table </url-pattern>
  6. </servlet-mapping>

当在浏览器中输入如下几种url时,都会被匹配到该servlet
http://10.43.11.143/myapp/kata/detail.html
http://10.43.11.143/myapp/demo.html
http://10.43.11.143/myapp/table

注意:

http://10.43.11.143/myapp/table/ 是非法的url,不会被当作http://10.43.11.143/myapp/table识别

另外上述url后面可以跟任意的查询条件,都会被匹配,如

http://10.43.11.143/myapp/table?hello 这个请求就会被匹配到MyServlet。

 

三、扩展名匹配

如果匹配规则如下


 
  1. <servlet-mapping>
  2. <servlet-name>MyServlet </servlet-name>
  3. <url-pattern>*.jsp </url-pattern>
  4. </servlet-mapping>

则任何扩展名为jsp(文件名和路径任意)的url请求都会匹配,比如下面的url都会被匹配
http://10.43.11.143/myapp/demo.jsp
http://10.43.11.143/myapp/test.jsp

 

四、路径匹配

如果匹配规则如下


 
  1. <servlet-mapping>
  2. <servlet-name>MyServlet </servlet-name>
  3. <url-pattern>/kata/* </url-pattern>
  4. </servlet-mapping>

则请求的ulr只要前面(myapp之后)的路径是/kata,而后面的路径可以任意。比如下面的url都会被匹配。
http://10.43.11.143/myapp/kata/demo.html
http://10.43.11.143/myapp/kata/test.jsp
http://10.43.11.143/myapp/kata/test/detail.html

http://10.43.11.143/myapp/kata/action

http://10.43.11.143/myapp/kata/action/

注意:路径和扩展名匹配无法同时设置,比如下面的三个<url-pattern>都是非法的,如果设置,启动tomcat服务器会报错。

<url-pattern>/kata/*.jsp</url-pattern>

<url-pattern>/*.jsp</url-pattern>

<url-pattern>he*.jsp</url-pattern>

另外注意:<url-pattern>/aa/*/bb</url-pattern>
这个是精确匹配,url必须是 /aa/*/bb,这里的*不是通配的含义

 

五、匹配任意的url

如果<url-pattern>配置成如下两种的任意一种

<url-pattern>/</url-pattern>

<url-pattern>/*</url-pattern>

则所有的url都可以被匹配上。其中/*是路径匹配,只是路径就是/。

 

六、优先顺序

当一个url与多个servlet的匹配规则可以匹配时,则按照 “ 精确路径 > 最长路径>扩展名”这样的优先级匹配到对应的servlet。举例如下:

例1:比如servletA 的url-pattern为 /test,servletB的url-pattern为 /* ,这个时候,如果我访问的url为http://localhost/test ,这个时候容器就会先进行精确路径匹配,发现/test正好被servletA精确匹配,那么就去调用servletA,不会去管servletB。

例2:比如servletA的url-pattern为/test/*,而servletB的url-pattern为/test/a/*,此时访问http://localhost/test/a时,容器会选择路径最长的servlet来匹配,也就是这里的servletB。 

例3: 比如servletA的url-pattern:*.action ,servletB的url-pattern为 /* ,这个时候,如果我访问的url为http://localhost/test.action,这个时候容器就会优先进行路径匹配,而不是去匹配扩展名,这样就去调用servletB。

七、小结

本文我们详细介绍了servlet的匹配规则。总的来说就是分为精确、路径和扩展名三种匹配方式,并且介绍了优先级。

 

一面

面试官比较年轻,可能年龄和我差不多。

刚开始有点紧张,差点脑子短路,之后就缓过来了。

下面是大概的面试过程,可能顺序不太对的上:

请先自我介绍一下

就大概按照简历上说了下,学校、专业、求职意向,还说了我的竞赛经历。

说一下 Java 虚拟机的内存模型吧

这里理解错问题了,要注意审题啊

我答的是多线程的内存模型,主存、工作内存之类的。说完面试官也没有反驳 =。=

这里应该回答堆栈相关,即 Java 虚拟机的运行时数据区域。

详细参考:《深入理解 Java 虚拟机》学习笔记(2)——运行时数据区域

请描述一下 Java 虚拟机的垃圾回收机制

这是个送分题啊!基本上被问到就可以扯上很久。

大概就是围绕 Java 虚拟机的运行时数据区域(自己都没意识到把上一个问题的坑填了,面完才发觉)、可达性分析、4 种引用、回收算法、垃圾收集器来回答。

被问到这个问题时候面试刚开始没多久,比较紧张,想说的太多,差点不知道从什么地方开始。。

详细参考:

《深入理解 Java 虚拟机》学习笔记(1)——JVM 垃圾回收与内存分配策略

《深入理解 Java 虚拟机》学习笔记(4)——垃圾收集器

我看你项目中用了 MyBatis,那你知道为什么现在越来越多的人倾向使用 MyBatis 呢?它和 Hibernate 有什么区别?

这个问题答得不是很好,明明前天才看了的,当时却想不起来了。就随便说了下 MyBatis 更加轻量级,容易掌握,而且比 Hibernate 更加灵活。MyBatis 可以进行更为细致的 SQL 优化。

正解:

两者相同点

  • Hibernate 与 MyBatis 都可以是通过 SessionFactoryBuider 由 XML 配置文件生成 SessionFactory,然后由 SessionFactory 生成 Session,最后由 Session 来开启执行事务和 SQL 语句。其中 SessionFactoryBuider,SessionFactory,Session 的生命周期都是差不多的。
  • Hibernate 和 MyBatis 都支持 JDBC 和 JTA 事务处理。

Mybatis 优势

  • MyBatis 可以进行更为细致的 SQL 优化,可以减少查询字段。
  • MyBatis 容易掌握,而 Hibernate 门槛较高。

Hibernate 优势

  • Hibernate 的 DAO 层开发比 MyBatis 简单,Mybatis 需要维护 SQL 和结果映射。
  • Hibernate 对对象的维护和缓存要比 MyBatis 好,对增删改查的对象的维护要方便。
  • Hibernate 数据库移植性很好,MyBatis 的数据库移植性不好,不同的数据库需要写不同 SQL。
  • Hibernate 有更好的二级缓存机制,可以使用第三方缓存。MyBatis 本身提供的缓存机制不佳。

详细参考:Hibernate 与 MyBatis 的比较

spring AOP 是如何实现的?

spring AOP 有 JDK 动态代理和 CGLIB 代理两种实现方式

JDK 动态代理和 CGLIB 代理有什么区别?

这个详细的实现有点记不住了,回答的是 JDK 动态代理是通过接口实现的,而 CGLIB 是通过字节码层面的类实现的。

虽然大体上没错,但是不够详细啊 =。=

正解:

  • JDK 动态代理:其代理对象必须是某个接口的实现,它是通过在运行期间创建一个接口的实现类来完成对目标对象的代理;其核心是 InvocationHandler 接口和 Proxy 类。
  • CGLIB 代理:实现原理类似于 JDK 动态代理,只是它在运行期间生成的代理对象是针对目标类扩展的子类。CGLIB 是高效的代码生成包,底层是依靠 ASM(开源的 java 字节码编辑类库)操作字节码实现的,性能比 JDK 强;需要引入包 asm.jar 和 cglib.jar。

那你知道 spring 默认使用哪种代理吗?

这个确实不知道,当时就回答的不知道。感觉这种问题不能乱猜,猜错会影响面试官对你的印象。

正解:

  • 如果目标对象实现了接口,默认情况下会采用 JDK 的动态代理实现 AOP
  • 如果目标对象实现了接口,可以强制使用 CGLIB 实现 AOP
  • 如果目标对象没有实现接口,则默认采用 CGLIB 实现 AOP

你项目中用到了 MySQL,那你知道 MySQL 有哪些引擎吗?

回答的是用过 MyISAM 和 InnoDB,还有两个不记得了。期间还被面试官提醒名字

正解:MyISAM、InnoDB、MEMORY、MERGE

说说 MyISAM 和 InnoDB 有什么区别

这个问题回答得惨不忍睹,之前也看过,但是基本记不起来了,当时深入浅出 MySQL 那本书是一晚上翻晚的。

我回答的 MyISAM 读速度比较快,不支持外键,而 InnoDB 支持外键

正解:(转自:InnoDB 与 Myisam 的六大区别

 MyISAMInnoDB
构成上每个 MyISAM 在磁盘上存储成三个文件。第一个文件的名字以表的名字开始,扩展名指出文件类型。

 

		<p>.frm 文件存储表定义。</p>

		<p>数据文件的扩展名为. MYD (MYData)。</p>

		<p>索引文件的扩展名是. MYI (MYIndex)。</p>
		</td>
		<td>基于磁盘的资源是 InnoDB 表空间数据文件和它的日志文件,InnoDB 表的大小只受限于操作系统文件的大小,一般为 2GB</td>
	</tr><tr><td><strong>事务处理</strong></td>
		<td>MyISAM 类型的表强调的是性能,其执行数度比 InnoDB 类型更快,但是不提供事务支持</td>
		<td>InnoDB 提供事务支持事务,外部键等高级数据库功能</td>
	</tr><tr><td><strong>SELECT,UPDATE,</strong>
		<p>&nbsp;</p>

		<p><strong>INSERT,</strong><strong>DELETE</strong></p>
		</td>
		<td>如果执行大量的 SELECT,MyISAM 是更好的选择</td>
		<td><strong>1.</strong>&nbsp;如果你的数据执行大量的<strong>&nbsp;INSERT</strong><strong>&nbsp;或</strong><strong>UPDATE</strong>,出于性能方面的考虑,应该使用 InnoDB 表
		<p>&nbsp;</p>

		<p><strong>2.DELETE FROM table</strong>&nbsp;时,InnoDB 不会重新建立表,而是一行一行的删除。</p>

		<p><strong>3.LOAD TABLE FROM MASTER</strong>&nbsp;操作对 InnoDB 是不起作用的,解决方法是首先把 InnoDB 表改成 MyISAM 表,导入数据后再改成 InnoDB 表,但是对于使用的额外的 InnoDB 特性(例如外键)的表不适用</p>
		</td>
	</tr><tr><td><strong>对</strong><strong>AUTO_INCREMENT</strong><strong>的操作</strong></td>
		<td>每表一个 AUTO_INCREMEN 列的内部处理。
		<p>&nbsp;</p>

		<p><strong>MyISAM</strong><strong>&nbsp;为</strong><strong>&nbsp;INSERT</strong><strong>&nbsp;和</strong><strong>&nbsp;UPDATE</strong><strong>&nbsp;操作自动更新这一列</strong>。这使得 AUTO_INCREMENT 列更快(至少 10%)。在序列顶的值被删除之后就不能再利用。(当 AUTO_INCREMENT 列被定义为多列索引的最后一列,可以出现重使用从序列顶部删除的值的情况)。</p>

		<p>AUTO_INCREMENT 值可用 ALTER TABLE 或 myisamch 来重置</p>

		<p>对于 AUTO_INCREMENT 类型的字段,InnoDB 中必须包含只有该字段的索引,但是在 MyISAM 表中,可以和其他字段一起建立联合索引</p>

		<p>更好和更快的 AUTO_INCREMENT 处理</p>
		</td>
		<td>如果你为一个表指定 AUTO_INCREMENT 列,在数据词典里的 InnoDB 表句柄包含一个名为自动增长计数器的计数器,它被用在为该列赋新值。
		<p>&nbsp;</p>

		<p>自动增长计数器仅被存储在主内存中,而不是存在磁盘上</p>

		<p>关于该计算器的算法实现,请参考</p>

		<p><strong>AUTO_INCREMENT</strong><strong>&nbsp;列在</strong><strong>&nbsp;InnoDB</strong><strong>&nbsp;里如何工作</strong></p>
		</td>
	</tr><tr><td><strong>表的具体行数</strong></td>
		<td>SELECT COUNT(*) FROM&nbsp;table,MyISAM 只要简单的读出保存好的行数,注意的是,当 COUNT(*) 语句包含 WHERE 条件时,两种表的操作是一样的</td>
		<td>InnoDB 中不保存表的具体行数,也就是说,执行 SELECT COUNT(*) FROM table 时,InnoDB 要扫描一遍整个表来计算有多少行</td>
	</tr><tr><td><strong>锁</strong></td>
		<td>&nbsp;&nbsp;表锁</td>
		<td>&nbsp;&nbsp;提供行锁 (locking on row level),提供与 Oracle 类型一致的不加锁读取 (non-locking read in<br>
		SELECTs),另外,InnoDB 表的行锁也不是绝对的,如果在执行一个 SQL 语句时 MySQL 不能确定要扫描的范围,InnoDB 表同样会锁全表,例如 UPDATE table SET num=1 WHERE name LIKE&nbsp;"%aaa%"</td>
	</tr></tbody></table></div><blockquote>

说说异常的类继承关系

大概就是说的 Exception 和 Error 都继承于 Throwable,然后 Exception 的子类又分 RuntimeException 和非 RuntimeException,RuntimeException 就是运行时异常,比如:NullPointerException、IndexOutOfBoundsException

而 Error 和 RuntimeException 属于 Unchecked Exception,不需要 try...catch 处理

其他的属于 Checked Exception,需要 try...catch 处理

Checked Exception 一般是什么引起的?

程序不能直接控制的无效外界情况(如用户输入,数据库问题,网络异常,文件丢失等)

concurrent 包用过哪些东西?

回答的 ConcurrentHashMap

ConcurrentHashMap 原理是什么?

大致说了下 Hashtable 和 ConcurrentHashMap 的区别,ConcurrentHashMap 是存的段,段里面存的桶,加锁是对段进行加锁。(JDK8 修改了实现方式)

ConcurrentHashMap 默认桶的个数是多少?

这个没有注意看过,于是回答的 HashMap 是 16 个,ConcurrentHashMap 不太清楚。回去看了下源码,都是 16 个。

为什么默认初始化桶数组大小为16,为什么加载因子的大小为0.75,这两个值的选取有什么特点。

通过看上面的代码我们可以知道这两个值主要影响的threshold的大小,这个值的数值是当前桶数组需不需要扩容的边界大小,

我们都知道桶数组如果扩容,会申请内存空间,然后把原桶中的元素复制进新的桶数组中,这是一个比较耗时的过程。既然这样,那为何不把这两个值都设置大一些呢,threshold是两个数的乘积,设置大一些就不那么容易会进行扩容了啊。

原因是这样的,如果桶初始化桶数组设置太大,就会浪费内存空间,16是一个折中的大小,既不会像1,2,3那样放几个元素就扩容,也不会像几千几万那样可以只会利用一点点空间从而造成大量的浪费。

加载因子设置为0.75而不是1,是因为设置过大,桶中键值对碰撞的几率就会越大,同一个桶位置可能会存放好几个value值,这样就会增加搜索的时间,性能下降,设置过小也不合适,如果是0.1,那么10个桶,threshold为1,你放两个键值对就要扩容,太浪费空间了。

悲观锁和乐观锁用过吗?

回答的没用过但是知道概念,比如 synchronized 是悲观锁,而 Java 的原子类比如 AtomicInteger 使用 CAS 乐观锁实现的。

后来面完才意识到这不就是用过么,当时 sb 了。

 

之后就是一些非技术性问题了,简单列举下,就不放我的回答了

你最看重一个公司的哪一点?

对加班怎么看?

平时怎么学习的?

之前被通知下午一点半开始下午的面试,中午的时间就稍微把上午问到的问题查了下,一点半一到就被分配面试了。

 

二面

二面是个比较成熟的面试官,估计至少是 leader 级别的了

感觉二面就是压力面,面试是在一个很小的房间,大概 5 平米,和面试官的距离很近,可以清楚看到他的表情。

不过到了二面反而不紧张了,而且从面试官的表情可以看出你答得怎么样,感觉还是和面试官比较谈得来。

二面大概就是围绕项目和基础,不过挖得很深,你提到的东西一定要知道原理,不要抱侥幸心理,只要你说出来肯定会被深入的问下去,所以回答的时候要注意不要给自己挖坑,要尽量往自己知道的方向带。

二面大概面了 40~60 分钟,具体时间不太清楚了。当时我是关了手机的,没看时间。

做个简单的自我介绍吧

同一面

给我介绍一下你这个项目吧

就大概说了下这个项目是做什么的,以下问题都没有可复制性,我就只列出问题了

为什么要做这个项目?

你做的这个模块的结构给我说下吧

你对缓存后的结果做了测试吗?(期间说到了 MyBatis 缓存)

你觉得可以怎么优化你的模块?

期间提到了 SQL 优化,然后被问到了:

有哪些优化 SQL 语句优化方式?怎么知道优化的结果

这个问题答得不好,虽然看过但是不太记得了(又是 MySQL!)

正解:(详细请看《深入浅出 MySQL》第 18 章)

优化 SQL 语句的步骤:

  1. 通过 show status 命令了解各种 SQL 的执行频率
  2. 定位执行效率较低的 SQL 语句
  3. 通过 EXPLAIN 分析低效 SQL 的执行计划
  4. 确定问题并采取相应的优化措施

优化方式:

  • 使用索引
  • 使用 OPTIMIZE TABLE 命令来进行表优化。这个命令可以将表中的空间碎片进行合并,并且可以消除由于删除或者更新造成的空间浪费
  • 优化 INSERT 语句:对 MyISAM 表,导入大量数据时关闭索引的更新,结束后开启,同时可以和 LOAD DATA INFILE 命令配合使用
  • 优化 GROUP BY 语句:GROUP BY 默认排序,可以通过指定 ORDER BY NULL 禁止排序
  • 优化 ORDER BY 语句:使用一个索引来满足 ORDER BY 子句,而不需要额外的排序。WHERE 条件和 ORDERBY 使用相同的索引,并且 ORDER BY 的顺序和索引顺序相同,并且 ORDER BY 的字段都是升序或者都是降序。
  • 优化子查询:有些情况下,子查询可以被更有效率的连接(JOIN)替代。连接(JOIN)之所以更有效率一些,是因为 MySQL 不需要在内存中创建临时表来完成这个逻辑上的需要两个步骤的查询工作。
  • 对于含有 OR 的查询子句,如果要利用索引,则 OR 之间的每个条件列都必须用到索引;如果没有索引,则应该考虑增加索引。

MySQL 有哪些引擎?MyISAM 和 InnoDB 有什么区别?

幸好我面完一面就看了这个问题的答案,二面又被问到了。同上正解

你觉得可以怎么优化你的模块?

说了个实现算法的优化方案,面试官比较满意。

之后就开始问 Java 基础问题了

一上来就是一面的老问题。看来面试官之间并没有交流,JVM 真的是送分题。

Java 虚拟机的内存模型(这次审题对了)

Java 垃圾回收机制

不过虽然和一面问题一样,但是面试官随时会打断你的描述,然后问一些更深的问题,比如

你用过哪些 JVM 参数?

你自己设置过使用哪个回收算法吗?

不过我当时说的时候也说得比一面要深入,所以并没有被问多少问题,感觉只要熟悉《深入理解 Java 虚拟机》这本书 JVM 这块就没问题了。

什么叫线程安全?

线程安全就是说多线程访问同一代码,不会产生不确定的结果。

线程有哪些状态?

  • New (新生)
    如用 new Thread() 创建一个新线程,这个线程还没有开始运行
  • Runnable (可运行)
    一旦调用 start 方法,线程处于可运行状态。系统会为这个线程分配它运行时所需的除处理器之外的所有系统资源。处于此状态的线程可能正在运行也可能没有运行,这取决于操作系统给线程提供运行的时间。
  • Blocked (被阻塞)
    当一个线程试图获取一个内部的对象锁,而该锁被其他线程持有,则该线程进入阻塞状态。当所有其他线程释放该锁,并且线程调度器允许本线程持有它的时候,该线程将变为非阻塞状态。
  • Waiting (等待)
    当线程等待另一个线程通知调度器一个条件时,进入等待状态,如调用 Object.wait() 方法时,需要等待其他线程调用 Object.notify() 或 Object.notifyAll()
  • Timed waiting (计时等待)
    有几个方法有一个超时参数,调用它们导致线程进入计时等待状态。这一状态将一直保持到超时期满或者接收到适当的通知。
  • Terminated (被终止)
    因 run 方法正常退出而自然死亡。或因为一个没有捕获的异常终止了 run 方法而意外死亡。

Java 使用锁的方式有哪几种?

synchronized、ReentrantLock、volatile

volatile 的原理是什么?

我的回答:每个线程会将类变量复制一份到工作内存,当修改一个类变量副本时会立即写会主存,之后其他线程的此变量副本会变为过期状态,当其他线程发现过期时会从主存中重新读取。

大致没有问题,但是回答不标准。

正解:

有 volatile 变量修饰的共享变量进行写操作的时候在汇编代码中会多出 Lock 前缀。

Lock 前缀的指令在多核处理器下会引发了两件事情:

  1. 将当前处理器缓存行的数据写回到系统内存。
  2. 这个写回内存的操作会使在其他 CPU 里缓存了该内存地址的数据无效。

为了提高处理速度,处理器不直接和内存进行通信,而是先将系统内存的数据读到内部缓存(L1,L2 或其他)后再进行操作,但操作完不知道何时会写到内存。如果对声明了 volatile 的变量进行写操作,JVM 就会向处理器发送一条 Lock 前缀的指令,将这个变量所在缓存行的数据写回到系统内存。但是,就算写回到内存,如果其他处理器缓存的值还是旧的,再执行计算操作就会有问题。所以,在多处理器下,为了保证各个处理器的缓存是一致的,就会实现缓存一
致性协议,每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了,当处理器发现自己缓存行对应的内存地址被修改,就会将当前处理器的缓存行设置成无效状态,当处理器对这个数据进行修改操作的时候,会重新从系统内存中把数据读到处理器缓存里。

集合你用过哪些?

ArrayList、LinkedList、HashMap... 然后说常见的都用过。

HashMap 是怎么实现的?

桶数组实现,每个桶是一个链表,然后说了一下 JDK8 对 HashMap 的优化,当桶中元素个数大于等于 8 时链表改为红黑树实现,可以防止 hashCode 攻击,然后解释了下什么事 hashCode 攻击,为什么可以防止。

哈希表碰撞攻击就是通过精心构造数据,使得所有数据全部碰撞,人为将哈希表变成一个退化的单链表,此时哈希表各种操作的时间均提升了一个数量级,因此会消耗大量CPU资源,导致系统无法快速响应请求,从而达到拒绝服务攻击(DoS)的目的。

JDK1.8 有哪些新特性?

1、default关键字

2、Lambda 表达式

3、函数式接口

4、方法与构造函数引用

5、局部变量限制

6、Date Api更新 

7、流

我先说了下接口可以有静态方法和默认方法了。然后面试官说,不要说语法层面的,说大方向上的。

然后想了下说对并发进行了优化,面试官让举例,于是举 concurrentHashMap,修改实现方式,代码从 2000 行左右增加到了 6000 行左右。(表现自己看过源码,并且把话题扯开)

concurrentHashMap 的实现原理

表明自己不太清楚 JDK8 的实现方式,但是知道 JDK7 的,然后面试官便问 JDK7 的,答案同一面。

然后就是一些非技术性问题:

除了写代码,你平时还喜欢做什么?

你怎么学习的?比如 MyBatis 怎么学的?

你最喜欢的一门课是什么?

排序方法总结

 

ç®æ³æ§è½æ¯è¾å¾

Hibernate:

hibernate中@Entity和@Table的区别

Java Persistence API定义了一种定义,可以将常规的普通Java对象(有时被称作POJO)映射到数据库。
这些普通Java对象被称作Entity Bean。
除了是用Java Persistence元数据将其映射到数据库外,Entity Bean与其他Java类没有任何区别。
事实上,创建一个Entity Bean对象相当于新建一条记录,删除一个Entity Bean会同时从数据库中删除对应记录,修改一个Entity Bean时,容器会自动将Entity Bean的状态和数据库同步。

Java Persistence API还定义了一种查询语言(JPQL),具有与SQL相类似的特征,只不过做了裁减,以便处理Java对象而非原始的关系表。



 hibernate中@Entity和@Table的区别:
@Entity说明这个class是实体类,并且使用默认的orm规则,即class名即数据库表中表名,class字段名即表中的字段名
如果想改变这种默认的orm规则,就要使用@Table来改变class名与数据库中表名的映射规则,@Column来改变class中字段名与db中表的字段名的映射规则

 

 

欢迎使用Markdown编辑器

你好! 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章,了解一下Markdown的基本语法知识。

新的改变

我们对Markdown编辑器进行了一些功能拓展与语法支持,除了标准的Markdown编辑器功能,我们增加了如下几点新功能,帮助你用它写博客:

  1. 全新的界面设计 ,将会带来全新的写作体验;
  2. 在创作中心设置你喜爱的代码高亮样式,Markdown 将代码片显示选择的高亮样式 进行展示;
  3. 增加了 图片拖拽 功能,你可以将本地的图片直接拖拽到编辑区域直接展示;
  4. 全新的 KaTeX数学公式 语法;
  5. 增加了支持甘特图的mermaid语法1 功能;
  6. 增加了 多屏幕编辑 Markdown文章功能;
  7. 增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能,功能按钮位于编辑区域与预览区域中间;
  8. 增加了 检查列表 功能。

功能快捷键

撤销:Ctrl/Command + Z
重做:Ctrl/Command + Y
加粗:Ctrl/Command + B
斜体:Ctrl/Command + I
标题:Ctrl/Command + Shift + H
无序列表:Ctrl/Command + Shift + U
有序列表:Ctrl/Command + Shift + O
检查列表:Ctrl/Command + Shift + C
插入代码:Ctrl/Command + Shift + K
插入链接:Ctrl/Command + Shift + L
插入图片:Ctrl/Command + Shift + G

合理的创建标题,有助于目录的生成

直接输入1次#,并按下space后,将生成1级标题。
输入2次#,并按下space后,将生成2级标题。
以此类推,我们支持6级标题。有助于使用TOC语法后生成一个完美的目录。

如何改变文本的样式

强调文本 强调文本

加粗文本 加粗文本

标记文本

删除文本

引用文本

H2O is是液体。

210 运算结果是 1024.

插入链接与图片

链接: link.

图片: Alt

带尺寸的图片: Alt

居中的图片: Alt

居中并且带尺寸的图片: Alt

当然,我们为了让用户更加便捷,我们增加了图片拖拽功能。

如何插入一段漂亮的代码片

博客设置页面,选择一款你喜欢的代码片高亮样式,下面展示同样高亮的 代码片.

// An highlighted block
var foo = 'bar';

生成一个适合你的列表

  • 项目
    • 项目
      • 项目
  1. 项目1
  2. 项目2
  3. 项目3
  • 计划任务
  • 完成任务

创建一个表格

一个简单的表格是这么创建的:

项目Value
电脑$1600
手机$12
导管$1

设定内容居中、居左、居右

使用:---------:居中
使用:----------居左
使用----------:居右

第一列第二列第三列
第一列文本居中第二列文本居右第三列文本居左

SmartyPants

SmartyPants将ASCII标点字符转换为“智能”印刷标点HTML实体。例如:

TYPEASCIIHTML
Single backticks'Isn't this fun?'‘Isn’t this fun?’
Quotes"Isn't this fun?"“Isn’t this fun?”
Dashes-- is en-dash, --- is em-dash– is en-dash, — is em-dash

创建一个自定义列表

Markdown
Text-to- HTML conversion tool
Authors
John
Luke

如何创建一个注脚

一个具有注脚的文本。2

注释也是必不可少的

Markdown将文本转换为 HTML

KaTeX数学公式

您可以使用渲染LaTeX数学表达式 KaTeX:

Gamma公式展示 Γ ( n ) = ( n − 1 ) ! ∀ n ∈ N \Gamma(n) = (n-1)!\quad\forall n\in\mathbb N Γ(n)=(n1)!nN 是通过欧拉积分

Γ ( z ) = ∫ 0 ∞ t z − 1 e − t d t &ThinSpace; . \Gamma(z) = \int_0^\infty t^{z-1}e^{-t}dt\,. Γ(z)=0tz1etdt.

你可以找到更多关于的信息 LaTeX 数学表达式here.

新的甘特图功能,丰富你的文章

Mon 06 Mon 13 Mon 20 已完成 进行中 计划一 计划二 现有任务 Adding GANTT diagram functionality to mermaid
  • 关于 甘特图 语法,参考 这儿,

UML 图表

可以使用UML图表进行渲染。 Mermaid. 例如下面产生的一个序列图::

张三 李四 王五 你好!李四, 最近怎么样? 你最近怎么样,王五? 我很好,谢谢! 我很好,谢谢! 李四想了很长时间, 文字太长了 不适合放在一行. 打量着王五... 很好... 王五, 你怎么样? 张三 李四 王五

这将产生一个流程图。:

链接
长方形
圆角长方形
菱形
  • 关于 Mermaid 语法,参考 这儿,

FLowchart流程图

我们依旧会支持flowchart的流程图:

Created with Raphaël 2.2.0 开始 我的操作 确认? 结束 yes no
  • 关于 Flowchart流程图 语法,参考 这儿.

导出与导入

导出

如果你想尝试使用此编辑器, 你可以在此篇文章任意编辑。当你完成了一篇文章的写作, 在上方工具栏找到 文章导出 ,生成一个.md文件或者.html文件进行本地保存。

导入

如果你想加载一篇你写过的.md文件或者.html文件,在上方工具栏可以选择导入功能进行对应扩展名的文件导入,
继续你的创作。


  1. mermaid语法说明 ↩︎

  2. 注脚的解释 ↩︎

  • 0
    点赞
  • 0
    评论
  • 0
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值