一、Java基础
1.String类为什么是final的。
2.HashMap的源码，实现原理，底层结构。
3.反射中，Class.forName和classloader的区别
4.session和cookie的区别和联系，session的生命周期，多个服务部署时session管理。
5.Java中的队列都有哪些，有什么区别。
Java中的队列都有哪些，实际上是问queue的实现有哪些，如：ConcurrentLinkedQueue、LinkedBlockingQueue 、ArrayBlockingQueue、LinkedList。
源于我经历过的一次生产事故，有个服务会收集业务系统的日志，此服务的开发人员在给业务系统的sdk中就因为使用了LinkedList，又没有做并发控制，就造成了此服务经常不能正常收集到业务系统的日志(丢日志以及日志上报的线程停止运行)。
看一下add()方法的源码，我们就可以知道原因了：
public boolean add(E e) {
linkLast(e);//调用linkLast，在队列尾部添加元素
return true;
}
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;//多线程情况下，如果业务系统没做并发控制，size的数量会远远大于实际元素的数量
modCount++;
}上面这个示例中，展示了LinkedList在多线程且没有做并发控制的环境下，size的值远远大于了队列的实际值，100个线程，每个添加1000个元素，最后实际只加进去2030个元素：
List的变量size值为：88371
第2031个元素取出为null
解决方案，使用锁或者使用ConcurrentLinkedQueue、LinkedBlockingQueue等支持添加元素为原子操作的队列。
我们已经分析过LinkedBlockingQueue的put等方法的源码，是使用ReentrantLock来实现的添加元素原子操作。那么再简单看一下高并发queue的add和offer(）方法，方法中使用了CAS来实现的无锁的原子操作：
public boolean add(E e) {
return offer(e);
}public boolean offer(E e) {
checkNotNull(e);
final Node<E> newNode = new Node<E>(e);
for (Node<E> t = tail, p = t;;) {
Node<E> q = p.next;
if (q == null) {
// p is last node
if (p.casNext(null, newNode)) {
// Successful CAS is the linearization point
// for e to become an element of this queue,
// and for newNode to become "live".
if (p != t) // hop two nodes at a time
casTail(t, newNode); // Failure is OK.
return true;
}
// Lost CAS race to another thread; re-read next
}else if (p == q)
// We have fallen off list. If tail is unchanged, it
// will also be off-list, in which case we need to
// jump to head, from which all live nodes are always
// reachable. Else the new tail is a better bet.
p = (t != (t = tail)) ? t : head;
else
// Check for tail updates after two hops.
p = (p != t && t != (t = tail)) ? t : q;
}
}接下来，我们再利用高并发queue对上面的demo进行改造，大家只要改变demo中的内容，讲下面两行的注释内容颠倒，即可发现没有丢失任何的元素：
public static LinkedList list = new LinkedList();
//public static ConcurrentLinkedQueue list = new ConcurrentLinkedQueue();再看一下高性能queue的poll()方法，才觉得NB，取元素的方法也用CAS实现了原子操作，因此在实际使用的过程中，当我们不那么在意元素处理顺序的情况下，队列元素的消费者，完全可以是多个，不会丢任何数据：
public E poll() {
restartFromHead:
for (;;) {
for (Node<E> h = head, p = h, q;;) {
E item = p.item;
if (item != null && p.casItem(item, null)) {
// Successful CAS is the linearization point
// for item to be removed from this queue.
if (p != h) // hop two nodes at a time
updateHead(h, ((q = p.next) != null) ? q : p);
return item;
}
else if ((q = p.next) == null) {
updateHead(h, p);
return null;
}
else if (p == q)
continue restartFromHead;
else
p = q;
}
}
}关于ConcurrentLinkedQueue和LinkedBlockingQueue：
- LinkedBlockingQueue是使用锁机制，ConcurrentLinkedQueue是使用CAS算法，虽然LinkedBlockingQueue的底层获取锁也是使用的CAS算法
- 关于取元素，ConcurrentLinkedQueue不支持阻塞去取元素，LinkedBlockingQueue支持阻塞的take()方法，如若大家需要ConcurrentLinkedQueue的消费者产生阻塞效果，需要自行实现
- 关于插入元素的性能，从字面上和代码简单的分析来看ConcurrentLinkedQueue肯定是最快的，但是这个也要看具体的测试场景，我做了两个简单的demo做测试，测试的结果如下，两个的性能差不多，但在实际的使用过程中，尤其在多cpu的服务器上，有锁和无锁的差距便体现出来了，ConcurrentLinkedQueue会比LinkedBlockingQueue快很多：ConcurrentLinkedQueuePerform:在使用ConcurrentLinkedQueue的情况下100个线程循环增加的元素数为：33828193
LinkedBlockingQueuePerform:在使用LinkedBlockingQueue的情况下100个线程循环增加的元素数为：33827382
6.Java的内存模型以及GC算法
7.Java7、Java8的新特性(baidu问的,好BT)
8.Java数组和链表两种结构的操作效率，在哪些情况下(从开头开始，从结尾开始，从中间开始)，哪些操作(插入，查找，删除)的效率高
9.Java内存泄露的问题调查定位：jmap，jstack的使用等等
二、框架
1.struts1和struts2的区别
2.struts2和springMVC的区别
3.spring框架中需要引用哪些jar包，以及这些jar包的用途
4.springMVC的原理
5.springMVC注解的意思
6.spring中beanFactory和ApplicationContext的联系和区别
7.spring注入的几种方式
8.spring如何实现事物管理的
9.springIOC和AOP的原理
10.hibernate中的1级和2级缓存的使用方式以及区别原理
11.spring中循环注入的方式
三、多线程
1.Java创建线程之后，直接调用start()方法和run()的区别
2.常用的线程池模式以及不同线程池的使用场景
3.newFixedThreadPool此种线程池如果线程数达到最大值后会怎么办，底层原理。
4.多线程之间通信的同步问题，synchronized锁的是对象，衍伸出和synchronized相关很多的具体问题，例如同一个类不同方法都有synchronized锁，一个对象是否可以同时访问。或者一个类的static构造方法加上synchronized之后的锁的影响。
5.了解可重入锁的含义，以及ReentrantLock 和synchronized的区别
6.同步的数据结构，例如concurrentHashMap的源码理解以及内部实现原理，为什么他是同步的且效率高
7.atomicinteger和volatile等线程安全操作的关键字的理解和使用
8.线程间通信，wait和notify
Java提供了3个非常重要的方法来巧妙地解决线程间的通信问题。这3个方法分别是：wait()、notify()和notifyAll()。它们都是Object类的最终方法，因此每一个类都默认拥有它们。
虽然所有的类都默认拥有这3个方法，但是只有在synchronized关键字作用的范围内，并且是同一个同步问题中搭配使用这3个方法时才有实际的意义。
-
如果对象调用了wait方法就会使持有该对象的线程把该对象的控制权交出去，然后处于等待状态。
-
如果对象调用了notify方法就会通知某个正在等待这个对象的控制权的线程可以继续运行。
-
如果对象调用了notifyAll方法就会通知所有等待这个对象控制权的线程继续运行。
9.定时线程的使用
10.场景：在一个主线程中，要求有大量(很多很多)子线程执行完之后，主线程才执行完成。多种方式，考虑效率。
四、网络通信
1.http是无状态通信，http的请求方式有哪些，可以自己定义新的请求方式么。
2.socket通信，以及长连接，分包，连接异常断开的处理。
3.socket通信模型的使用，AIO和NIO。
4.socket框架netty的使用，以及NIO的实现原理，为什么是异步非阻塞。
5.同步和异步，阻塞和非阻塞。
五、Linux
1.常用的linux下的命令
2.大的log文件中，统计异常出现的次数、排序，或者指定输出多少行多少列的内容。(主要考察awk)
3.linux下的调查问题思路：内存、CPU、句柄数、过滤、查找、模拟POST和GET请求等等场景
4.shell脚本中#！的作用
六、数据库MySql
1.MySql的存储引擎的不同
2.单个索引、联合索引、主键索引
MySQL单列索引和组合索引(联合索引)的区别详解
初始我写这篇文章的原因在于面试到一家大的游戏公司的时候，一个面试题
大致的内容是怎么加速这个where a=’1′ 和 where a=’1′ and b=’2′,当时我答题的时候回答的是a加索引，a和b加联合索引。
面试官跟我聊题目的时候说 where a=’1′ and b=’2′ 在加一个b的索引就好了，因为之前加过a的单列索引了，他很确定的告诉我，因为我没有测试过，所以没有反驳。在回去的路上我一直想不通，多个单列的索引和联合索引都一样的速度，联合索引还有什么用?
今天有空来做个试验，当然之前我已经查过资料了，为了确定一下
创建一个users表
- CREATE TABLE `users` (
- `userID` int(11) NOT NULL AUTO_INCREMENT,
- `userName` varchar(20) NOT NULL,
- `password` varchar(20) NOT NULL,
- PRIMARY KEY (`userID`)
- )
创建一个genUsers存储过程，用来模拟数据
- delimiter $
- create procedure genUsers()
- begin
- declare i int default 0;
- while i < 100000 do
- set i = i + 1;
- insert into users(userID,userName,`password`) values(i,concat('username',i),concat('password',i));
- end while;
- end $
- delimiter ;
执行存储过程
- call genUsers();
复制表结构和数据
- CREATE TABLE users2 SELECT * FROM users;
添加userName，password单列索引
- alter table users add index userName(userName);
- alter table users add index password(password);
- select * from users where userName like 'username65%' and password like 'password65%'; 执行时间0.06 秒
- alter table users2 add index userName_password(userName,password);
- select * from users2 where userName like 'username65%' and password like 'password65%’;执行时间0.00秒
上面的结果每台机子测试的结果可能有所不同
原因是在mysql执行查询的时候，只能使用一个索引，mysql会选择一个最严格(获得结果集记录数最少)的索引。最左前缀：顾名思义，就是最左优先，打一比方
alter table users add index lname_fname_age(lname,fname,age);
创建了lname_fname_age多列索引,相当于创建了(lname)单列索引，(lname,fname)联合索引以及(lname,fname,age)联合索引。
3.Mysql怎么分表，以及分表后如果想按条件分页查询怎么办(如果不是按分表字段来查询的话，几乎效率低下，无解)
4.分表之后想让一个id多个表是自增的，效率实现
5.MySql的主从实时备份同步的配置，以及原理(从库读主库的binlog)，读写分离
6.写SQL语句。。。
7.索引的数据结构，B+树
8.事物的四个特性，以及各自的特点（原子、隔离）等等，项目怎么解决这些问题
七、设计模式(写代码)
1.单例模式：饱汉、饿汉。以及饿汉中的延迟加载
2.工厂模式、装饰者模式、观察者模式。
八、算法
1.使用随机算法产生一个数，要求把1-1000W之间这些数全部生成。（考察高效率，解决产生冲突的问题）
2.两个有序数组的合并排序
有两种实现思路：
1. 定义一个新数组，长度为两个数组长度之和，将两个数组都copy到新数组，然后排序。
2. 给两个数组分别定义一个下标，最大长度是数组长度减一，按位循环比较两个数组，较小元素的放入新数组，下标加一（注意，较大元素对应的下标不加一），直到某一个下标超过数组长度时退出循环，此时较短数组已经全部放入新数组，较长数组还有部分剩余，最后将剩下的部分元素放入新数组，大功告成。
3.一个数组的倒序
4.计算一个正整数的正平方根
5.说白了就是常见的那些查找排序算法（排序转载：http://mp.weixin.qq.com/s?__biz=MjM5MTAzMTE4Nw==&mid=204838393&idx=2&sn=e9b50c8ef689e2cb6436110a8dc148a3&scene=5#rd）
九、缓存
1.为什么用缓存，用过哪些缓存，redis和memcache的区别
http://www.cnblogs.com/shan1393/p/9001113.html
2.redis的数据结构 String list set Zset hash
3.redis的持久化方式，以及项目中用的哪种，为什么 快照
4.redis集群的理解，怎么动态增加或者删除一个节点，而保证数据不丢失。（一致性哈希问题）