按牛客网讨论区笔经面经的发表时间排序。
阿里内推,蚂蚁金服---java开发工程师第一次电话面试
1.TCP三次握手?
(记住1.过程;2.状态变化;3.几个常见问题)
第一次:客户端给服务器发送syn包x;SYN_SENT
第二次:服务器接收到syn包,返回一个syn包y 和 一个ack包x+1; SYN_RECV
第三次:客户端收到syn+ack包,向服务器发送ack包。ESTABLISHED
为什么三次握手?
防止已失效的连接请求报文段重传。
四次挥手?
把三次握手的第二次分解,先发ack包,再发fin包。
第一次:主动关闭方发送fin包x,关闭数据传送; FIN_WAIT1 CLOSE_WAIT
第二次:被动方发送ack包x+1; FIN_WAIT2
第三次:被动方发送fin包y,关闭数据传送; TIME_WAIT LASH_ACK
第四次:主动方发送ack包y+1;
为什么四次握手?
被动方收到FIN包时,并不会立即关闭socket,所以先回复一个ack包。等到被动方所有数据发送完,再发fin包。
为什么TIME_WAIT/等待2MSL?
MSL是报文最大生存时间;主动方发出最后一个ACK包进入TIME_WAIT状态,目的是防止最后一个ACK包对方没接收到,那么对方在超时后将重发第三次握手的FIN包。 A->ACK->B,等待ACK到达对方时间MSL,等待FIN超时重传MSL,所以如果2MSL时间没有收到FIN,说明对方安全收到FIN。
2.在浏览器访问一个网址的过程?
1.首先浏览器通过DNS解析网址的IP地址,通过IP找到服务器路径;
2.根据IP地址向服务器发送一个HTTP请求;
3.服务器收到请求,返回响应;
4.浏览器对网页解析,渲染显示。
涉及各层协议?
应用层:HTTP、DNS、(DNS解析域名为目的IP,通过IP找到服务器路径,客户端向服务器发起HTTP会话)
传输层:TCP、 (HTTP会话会被分成报文段,添加源、目的端口;TCP协议进行主要工作)
网际层:IP、(ARP)、ICMP、(为数据包选择路由,IP协议进行主要工作)
链路层:PPP、(ARP)(发送IP数据包到达服务器的地址,ARP协议将IP地址转成MAC地址)
3.Linux文件的权限;
4.排序算法有哪些?时间复杂度是?
(还需要记住最好最坏时间复杂度、稳定性)
O(n^2):
选择排序:O(n^2)、O(n^2); 不稳定
冒泡排序:O(n)、O(n^2); 稳定
插入排序:O(n)、O(n^2); 稳定
O(nlogn):
快速排序:O(nlogn)、O(n^2);空间:O(logn) 不稳定
归并排序:O(nlogn)、O(nlogn);空间:O(n) 稳定
堆排序:O(nlogn)、O(nlogn);空间:O(1) 稳定
5.在线编程?
阿里一面17分钟
1.==和equals的区别?
(1.基本类型; 2.基本类型封装;3.String;4.非字符串变量)
equals()是Object类的方法;
(1) 如果是基本类型比较,那么只能用==来比较,用equals会编译错误,因为不是对象。int a = 3;
(2) 对于基本类型的包装类型,比如Boolean、Character、Byte、Shot、Integer、Long、Float、Double等的引用变量,==是比较地址的,而equals是比较内容的。Integer n1 = new Integer(30);
(2.5)对于String a = “a”; Integer b = 1;这种类型的特有对象创建方式,==的时候值是相同的。
(3)对于字符串变量来说,使用“==”和“equals()”方法比较字符串时,其比较方法不同。
“==”比较两个变量本身的值,即两个对象在内存中的首地址。
“equals()”比较字符串中所包含的内容是否相同。
String s1 = "123";
String s2 = "123";
String s4 = new String("123");
String s5 = new String("123");
s1==s2 true; s1.equals(s2) true;
s4==s5 false; s4.equals(s5) true;
s1==s4 false; s1.equals(s4) true;
s1/s2分别指向字符串常量"123"创建的对象,在常量池里只有一个对象,内容为"123";
s4/s5两个引用对象指向的对象内容相同,但是new操作符创建的,内存中分配两块空间给这两个对象,所以内存地址不同。
(4)对于非字符串变量来说,"=="和"equals"方法的作用是相同的都是用来比较其对象在堆内存的首地址,即用来比较两个引用变量是否指向同一个对象。
2.string是不是基本数据类型,
不是,String是类类型,基本类型有八种:
整型4种:byte/short/int/long 字节数:1/2/4/8
字符型1种:char 2
浮点型2种:float/double 4/8
布尔型1种:boolean 1/8
一个字节等于8位,等于256个数,就是-128到127
大写的B表示Bytes=字节;小写的b表示bit=位;1byte=8bit;
自动转换:(小可转大,大转小会失去精度)
byte -> short/char -> int -> long -> float -> double
3.char能不能存放汉字?
能,一个char字符可以存储一个中文汉字。
4.error/exception/runtime exception区别?
Error和Exception都实现了Throwable接口
Error指的是JVM层面的错误,比如内存不足OutOfMemoryError
Exception 指的是代码逻辑的异常,比如下标越界OutOfIndexException
Exception分为可查异常CheckedException和运行时异常RuntimeException:
可查异常是必须处理的异常,要么try catch住,要么往外抛,谁调用,谁处理,比如 FileNotFoundException、IOException、SQLException等。如果不处理,编译器就不让你通过。
运行时异常 又叫做非可查异常,在编译过程中,不要求必须进行显示捕捉。
常见的Runtime Excepiton?
NullPointerException 空指针异常
ArithmeticException 算术异常,比如除数为零
ClassCastException 类型转换异常
ConcurrentModificationException 同步修改异常,遍历一个集合的时候,删除集合的元素,就会抛出该异常
IndexOutOfBoundsException 数组下标越界异常
NegativeArraySizeException 为数组分配的空间是负数异常
为什么分两种异常?
Java之所以会设计运行时异常的原因之一,是因为下标越界,空指针这些运行时异常太过于普遍,如果都需要进行捕捉,代码的可读性就会变得很糟糕。
5.object类的方法?
9种;(简要介绍各方法)
1.对象的复制/获取/String/释放:clone/getClass/toString/finalize;
2.hash:equals/hashCode;
3.多线程:wait/notify/notifyAll
clone:实现对象的浅复制;
getClass:获得运行时类对象;
finalize:用于释放资源;
equals:比较对象是否相等;基本类型不可以用equals,对于String类型“equals”和“==”作用不同;
hashcode:用于hash寻找;
wait:使当前线程等待该对象的锁,当前线程必须是该对象的拥有者,也就是具有该对象的锁;wait()方法一直等待,直到获得锁或者被中断。wait(longtimeout)设定一个超时间隔,如果在规定时间内没有获得锁就返回。
调用该方法后当前线程进入睡眠状态,直到以下事件发生:
(1)其他线程调用了该对象的notify方法。
(2)其他线程调用了该对象的notifyAll方法。
(3)其他线程调用了interrupt中断该线程。
(4)时间间隔到了。
此时该线程就可以被调度了,如果是被中断的话就抛出一个InterruptedException异常。
notify:唤醒在该对象上等待的某个线程
6.jvm垃圾回收?
7.linux查看日志文件的方式?
蚂蚁金服Java面经
1.Java都学了些什么?
答:集合、IO、多线程、框架等等
2.说说多线程吧
答:说了一下多线程的实现,同步,优化
(tips:对于大范围的内容要整理出目录,不然会很乱。)
进程和线程的区别 感觉有点偏题就不写了
多线程的实现?
三种方法:1.继承Thread类;2.实现Runnable接口;3.使用Executor创建线程池;
多线程的同步?
(1)同步方法:synchronized修饰的方法;
(2)同步代码块:同步是一种高开销的操作,因此应该尽量减少同步的内容。通常没有必要同步整个方法,使用synchronized代码块同步关键代码即可。
同步方法和同步代码块的区别是什么?
答:同步方法默认用this或者当前类class对象作为锁; 同步代码块可以选择以什么来加锁,比同步方法要更细颗粒度,我们可以选择只同步会发生同步问题的部分代码而不是整个方法。
(3)使用volatile实现同步:每次线程要访问volatile修饰的变量时都是从内存中读取,而不是从缓存当中读取,因此每个线程访问到的变量值都是一样的。这样就保证了同步。
(4)使用重入锁实现线程同步:ReentrantLock是concurrent包的类;常用方法有lock()和unlock();可以创建公平锁;支持非阻塞的tryLock(可超时);需要手动释放锁。
(5)使用ThreadLocal实现线程同步:每个线程都创建一个变量副本,修改副本不会影响其他线程的副本。ThreadLocal并不能替代同步机制,两者面向的问题领域不同。同步机制是为了同步多个线程对相同资源的并发访问,是为了多个线程之间进行通信的有效方式;而ThreadLocal是隔离多个线程的数据共享,从根本上就不在多个线程之间共享资源(变量)。
多线程的优化?
影响多线程性能的问题:死锁、过多串行化、过多锁竞争等;
预防和处理死锁的方法:
1)尽量不要在释放锁之前竞争其他锁;一般可以通过细化同步方法来实现;
2)顺序索取锁资源;
3)尝试定时锁tryLock();
降低锁竞争方法:
1)缩小锁的范围,减小锁的粒度;
2)使用读写分离锁ReadWriteLock来替换独占锁:来实现读-读并发,读-写串行,写-写串行的特性。这种方式更进一步提高了可并发性,因为有些场景大部分是读操作,因此没必要串行工作。
3.说一下线程池,线程池里面的线程的状态有哪些?
线程池:
(1.创建;2.参数;)
线程池的顶级接口是Executor,是执行线程的工具;真正的线程池接口是ExecutorService。ThreadPoolExecutor是ExecutorService的默认实现。
ThreadPoolExecutor的参数有:
corePoolSize - 池中所保存的线程数,包括空闲线程。
maximumPoolSize-池中允许的最大线程数。
keepAliveTime - 当线程数大于核心时,此为终止前多余的空闲线程等待新任务的最长时间。
unit - keepAliveTime 参数的时间单位。
workQueue - 执行前用于保持任务的队列。此队列仅保持由 execute方法提交的 Runnable任务。
threadFactory - 执行程序创建新线程时使用的工厂。
handler - 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序。
线程的状态:(把那张图将熟悉)
包括New、Runnable、Running、Blocked、Dead状态;
1)New:Thread t = new Thread();
2)Runnable:t.start()后进入Runnable状态;位于可运行线程池中,等待被线程调度选中,获得CPU使用权;
3)Running:Runnable状态的线程获得了cpu时间片;
4)Blocked:三种情况;
1.等待阻塞:o.wait(),释放锁;进入等待队列;o.notify()/notifyAll() 进入锁池;
2.同步阻塞:同步锁被别的线程占用;进入锁池;
3.其他阻塞:1)Thread.sleep();2)t2.join();3)等待用户输入(发出I/O请求);不会释放锁;当sleep时间结束,t2线程结束,I/O处理完成后进入Runnable状态;
5)Dead:run()/main()执行结束 或者 异常退出;线程结束生命周期。
4.数据结构学了些什么?
数组、HashMap、栈、队列、链表、树;(HashMap也算?)
(把方向引向自己擅长的部分)
5.Hashmap和Hashtable的区别?
相同点:都实现了Map接口;
不同点-两个方面:null值,同步;
HashMap允许键和值是null,HashTable不允许;
HashTable是同步的,HashMap不是;
6.Hashmap的数据结构,Hash的具体实现(这块答得不好)
(讲HashMap:1.结构+原理;2.其他参数-容量、负荷系数、阈值;)
1)HashMap是有数组+链表组成,Entry数组是HashMap的主体,链表是为了解决Hash冲突;
2)HashMap的Entry数组的元素可以看作是一个个散列桶,每个桶是一个单链表;每个Entry内部类有四个字段:key/value/hash/next;
3)执行put时,根据key的hashcode定位到桶;遍历单链表,利用key.equals()检查key是否存在;如果存在则覆盖;否则新建Entry放在头部;
4)执行get时,根据key的hashcode定位到桶;遍历单链表,利用key.equals()获取对应的Entry,返回它的value;
5)参数:容量capacity(默认16)、负载系数loadFactor(默认0.75)、阈值threshold=容量*负载系数。数组容量capacity必须是2的n次方,当键值对个数>threshold(12)时,扩容:将数组扩容为原来容量的二倍。
几点补充:
1)根据hashcode定位桶步骤:
int hash = hash(key.hashCode()); //计算key.hashcode()的hash值,hash函数由hashmap自己实现 int i = indexFor(hash, table.length);//获取将要存放的数组下标
也就是首先计算key的hashcode(),再对该值map的自定义hash()(将hash值打散,使插入的Entry落在不同的桶上,提高查询效率),再根据得到的hash值调用indexFor()方法;indexFor(h,length)方法:将hash值与entry数组的长度-1按位与;
/** * "按位与"来获取数组下标 */ static int indexFor(int h, int length) { return h & (length - 1); }
2)为什么保持Entry数组大小2的n次方?
当length总是2的n次方时,h& (length-1)运算等价于对length取余,也就是h%length,但是&比%具有更高的效率。
参考:HashMap源码
7.设计模式有了解吗?
答:谈了一下单例模式、工厂模式、代理模式,顺便说了一下Spring的AOP是基于代理模式的,可以实现日志记录等功能。
代理模式
8.数据库事务你了解吗?脏读是什么,幻读是什么?
(说一下事务的四个特性+四个冲突+四个隔离级别)
阿里内推一面,已跪
[阿里] [c++]
1.讲一下Linux下如何将源文件逐步编译成目标文件的过程
2.你简历上写熟悉TCP/IP协议,那你说一下TCP的报头吧。
/*TCP头定义,共20个字节*/
typedef struct _TCP_HEADER
{
short m_sSourPort; // 源端口号16bit
short m_sDestPort; // 目的端口号16bit
unsigned int m_uiSequNum; // 序列号32bit
unsigned int m_uiAcknowledgeNum; // 确认号32bit
short m_sHeaderLenAndFlag; // 前4位:TCP头长度;中6位:保留;后6位:标志位
short m_sWindowSize; // 窗口大小16bit
short m_sCheckSum; // 检验和16bit
short m_surgentPointer; // 紧急数据偏移量16bit
}__attribute__((packed))TCP_HEADER, *PTCP_HEADER;
3. 你简历上写的掌握常用的数据结构和排序算法,那你说一个你熟悉的排序算法吧,冒泡就不用说了 。(注:原理+复杂度+手写代码)
排序主要用这六种:
O(n^2)的有:冒泡排序、插入排序、选择排序;
O(nlogn)的有:快排、归并排序、堆排序;
冒泡排序:原理是无序区两两比较,每趟得到一个最大的放在无序区最后;
算法:外循环是趟数[0,n-1), 内循环是无序区个数[0, n-i-1);循环体是比较[j]和[j+1];
插入排序:是把数组分成有序区和无序区两部分,每次从无序区取出一位作为tar值,从后向前遍历有序区,大于tar则后移,最后放到目标位置;
算法:外循环是无序区长度[1,n);定义a[i]为tar值;内循环j指向i,比较a[j-1]与tar,大于则往后顺移a[j-1];最后a[j]赋值;
选择排序:也是分为有序区和无序区,每次从无序区选择一位最小的放到有序区末尾;
算法:外循环是趟数[0,n-1), 内循环是无序区个数[i+1,n);循环体是比较[i]和[j];
快排:每次排序确定一个数的位置,比该数小的移到左边,大的移到右边。一趟快排的算法是:
- 设置两个首尾指针lo、hi;
- 以第一个元素作为key值;
- 从hi向前搜索,如果大于key则hi--,小于key则[lo]=[hi]把[hi]移到前面;
- 从lo向后搜搜,如果小于key则lo++,大于key则[hi]=[lo]把[lo]移到后面;
- 重复3、4步骤,直到lo=hi;返回lo位置。
上述过程就是partition函数;以partition函数返回的位置,对左右两边递归。
算法:(如上)partition(a,lo,hi)函数:定义key,while循环(lo<hi),内部(lo<hi && a[hi]>=key);最后a[lo]赋值,返回lo; sort(a,lo,hi)函数:判断(lo<hi),index,递归;
归并排序:将数组分成若干个小数组,将已有序的数组两两归并得到完全有序数组。每趟归并的算法是:
- 申请空间tmp[],大小是两个已排数组的和,[hi-lo+1];
- 设定两个指针,分别指向两个已排数组的起始位置;
- 比较两个指针元素的值,选择小的元素放到tmp[]里,并移动指针;
- 重复步骤3,直到某一指针到数组尾;
- 将另一序列剩下的所有元素复制到tmp[]里;
- 将tmp[]数组覆盖原num[]数组;
算法:merge(a,lo,mid,hi)方法:tmp[]数组,左右指针+临时指针,比较两数组小的保存,保存剩余数组,赋值数组;mergeSort(a,lo,hi) mid, if()判断:左右递归,merge();注意左右递归一定是左边(lo,mid),右边(mid+1, hi);因为mid偏左,不然会死循环。
堆排序:堆排序包括两个过程,首先是根据元素建堆,时间复杂度O(n),然后将堆的根节点取出(与最后一个节点交换),将前面N-1个节点进行堆调整。直至所有节点都取出。堆调整时间复杂是O(lgn),调用了n-1次,所以堆排序时间复杂度是O(nlgn);
- 建堆:建堆是不断调整堆的过程;从len/2出开始调整(最后一个父节点)。最后一层父节点最多下调1次,倒数第二层最多下调2次,顶点最多下调H=logN次。而最后一层父节点共有2^(H-1)个,倒数第二层公有2^(H-2),顶点只有1(2^0)个,所以总共的时间复杂度为s = 1 * 2^(H-1) + 2 * 2^(H-2) + ... + (H-1) * 2^1 + H * 2^0。将H代入后s= 2N - 2 - log2(N),近似的时间复杂度就是O(N)。
- 调整堆:思想是比较节点i和它的孩子节点left(i),right(i),若i不是最大则调换。
* JDK动态代理只能对实现了接口的类生成代理,而不能针对类
* CGLIB是针对类实现代理,主要是对指定的类生成一个子类,覆盖其中的方法。
数据链路层:将比特组装成帧和点到点的传递( 帧Frame) PPP点对点协议、ARP地址解析协议;
传输层:提供端到端的可靠报文传递和错误恢复( 段Segment) TCP、UDP
会话层:建立、管理和终止会话(会话协议数据单元SPDU)
表示层:对数据进行翻译、加密和压缩(表示协议数据单元PPDU)
应用层:允许访问OSI环境的手段(应用协议数据单元APDU)FTP、DNS、HTTP
1.ArrayList和LinkedList的区别
三个方面:1.实现;2.查询、增删;3.内存;
2.知道乐观锁,悲观锁么?什么情况下用乐观什么情况下用悲观么?
乐观锁:默认读数据的时候不会修改,所以不会上锁;
悲观锁:默认读数据的时候会修改,所以会上锁;
乐观锁适用于多读写比较少的情况,省去锁的开销,加大系统的吞吐量。
3.volatile关键字的作用?i++是原子性的么?
在当前的Java内存模型下,线程可以把变量保存在本地内存(比如机器的寄存器)中,而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值,而另外一个线程还继续使用它在寄存器中的变量值的拷贝,造成数据的不一致。
要解决这个问题,只需要像在本程序中的这样,把该变量声明为volatile(不稳定的)即可,这就指示JVM,这个变量是不稳定的,每次使用它都到主存中进行读取。一般说来,多任务环境下各任务间共享的标志都应该加volatile修饰。
Volatile修饰的成员变量在每次被线程访问时,都强迫从共享内存中重读该成员变量的值。而且,当成员变量发生变化时,强迫线程将变化值回写到共享内存。这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个值。
使用volatile关键字修饰变量,线程要访问变量时都是从内存中读取,而不是从缓存当中读取,因此每个线程访问到的变量值都是一样的。
i++不是原子操作,分为三个阶段:内存到寄存器、寄存器自增、写会内存;这三个阶段中间都可以被中断分离开.
4.Java内存模型?为什么设置工作内存和主内存?
PS:JVM内存模型和JMM(Java内存模型)没有关系。JMM的目的是为了解决Java多线程对共享数据的读写一致性问题。
1.Lambda表达式的形式化表示如下所示
Parameters -> an expression
2.如果Lambda表达式中要执行多个语句块,需要将多个语句块以{}进行包装,如果有返回值,需要显示指定return语句,如下所示:
Parameters -> {expressions;};
3.如果Lambda表达式不需要参数,可以使用一个空括号表示,如下示例所示
() -> {for (int i = 0; i < 1000; i++) doSomething();};
5.如果Lambda表达式只有一个参数,并且参数的类型是可以由编译器推断出来的,则可以如下所示使用Lambda表达式,即可以省略参数的类型及括号
Stream.of(datas).forEach(param -> {System.out.println(param.length());});
参考:lambda表达式
9.设计模式知道么?
单例模式、工厂模式、观察者模式;
单例模式:
1.特点:
- 只能有一个实例;
- 必须自己创建自己的唯一实例;
- 必须给其他对象提供这一实例;
2.单例模式有两种写法:饿汉式和懒汉式;饿汉式是一旦类加载了,就把单例初始化完成;而懒汉式只有在调用getInstance的时候,才初始化这个单例。
3.懒汉式单例:
a.写代码(构造方法,创建实例,get);
b.非线程安全;
c.三种线程安全的代码+优缺点
syn:每次获取都需要同步,影响性能;
双重检查:判空后锁住类;为什么要第二次检查?创建实例的操作非原子化;在getInstance中做了两次null检查,确保了只有第一次调用单例的时候才会做同步,这样也是线程安全的,同时避免了每次都同步的性能损耗;
静态内部类:LazyHolder;利用了classloader的机制来保证初始化instance时只有一个线程,所以也是线程安全的,同时没有性能损耗;
4.饿汉式单例:线程安全;在类创建的同事就实例化一个静态对象出来。
工厂模式:
见印象笔记/设计模式;工厂方法模式和抽象工厂模式区别;
观察者模式:
角色:抽象观察者-update、具体观察者、抽象被观察者-attach/detach/notify、具体被观察者;
使用场景:一个对象状态更新,其他对象同步更新,只需要将自己更新通知给其他对象而不需要知道其他对象细节。解耦,各自变换互不影响。
10.项目难点?