留学生大佬面经三名狂客

1，·CHROME给每个tab开了进程，为什么？其实就是问线程与进程区别：

··进程是具有一定独立功能的程序、它是系统进行资源分配和调度的一个独立单位，重点在系统调度和单独的单位，也就是说进程是可以独立运行的一段程序。

·线程是进程的一个实体，是CPU调度和分派的基本单位，他是比进程更小的能独立运行的基本单位，线程自己基本上不拥有系统资源。在运行时，只是暂用一些计数器、寄存器和栈。

·调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位。

·并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可以并发执行。

·拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源。

·关于进程和线程，首先从定义上理解就有所不同：

1.进程是具有一定独立功能的程序、它是系统进行资源分配和调度的一个独立单位，重点在系统调度和单独的单位，也就是说进程是可以独立运行的一段程序。

2.线程是进程的一个实体，是CPU调度和分派的基本单位，他是比进程更小的能独立运行的基本单位，线程自己基本上不拥有系统资源。在运行时，只是暂用一些计数器、寄存器和栈。

·

他们之间的关系

1.一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程（通常说的主线程）。

2.资源分配给进程，同一进程的所有线程共享该进程的所有资源。

3.线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。

4.处理机分给线程，即真正在处理机上运行的是线程。

5.线程是指进程内的一个执行单元，也是进程内的可调度实体。

从三个角度来剖析二者之间的区别

1.调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位。

2.并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可以并发执行。

3.拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源。

·共享变量

·wait/notify机制

·Lock/Condition机制

·管道

·线程间发送信号的一个简单方式是在共享对象的变量里设置信号值。线程A在一个同步块里设置boolean型成员变量hasDataToProcess为true，线程B也在同步块里读取hasDataToProcess这个成员变量。这个简单的例子使用了一个持有信号的对象，并提供了set和check方法:

1

2

3

4

5

6

7

8

9

10

11

12

13

