一、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
    
      l = last; final Node
     
       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
    
      newNode = new Node
     
      (e); for (Node
      
        t = tail, p = t;;) { Node
       
         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
    
      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表

1. CREATE TABLE `users` (
2. `userID` int(11) NOT NULL AUTO_INCREMENT,
3. `userName` varchar(20) NOT NULL,
4. `password` varchar(20) NOT NULL,
5. PRIMARY KEY (`userID`)
6. )

创建一个genUsers存储过程，用来模拟数据

1. delimiter $
2. create procedure genUsers()
3. begin
4. declare i int default 0;
5. while i < 100000 do
6. set i = i + 1;
7. insert into users(userID,userName,`password`) values(i,concat('username',i),concat('password',i));
8. end while;
9. end $
10. delimiter ;

执行存储过程

1. call genUsers();

复制表结构和数据

1. CREATE TABLE users2 SELECT * FROM users;

添加userName，password单列索引

1. alter table users add index userName(userName);
2. alter table users add index password(password);

1. select * from users where userName like 'username65%' and password like 'password65%'; 执行时间0.06 秒

1. alter table users2 add index userName_password(userName,password);

1. 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.说白了就是常见的那些查找排序算法（排序转载：）

九、缓存 

1.为什么用缓存，用过哪些缓存，redis和memcache的区别

 http://www.cnblogs.com/shan1393/p/9001113.html

2.redis的数据结构  String list set Zset hash

3.redis的持久化方式，以及项目中用的哪种，为什么  快照

4.redis集群的理解，怎么动态增加或者删除一个节点，而保证数据不丢失。（一致性哈希问题）