面试题: 大公司面试 !=!=未看

zoukankan html css js c++ java

面试题: 大公司面试 !=!=未看
一、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：
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.说白了就是常见的那些查找排序算法（排序转载：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集群的理解，怎么动态增加或者删除一个节点，而保证数据不丢失。（一致性哈希问题）
查看全文

相关阅读:
继百岁版之后的续命版的更新
 重启nginx
酒吧流行游戏不完全手册
 google实时搜索
 ubuntu 支持gbk
网页编码
 爬虫日志分析
 feedsky 话题营销
 python时间日期格式转换
 nginx错误重定向

原文地址：https://www.cnblogs.com/shan1393/p/9017478.html

面试题: 大公司面试 !=!=未看

关于ConcurrentLinkedQueue和LinkedBlockingQueue：