publicclassMySignal{

protectedbooleanhasDataToProcess=false;

publicsynchronizedbooleanhasDataToProcess(){

returnthis.hasDataToProcess;

}

publicsynchronizedvoidsetHasDataToProcess(booleanhasData){

this.hasDataToProcess=hasData;

·线程A和B必须获得指向一个MySignal共享实例的引用，以便进行通信。如果它们持有的引用指向不同的MySingal实例，那么彼此将不能检测到对方的信号。需要处理的数据可以存放在一个共享缓存区里，它和MySignal实例是分开存放的。

·为了实现线程通信，我们可以使用Object类提供的wait()、notify()、notifyAll()三个方法。调用wait()方法会释放对该同步监视器的锁定。这三个方法必须由同步监视器对象来调用，这可分成两种情况：

o对于使用synchronized修饰的同步方法，因为该类的默认实例是(this)就是同步监视器，所以可以直接调用这三使用个方法。

o对于synchronized修饰的同步代码块，同步监视器是synchronized括号里的对象，所以必须使用该对象调用这三个方法。

假设系统中有两条线程，这两条线程分别代表取钱者和存钱者。现在系统有一种特殊的要求，系统要求存款者和取钱者不断的实现存款和取钱动作，而且要求每当存款者将钱存入指定账户后，取钱者立即将钱取走.不允许存款者两次存钱，也不允许取钱者两次取钱。我们通过设置一个旗标来标识账户中是否已有存款，有就为true,没有就标为false。具体代码如下:

首先我们定义一个Account类，这个类中有取钱和存钱的两个方法，由于这两个方法可能需要并发的执行取钱、存钱操作，所有将这两个方法都修改为同步方法.(使用synchronized关键字)。

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

publicclassAccount{

privateStringaccountNo;

privatedoublebalance;

//标识账户中是否有存款的旗标

privatebooleanflag=false;

publicAccount(){

super();

publicAccount(StringaccountNo,doublebalance){

this.accountNo=accountNo;

this.balance=balance;

publicsynchronizedvoiddraw(doubledrawAmount){

try{

if(!flag){

this.wait();

}else{

//取钱

System.out.println(Thread.currentThread().getName()+"取钱:"+drawAmount);

balance=balance-drawAmount;

System.out.println("余额:"+balance);

//将标识账户是否已有存款的标志设为false

flag=false;

//唤醒其它线程

this.notifyAll();

}catch(Exceptione){

e.printStackTrace();

publicsynchronizedvoiddeposit(doubledepositAmount){

if(flag){

else{

System.out.println(Thread.currentThread().getName()+"存钱"+depositAmount);

balance=balance+depositAmount;

System.out.println("账户余额为："+balance);

flag=true;

//TODO:handleexception

·接下来创建两个线程类，分别为取钱和存钱线程！

·取钱线程类：

publicclassDrawThreadimplementsRunnable{

privateAccountaccount;

privatedoubledrawAmount;

publicDrawThread(Accountaccount,doubledrawAmount){

this.account=account;

this.drawAmount=drawAmount;

publicvoidrun(){

for(inti=0;i<100;i++){

account.draw(drawAmount);

·存钱线程类：

publicclassdepositThreadimplementsRunnable{

privatedoubledepositAmount;

publicdepositThread(Accountaccount,doubledepositAmount){

this.depositAmount=depositAmount;

account.deposit(depositAmount);

·最后我们测试一下这个取钱和存钱的操作

publicclassTestDraw{

publicstaticvoidmain(String[]args){

//创建一个账户

Accountaccount=newAccount();

newThread(newDrawThread(account,800),"取钱者").start();

newThread(newdepositThread(account,800),"存款者甲").start();

newThread(newdepositThread(account,800),"存款者乙").start();

newThread(newdepositThread(account,800),"存款者丙").start();

·大致的输出结果如下

存款者甲存钱800.0

账户余额为：800.0

取钱者取钱:800.0

余额:0.0

存款者丙存钱800.0

·如何程序不使用synchronized关键字来保持同步，而是直接适用Lock对像来保持同步，则系统中不存在隐式的同步监视器对象，也就不能使用wait()、notify()、notifyAll()来协调线程的运行.

·当使用LOCK对象保持同步时，Java为我们提供了Condition类来协调线程的运行。关于Condition类，JDK文档里进行了详细的解释.，再次就不啰嗦了。

·我们就拿Account类进行稍微的修改一下吧！

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

importjava.util.concurrent.locks.Condition;

importjava.util.concurrent.locks.Lock;

importjava.util.concurrent.locks.ReentrantLock;

//显示定义Lock对象

privatefinalLocklock=newReentrantLock();

//获得指定Lock对象对应的条件变量

privatefinalConditioncon=lock.newCondition();

publicvoiddraw(doubledrawAmount){

//加锁

lock.lock();

//this.wait();

con.await();

//this.notifyAll();

con.signalAll();

finally{

lock.unlock();

publicvoiddeposit(doubledepositAmount){

}finally{

·输出结果和上面是一样的！只不过这里显示的使用Lock对像来充当同步监视器,使用Condition对象来暂停指定线程，唤醒指定线程！

管道流是JAVA中线程通讯的常用方式之一，基本流程如下：

1.

创建管道输出流PipedOutputStreampos和管道输入流PipedInputStreampis

2.

3.

将pos和pis匹配，pos.connect(pis);

4.

5.

将pos赋给信息输入线程，pis赋给信息获取线程，就可以实现线程间的通讯了

6.

81

82

83

84

85

86

87

importjava.io.IOException;

importjava.io.PipedInputStream;

importjava.io.PipedOutputStream;

publicclasstestPipeConnection{

/**

*创建管道输出流

*/

PipedOutputStreampos=newPipedOutputStream();

*创建管道输入流

PipedInputStreampis=newPipedInputStream();

*将管道输入流与输出流连接此过程也可通过重载的构造函数来实现

pos.connect(pis);

}catch(IOExceptione){

*创建生产者线程

Producerp=newProducer(pos);

*创建消费者线程

Consumer1c1=newConsumer1(pis);

*启动线程

p.start();

c1.start();

*

classProducerextendsThread{

privatePipedOutputStreampos;

publicProducer(PipedOutputStreampos){

this.pos=pos;

inti=0;

while(true)

{

this.sleep(3000);

pos.write(i);

i++;

classConsumer1extendsThread{

privatePipedInputStreampis;

publicConsumer1(PipedInputStreampis){

this.pis=pis;

System.out.println("consumer1:"+pis.read());

·程序启动后，就可以看到producer线程往consumer1线程发送数据

consumer1:0

consumer1:1

consumer1:2

consumer1:3

......

管道流虽然使用起来方便，但是也有一些缺点

o

管道流只能在两个线程之间传递数据。线程consumer1和consumer2同时从pis中read数据，当线程producer往管道流中写入一段数据后，每一个时刻只有一个线程能获取到数据，并不是两个线程都能获取到producer发送来的数据，因此一个管道流只能用于两个线程间的通讯。不仅仅是管道流，其他IO方式都是一对一传输。

管道流只能实现单向发送，如果要两个线程之间互通讯，则需要两个管道流。可以看到上面的例子中，线程producer通过管道流向线程consumer发送数据，如果线程consumer想给线程producer发送数据，则需要新建另一个管道流pos1和pis1，将pos1赋给consumer1，将pis1赋给producer，具体例子本文不再多说。

·管道（Pipe）：管道可用于具有亲缘关系进程间的通信，允许一个进程和另一个与它有共同祖先的进程之间进行通信。

·命名管道（namedpipe）：命名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信。命名管道在文件系统中有对应的文件名。命名管道通过命令mkfifo或系统调用mkfifo来创建。

·信号（Signal）：信号是比较复杂的通信方式，用于通知接受进程有某种事件发生，除了用于进程间通信外，进程还可以发送信号给进程本身；Linux除了支持Unix早期信号语义函数sigal外，还支持语义符合Posix.1标准的信号函数sigaction（实际上，该函数是基于BSD的，BSD为了实现可靠信号机制，又能够统一对外接口，用sigaction函数重新实现了signal函数）。

·消息（Message）队列：消息队列是消息的链接表，包括Posix消息队列systemV消息队列。有足够权限的进程可以向队列中添加消息，被赋予读权限的进程则可以读走队列中的消息。消息队列克服了信号承载信息量少，管道只能承载无格式字节流以及缓冲区大小受限等缺

·共享内存：使得多个进程可以访问同一块内存空间，是最快的可用IPC形式。是针对其他通信机制运行效率较低而设计的。往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。

·内存映射（mappedmemory）：内存映射允许任何多个进程间通信，每一个使用该机制的进程通过把一个共享的文件映射到自己的进程地址空间来实现它。

·信号量（semaphore）：主要作为进程间以及同一进程不同线程之间的同步手段。

·套接口（Socket）：更为一般的进程间通信机制，可用于不同机器之间的进程间通信。起初是由Unix系统的BSD分支开发出来的，但现在一般可以移植到其它类Unix系统上：linux和SystemV的变种都支持套接字。

·个人介绍

··springMVC拦截器和过滤器的区别

··excel导出功能如何实现

··SpringIOC和AOP，动态代理实现方式

··自动装配有哪几种方式，自动装配有什么局限性

模式

说明

Default

在每个bean中都一个autowire=default的默认配置它的含义是：

采用beans和跟标签中的default-autowire="属性值"一样的设置。

On

不使用自动装配，必须通过ref元素指定依赖，默认设置。

ByNname

根据属性名自动装配。此选项将检查容器并根据名字查找与属性完全一致的bean，并将其与属性自动装配。例如，在bean定义中将autowire设置为byname，而该bean包含master属性（同时提供setMaster(..)方法），Spring就会查找名为master的bean定义，并用它来装配给master属性。

Bytype

如果容器中存在一个与指定属性类型相同的bean，那么将与该属性自动装配。如果存在多个该类型的bean，那么将会抛出异常，并指出不能使用byType方式进行自动装配。若没有找到相匹配的bean，则什么事都不发生，属性也不会被设置。如果你不希望这样，那么可以通过设置dependency-check="objects"让Spring抛出异常。

Constructor

与byType的方式类似，不同之处在于它应用于构造器参数。如果在容器中没有找到与构造器参数类型一致的bean，那么将会抛出异常。

Antodetect

通过bean类的自省机制（introspection）来决定是使用constructor还是byType方式进行自动装配。如果发现默认的构造器，那么将使用byType方式。

注意：

byName和byType

在使用的过程中必须保证bean能够初始化,否则的话会出现bug

如果有默认的无参数的构造器就不需要多余的配置

如果有带有参数的构造器,那在bean的配置中必须配置器初始化的参数或者在bean中添加无参数的构造器

基本类型不可以装配，精准度易混乱bean必须可以获得

··数据库引擎，Innodb,MyISAM的区别

1.MySQL默认采用的是MyISAM。

2.MyISAM不支持事务，而InnoDB支持。InnoDB的AUTOCOMMIT默认是打开的，即每条SQL语句会默认被封装成一个事务，自动提交，这样会影响速度，所以最好是把多条SQL语句显示放在begin和commit之间，组成一个事务去提交。

4.InnoDB支持外键，MyISAM不支持。

5.InnoDB的主键范围更大，最大是MyISAM的2倍。

6.InnoDB不支持全文索引，而MyISAM支持。全文索引是指对char、varchar和text中的每个词（停用词除外）建立倒排序索引。MyISAM的全文索引其实没啥用，因为它不支持中文分词，必须由使用者分词后加入空格再写到数据表里，而且少于4个汉字的词会和停用词一样被忽略掉。

7.MyISAM支持GIS数据，InnoDB不支持。即MyISAM支持以下空间数据对象：Point,Line,Polygon,Surface等。

8.没有where的count(*)使用MyISAM要比InnoDB快得多。因为MyISAM内置了一个计数器，count(*)时它直接从计数器中读，而InnoDB必须扫描全表。所以在InnoDB上执行count(*)时一般要伴随where，且where中要包含主键以外的索引列。为什么这里特别强调“主键以外”？因为InnoDB中primaryindex是和rawdata存放在一起的，而secondaryindex则是单独存放，然后有个指针指向primarykey。所以只是count(*)的话使用secondaryindex扫描更快，而primarykey则主要在扫描索引同时要返回rawdata时的作用较大。

··索引实现方式，B+树有什么特点，B树和B+数的区别，B+树的实现方式

··索引的最左配原则

··HashMap和HashSet的区别，HashMap是有序的吗

··LinkedHashMap，保证什么有序，底层实现。

··java多线程的方式，FutureTaskCallAble介绍，CallAble和Runnable的区别

··线程池

··类的加载过程，双亲委派机制

1.自我介绍？

分布式缓存的典型应用场景可分为以下几类:

1)页面缓存.用来缓存Web页面的内容片段,包括HTML、CSS和图片等,多应用于社交网站等;

2)应用对象缓存.缓存系统作为ORM框架的二级缓存对外提供服务,目的是减轻数据库的负载压力,加速应用访问;

3)状态缓存.缓存包括Session会话状态及应用横向扩展时的状态数据等,这类数据一般是难以恢复的,对可用性要求较高,多应用于高可用集群;

4)并行处理.通常涉及大量中间计算结果需要共享;

5)事件处理.分布式缓存提供了针对事件流的连续查询(continuousquery)处理技术,满足实时性需求;

6)极限事务处理.分布式缓存为事务型应用提供高吞吐率、低延时的解决方案,支持高并发事务请求处理,多应用于铁路、金融服务和电信等领域.

3.你实习的时候JDK用的是那个版本，这个版本有什么新的特性？

Jdk7的新特性：

1.对集合类的语言支持；(？？)

2.自动资源管理；

3.改进的通用实例创建类型推断；(？？)

4.数字字面量下划线支持；（√）

5.switch中使用string；（√）

JSR292的实现增加了一个InvokeDynamic的字节码指令来支持动态类型语言，使得在把源代码编译成字节码时并不需要确定方法的签名，即方法参数的类型和返回类型。当运行时执行InvokeDynamic指令时，JVM会通过新的动态链接机制MethodHandles，寻找到真实的方法。

为了防止自定义多线程ClassLoad产生的死锁问题，java.lang.ClassLoader类增加了以下API。

4.G1回收器和其他回收器有什么区别？

并发与并行，部分代自己就可以，局部复制全局标记整理堆>4G会比较好。

Java8update20所引入的一个很棒的优化就是G1回收器中的字符串去重（Stringdeduplication）。由于字符串(包括它们内部的char[]数组）占用了大多数的堆空间，这项新的优化旨在使得G1回收器能识别出堆中那些重复出现的字符串并将它们指向同一个内部的char[]数组，以避免同一个字符串的多份拷贝，那样堆的使用效率会变得很低。你可以使用-XX:+UseStringDeduplication这个JVM参数来试一下这个特性。

Java8中最大的改变就是持久代的移除，它原本是用来给类元数据，驻留字符串，静态变量来分配空间的。这在以前都是需要开发人员来针对那些会加载大量类的应用来专门进行堆比例的优化及调整。许多年来都是如此，这也正是许多OutOfMemory异常的根源，因此由JVM来接管它真是再好不过了。即便如此，它本身并不会减少开发人员将应用解耦到不同的JVM中的可能性。

5.垃圾回收为什么会停顿？哪些对象可能作为GCRoots

虚拟机栈中引用的对象方法区（静态属性，常量引用的对象）本地方法栈中引用的对象。

6.垃圾回收分代收集算法？为什么会有两个Survivor区？new一个对象会保存在哪里？

堆

Survivor的存在意义，就是减少被送到老年代的对象，进而减少FullGC的发生，Survivor的预筛选保证，只有经历16次MinorGC还能在新生代中存活的对象，才会被送到老年代。

设置两个Survivor区最大的好处就是解决了碎片化

7.Java内存模型volatile关键字，使用场景？原子性的理解？先行发生原则？

Java内存模型中规定了所有的变量都存储在主内存中，每条线程还有自己的工作内存（可以与前面将的处理器的高速缓存类比），线程的工作内存中保存了该线程使用到的变量到主内存副本拷贝，线程对变量的所有操作（读取、赋值）都必须在工作内存中进行，而不能直接读写主内存中的变量。

·lock（锁定）：作用于主内存的变量，把一个变量标识为一条线程独占状态。

·unlock（解锁）：作用于主内存变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。

·read（读取）：作用于主内存变量，把一个变量值从主内存传输到线程的工作内存中，以便随后的load动作使用

·load（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。

·use（使用）：作用于工作内存的变量，把工作内存中的一个变量值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。

·assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。

·store（存储）：作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write的操作。

·write（写入）：作用于主内存的变量，它把store操作从工作内存中一个变量的值传送到主内存的变量中。

如果要把一个变量从主内存中复制到工作内存，就需要按顺寻地执行read和load操作，如果把变量从工作内存中同步回主内存中，就要按顺序地执行store和write操作。Java内存模型只要求上述操作必须按顺序执行，而没有保证必须是连续执行。也就是read和load之间，store和write之间是可以插入其他指令的，如对主内存中的变量a、b进行访问时，可能的顺序是reada，readb，loadb，loada。Java内存模型还规定了在执行上述八种基本操作时，必须满足如下规则：

·不允许read和load、store和write操作之一单独出现

·不允许一个线程丢弃它的最近assign的操作，即变量在工作内存中改变了之后必须同步到主内存中。

·不允许一个线程无原因地（没有发生过任何assign操作）把数据从工作内存同步回主内存中。

·一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量。即就是对一个变量实施use和store操作之前，必须先执行过了assign和load操作。

·一个变量在同一时刻只允许一条线程对其进行lock操作，lock和unlock必须成对出现

·如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前需要重新执行load或assign操作初始化变量的值

·如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作；也不允许去unlock一个被其他线程锁定的变量。

·对一个变量执行unlock操作之前，必须先把此变量同步到主内存中（执行store和write操作）。

1.作为状态标志

2.一次性安全发布

3.独立观察

4.volatilebean模式

5.开销较低的读写锁策略

Java内存模型中存在的天然的先行发生关系：

1.程序次序规则：同一个线程内，按照代码出现的顺序，前面的代码先行于后面的代码，准确的说是控制流顺序，因为要考虑到分支和循环结构。

4.线程启动规则：Thread的start()方法先行发生于这个线程的每一个操作。

5.线程终止规则：线程的所有操作都先行于此线程的终止检测。可以通过Thread.join()方法结束、Thread.isAlive()的返回值等手段检测线程的终止。

6.线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过Thread.interrupt()方法检测线程是否中断

7.对象终结规则：一个对象的初始化完成先行于发生它的finalize（）方法的开始。

8.传递性：如果操作A先行于操作B，操作B先行于操作C，那么操作A先行于操作C。

8.场景题：现在有三个线程，同时start，用什么方法可以保证线程执行的顺序，线程一执行完线程二执行，线程二执行完线程三执行？

packagecom.wenjie.threadDemo;

publicclassJionTest{

finalThreadt1=newThread(newRunnable(){

//TODOAuto-generatedmethodstub

System.out.println("t1");

});

finalThreadt2=newThread(newRunnable(){

t1.join();

}catch(InterruptedExceptione){

//TODOAuto-generatedcatchblock

System.out.println("t2");

finalThreadt3=newThread(newRunnable(){

t2.join();

System.out.println("t3");

t2.start();

t3.start();

t1.start();

9.你是怎么理解线程安全的？HashMap是线程安全的么？如果多个线程同时修改HashMap时会发生什么情况？

Failfast

死锁

异常concurrentmodeex

11.静态代理和动态代理的区别？动态代理是怎么实现的？

13.你做过hadoop的项目，为什么要用hadoop？你们处理的文件是什么格式的？写了几个mapper几个reducer？

Hbase，json

15.TCP首部？TCP为什么是可靠的？三次握手四次挥手？

TCP提供一种面向连接的、可靠的字节流服务。

面向连接：意味着两个使用TCP的应用（通常是一个客户和一个服务器）在彼此交换数据之前必须先建立一个TCP连接。在一个TCP连接中，仅有两方进行彼此通信。广播和多播不能用于TCP。

TCP通过下列方式来提供可靠性：

1、应用数据被分割成TCP认为最适合发送的数据块。这和UDP完全不同，应用程序产生的数据报长度将保持不变。(将数据截断为合理的长度)

2、当TCP发出一个段后，它启动一个定时器，等待目的端确认收到这个报文段。如果不能及时收到一个确认，将重发这个报文段。

(超时重发)

3、当TCP收到发自TCP连接另一端的数据，它将发送一个确认。这个确认不是立即发送，通常将推迟几分之一秒。(对于收到的请求，给出确认响应)(之所以推迟，可能是要对包做完整校验)

4、TCP将保持它首部和数据的检验和。这是一个端到端的检验和，目的是检测数据在传输过程中的任何变化。如果收到段的检验和有差错，TCP将丢弃这个报文段和不确认收到此报文段。(校验出包有错，丢弃报文段，不给出响应，TCP发送数据端，超时时会重发数据)

5、既然TCP报文段作为IP数据报来传输，而IP数据报的到达可能会失序，因此TCP报文段的到达也可能会失序。如果必要，TCP将对收到的数据进行重新排序，将收到的数据以正确的顺序交给应用层。(对失序数据进行重新排序，然后才交给应用层)

6、既然IP数据报会发生重复，TCP的接收端必须丢弃重复的数据。(对于重复数据，能够丢弃重复数据)

7、TCP还能提供流量控制。TCP连接的每一方都有固定大小的缓冲空间。TCP的接收端只允许另一端发送接收端缓冲区所能接纳的数据。这将防止较快主机致使较慢主机的缓冲区溢出。(TCP可以进行流量控制，防止较快主机致使较慢主机的缓冲区溢出)TCP使用的流量控制协议是可变大小的滑动窗口协议。

字节流服务::

两个应用程序通过TCP连接交换8bit字节构成的字节流。TCP不在字节流中插入记录标识符。我们将这称为字节流服务（bytestreamservice）。

TCP对字节流的内容不作任何解释::TCP对字节流的内容不作任何解释。TCP不知道传输的数据字节流是二进制数据，还是ASCII字符、EBCDIC字符或者其他类型数据。对字节流的解释由TCP连接双方的应用层解释。

17.你平时喜欢做什么？看过哪些书？最近在看什么书？（这里有个段子，我：最近在看《HTTP权威指南》。面试官：什么？HTTP潜规则？我：？？？）

柯南东野圭吾

舞蹈运动电影

二面：(8月2号晚上：视频面试：47分钟)

1.你那边怎么有点黑啊？（我靠，我也想说啊，暑假寝室集中供电，然而我们寝室没有电。发面经也不忘吐槽学校，简直坑啊。。。抱着台灯瑟瑟发抖。。。）

2.现在在哪里实习？实习主要做些什么？

3.说一下Java里面你最感兴趣的一个部分？

并发？

4.熟悉Java的哪些框架？用了Spring的哪些东西？Spring现在最新的版本是多少？

5.讲一下MVC设计模式，有什么框架用到了这个模式？spring

6.场景题：一个Controller调用两个Service，这两Service又都分别调用两个Dao，问其中用到了几个数据库连接池的连接？

7.安全方面：如何防止SQL注入？如何防止用户删除其他用户的信息？表单提交可以跨域么？自己写的接口如何防止被其他人恶意调用？

防止被恶意调用的话，可以做请求限制，第一次请求返回一个随机数，下次请求把随机数带过来，返回时再返回一个随机数

8.zookeeper偶数选举问题？（感觉很重视zookeeper啊）

9.hadoop为什么要将文件分块并且复制三份，复制两份不行么？这样不浪费空间么？namenode脑裂问题？zookeeper如何管理全局配置文件？你们的Hadoop项目用到了几台机器，每个机器的作用？

10.Servlet是线程安全的么？

11.创建一个对象的详细过程？其中发生了些什么？

12.JavaNIO你了解么？讲一讲你最熟悉的部分？

14.你认为你身边的同学怎么样？如果你正在打游戏，你想让同学帮忙带瓶水，你觉得有多少人会帮你带？（这又是什么套路？让我去送水？）

15.你还有什么想问的？

三面：（HR面，8月4号下午：视频面试：22分钟）

1.7岁一个阶段，说一说每一个阶段对你影响最大的一个人或事？

2.说一下你大学阶段做了些什么？

3.你感觉你前两个面试官怎么样？

4.春招的时候为什么没有去bat实习？

5.你当初准备暑期实习的话，是想学到些什么？现在感觉自己有哪些进步？

6.你还有什么想问的？（当然是万能的培养计划和晋升机制）

1.自我介绍？2.说一下最能代表你技术水平的项目吧？

3.maven如何进行依赖管理，如何解决依赖冲突？

1.依赖是使用Maven坐标来定位的，而Maven坐标主要由GAV（groupId,artifactId,version）构成。如果两个相同的依赖包，如果groupId,artifactId,version不同，那么maven也认为这两个是不同的。

2.依赖会传递，A依赖了B，B依赖了C，那么A的依赖中就会出现B和C。

3.Maven对同一个groupId,artifactId的冲突仲裁，不是以version越大越保留，而是依赖路径越短越优先，然后进行保留。

4.依赖的scope会影响依赖的影响范围。

1.确定出了问题的jar包名称。通常可以在eclipse中查找冲突的类有在哪些依赖包里面出现了。并确定实际要使用的是那个包，冲突的包有哪些。

2.通过mvndependency:tree>tree.txt导出全部的依赖。

4.找到相互冲突的并需要排除的依赖的顶级依赖,并分析冲突的原因，冲突的原因可能是以下几种：

·同一个jar包但groupId,artifactId不同，这种冲突只能通过设定依赖的来进行排除

·需要的版本jar包依赖路径较长，这种冲突可以把想要版本的依赖直接什么在依赖中，这样路径就最短了优先级最高。

5.最后可以通过打包mvninstall来确认打出来的war包中是否有被排除的依赖。

4.maven的源和插件了解哪些？maven的生命周期？

5.如何保证分布式缓存的一致性？分布式session实现？

6.spring的bean的创建时机？依赖注入的时机？

7.你们的图片时怎么存储的，对应在数据库中时如何保存图片的信息的？

9.项目中用到的JDK的哪些特性？

10.java8流式迭代的好处？

11.多线程如何在多个CPU上分布？线程调度算法有哪些？

12.线程调度和进程调度的区别？

13.项目中用到了哪些集合类？

14.说一下TreeMap的实现原理？红黑树的性质？红黑树遍历方式有哪些？如果key冲突如何解决？setColor()方法在什么时候用？什么时候会进行旋转和颜色转换？后者覆盖前者保持唯一性

15.你有什么想问的？

下面将最近面试遇到的一些题目进行汇总如下，希望对现在正在找工作的同学和现在面临毕业找工作的同学有所帮助。

单例模式：懒汉式、饿汉式、双重校验锁、静态加载，内部类加载、枚举类加载。保证一个类仅有一个实例，并提供一个访问它的全局访问点。

代理模式：动态代理和静态代理，什么时候使用动态代理。

适配器模式：将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

装饰者模式：动态给类加功能。

观察者模式：有时被称作发布/订阅模式，观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

策略模式：定义一系列的算法,把它们一个个封装起来,并且使它们可相互替换。

外观模式：为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

命令模式：将一个请求封装成一个对象，从而使您可以用不同的请求对客户进行参数化。

创建者模式：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

Set、List、Map的区别和联系

什么时候使用HashMap

什么时候使用LinkedHashMap、ConcurrentHashMap、WeakHashMap

哪些集合类是线程安全的

为什么Set、List、Map不实现Cloneable和Serializable接口

ConcurrentHashMap的实现，1.7和1.8的实现

Arrays.sort的实现

什么时候使用CopyOnArrayList

volatile的使用

Synchronied的使用

ReentrantLock的实现以及和Synchronied的区别

CAS的实现原理以及问题

AQS的实现原理

接口和抽象类的区别，什么时候使用

类加载机制的步骤，每一步做了什么，static和final修改的成员变量的加载时机

双亲委派模型

反射机制：反射动态擦除泛型、反射动态调用方法等

动态绑定：父类引用指向子类对象

JVM内存管理机制：有哪些区域，每个区域做了什么

JVM垃圾回收机制：垃圾回收算法垃圾回收器垃圾回收策略

jvm参数的设置和jvm调优

什么情况产生年轻代内存溢出、什么情况产生年老代内存溢出

内部类：静态内部类和匿名内部类的使用和区别

redis和memcached：什么时候选择redis，什么时候选择memcached，内存模型和存储策略是什么样的

mysql的优化策略有哪些

mysql索引的实现B+树的实现原理

什么情况索引不会命中，会造成全表扫描

java中bionioaio的区别和联系

为什么bio是阻塞的nio是非阻塞的nio的模型是什么样的

Reactor模型和Proactor模型

linux命令统计，排序，前几问题等

StringBuff和StringBuilder的实现，底层实现是通过byte数据，外加数组的拷贝来实现的

cas操作的使用

内存缓存和数据库的一致性同步实现

微服务的优缺点

线程池的参数问题

ip问题如何判断ip是否在多个ip段中

判断数组两个中任意两个数之和是否为给定的值

乐观锁和悲观锁的实现

synchronized实现原理

你在项目中遇到的困难和怎么解决的

你在项目中完成的比较出色的亮点

消息队列广播模式和发布/订阅模式的区别

生产者消费者代码实现

死锁代码实现

线程池：参数，每个参数的作用，几种不同线程池的比较，阻塞队列的使用，拒绝策略

常见序列化协议及其优缺点

memcached内存原理，为什么是基于块的存储

搭建一个rpc需要准备什么

如果线上服务器频繁地出现fullgc，如何去排查

如果某一时刻线上机器突然量变得很大，服务扛不住了，怎么解决

LRU算法的实现

LinkedHashMap实现LRU

定义栈的数据结构，请在该类型中实现一个能够找到栈最小元素的min函数

海量数据处理的解决思路

reactor模型的演变

阻塞、非阻塞、同步、异步区别

Collection的子接口

linux命令，awk、cat、sort、cut、grep、uniq、wc、top等

你觉得你的优点是什么，你的缺点是什么，为什么我们要录用你

Springmvc的实现原理

netty底层实现，IO模型，ChannelPipeline的实现和原理

缓存的设计和优化

缓存和数据库一致性同步解决方案

你所在项目的系统架构，谈谈整体实现

消息队列的使用场景

ActiveMQ、RabbitMQ、Kafka的区别

JVM内存分配策略和垃圾回收时机

JVM垃圾回收策略和对象的实际生命周期

对象是如何在堆中分配的

fullgc触发的场景，线上如果一直fullgc怎么排查

如何防止接口被恶意攻击

线上某一台服务器出现问题，如何实际操作去解决

线上接口最大的QPS以及如何评估服务器可承受的最大请求数

内存缓存的使用场景和优缺点

怎么防止线上接口被恶意刷

怎么防止线上接口被攻击

栈帧的结构

transient关键字的使用

hashMap可以key为空或者value为空吗？可以同时为空吗？

HashSet有什么特点？

话题二：

HashMap底层是怎么实现的？

1.6：数组+链表

1.8：数组+链表/红黑树

为什么要二次hash？谈谈扩容|什么时候扩容？

HashMap与Hashtable有什么区别吗？

Hashtable加同步锁有什么问题？能不能有更好的实现方式？

ConcurrentHashMap底层怎么实现的？怎么保证同步的（CAS）？

话题三：

如果前面的，你都答出来了？

什么是CAS？它synchronized有什么区别？

谈谈synchronized？

能谈一下volatile吗？

6、JVM连环炮+并发编程？

话题一：

1、谈谈内存区域？

堆、栈、方法区、（程序计算器、本地方法栈）|可以不谈

2、堆、栈、方法区分别有什么用？存储什么内容？

3、能谈谈堆吗？

新生代、老年代

4、怎么判断对象不可用？

5、能谈一下GC策略吗？它是怎么回收不可用对象的？

标记-清除，复制、标记-整理、分代。

6、能谈一下垃圾回收器吗(暂无碰见问的)

7、对象怎么分配的？

1、谈一下类加载过程？

2、谈一下双亲委派机制？

1、谈一下Java内存模型

2、谈一下Synchronized、volatile？

2、谈一下AQS、CountDownLatch、ReentrantLock？（暂时还没有人问）

3、谈一下ThreadLocal？

4、谈一下CAS？

5、谈一下线程池原理？

二、设计模式

1、谈一下六种设计原则？开闭原则什么意思？里氏XX是什么意思？

2、写一个单例模式？后续自己扩展各种的优缺点？

3、谈一个你熟悉的设计模式？

三、缓存

1、设计一个高效的缓存？

2、谈谈LRU算法？（解决高效的缓存）

三、架构思想、高并发、大数据量解决方案。

1、一个很大的日记文件，统计出访问排行？

2、mapreduce思想？谈谈shuffle？

1、unordered_map的实现原理。。很具体的描述

2、单链表多路归并排序

有一个场景，现在cache满了，需要淘汰频率最低的那个

更新：0824华为

关于HTTP请求GET和POST的区别

1.GET提交，请求的数据会附在URL之后（就是把数据放置在HTTP协议头＜request-line＞中），以分割URL和传输数据，多个参数用&连接;例如：login.actionname=hyddd&password=idontknow&verify=%E4%BD%A0%E5%A5%BD。如果数据是英文字母/数字，原样发送，如果是空格，转换为+，如果是中文/其他字符，则直接把字符串用BASE64加密，得出如：%E4%BD%A0%E5%A5%BD，其中％XX中的XX为该符号以16进制表示的ASCII。

POST提交：把提交的数据放置在是HTTP包的包体＜request-body＞中。上文示例中红色字体标明的就是实际的传输数据

因此，GET提交的数据会在地址栏中显示出来，而POST提交，地址栏不会改变

2.传输数据的大小：

GET:特定浏览器和服务器对URL长度有限制，例如IE对URL长度的限制是2083字节(2K+35)。对于其他浏览器，如Netscape、FireFox等，理论上没有长度限制，其限制取决于操作系统的支持。

因此对于GET提交时，传输数据就会受到URL长度的限制。

POST:由于不是通过URL传值，理论上数据不受限。但实际各个WEB服务器会规定对post提交数据大小进行限制，Apache、IIS6都有各自的配置。

3.安全性：

Http协议：一个HTTP请求报文由请求行（requestline）、请求头部（header）、空行和请求数据4个部分组成，下图给出了请求报文的一般格式。

请求行由请求方法字段、URL字段和HTTP协议版本字段3个字段组成，它们用空格分隔。例如，GET/index.htmlHTTP/1.1。

请求头部由关键字/值对组成，每行一对，关键字和值用英文冒号“:”分隔。请求头部通知服务器有关于客户端请求的信息，典型的请求头有：

User-Agent：产生请求的浏览器类型。

Accept：客户端可识别的内容类型列表。

Host：请求的主机名，允许多个域名同处一个IP地址，即虚拟主机。

HTTP响应也由三个部分组成，分别是：状态行、消息报头、响应正文。

HTTP：是互联网上应用最为广泛的一种网络协议，是一个客户端和服务器端请求和应答的标准（TCP），用于从WWW服务器传输超文本到本地浏览器的传输协议，它可以使浏览器更加高效，使网络传输减少。

HTTPS：是以安全为目标的HTTP通道，简单讲是HTTP的安全版，即HTTP下加入SSL层，HTTPS的安全基础是SSL，因此加密的详细内容就需要SSL。

HTTPS协议的主要作用可以分为两种：一种是建立一个信息安全通道，来保证数据传输的安全；另一种就是确认网站的真实性。

HTTPS和HTTP的区别主要如下：

对称密码加解密，非对称密码加解密。

事务隔离级别和实现方式。

遇到问题：分布式加锁问题：

memcached分布式锁:1、实现原理：

memcached带有add函数，利用add函数的特性即可实现分布式锁。add和set的区别在于：如果多线程并发set，则每个set都会成功，但最后存储的值以最后的set的线程为准。而add的话则相反，add会添加第一个到达的值，并返回true，后续的添加则都会返回false。利用该点即可很轻松地实现分布式锁。

2、优点

并发高效。

3、缺点

效率对库依赖比较重，重量级

（1）memcached采用列入LRU置换策略，所以如果内存不够，可能导致缓存中的锁信息丢失。

（2）memcached无法持久化，一旦重启，将导致信息丢失。

Redis：redis分布式锁即可以结合zk分布式锁锁高度安全和memcached并发场景下效率很好的优点，可以利用jedis客户端实现。

URL到页面相应的全过程：

浏览器缓存etc缓存路由缓存服务提供商缓存递归到根dns,请求连接TCP。发送报文，恢复

SpringAOP开发用到了那些部分？

==一般只用到了基本数据类型比较

1、equals方法用于比较对象的内容是否相等（覆盖以后）

2、hashcode方法只有在集合中用到

3、当覆盖了equals方法时，比较对象是否相等将通过覆盖后的equals方法进行比较（判断对象的内容是否相等）。

4、将对象放入到集合中时，首先判断要放入对象的hashcode值与集合中的任意一个元素的hashcode值是否相等，如果不相等直接将该对象放入集合中。如果hashcode值相等，然后再通过equals方法判断要放入对象与集合中的任意一个对象是否相等，如果equals判断不相等，直接将该元素放入到集合中，否则不放入。

J2SE基础

1.九种基本数据类型的大小，以及他们的封装类。

基本类型

大小(字节)

默认值

封装类

byte

(byte)0

Byte

short

(short)0

Short

int

0

Integer

long

0L

Long

float

0.0f

Float

double

0.0d

Double

boolean

-

false

Boolean

char

\u0000(null)

Character

void

Void

2.Switch能否用string做参数？

3.equals与==的区别。

4.Object有哪些公用方法？

Waitnotifynotifyallcloneequelsgetclass

5.Java的四种引用，强弱软虚，用到的场景。

6.Hashcode的作用。

7.ArrayList、LinkedList、Vector的区别。

8.String、StringBuffer与StringBuilder的区别。

9.Map、Set、List、Queue、Stack的特点与用法。

10.HashMap和HashTable的区别。

11.HashMap和ConcurrentHashMap的区别，HashMap的底层源码。

12.TreeMap、HashMap、LindedHashMap的区别。

13.Collection包结构，与Collections的区别。

14.trycatchfinally，try里有return，finally还执行么？

15.Excption与Error包结构。OOM你遇到过哪些情况，SOF你遇到过哪些情况。

16.Java面向对象的三个特征与含义。

17.Override和Overload的含义去区别。

18.Interface与abstract类的区别。

19.Staticclass与nonstaticclass的区别。

20.java多态的实现原理。

同一操作不同结果，前期绑定后期绑定

21.实现多线程的两种方法：Thread与Runable。Call

22.线程同步的方法：sychronized、lock、reentrantLock等。

23.锁的等级：方法锁、对象锁、类锁。

24.写出生产者消费者模式。

25.ThreadLocal的设计理念与作用。ThreadThreadLocal->ThreadLocalMap

26.ThreadPool用法与优势。

27.Concurrent包里的其他东西：ArrayBlockingQueue、CountDownLatch等等。

28.wait()和sleep()的区别。

29.foreach与正常for循环效率对比。

30.JavaIO与NIO。

31.反射的作用于原理。

32.泛型常用特点，List能否转为List