关闭

高新技术

1913人阅读 评论(0) 收藏 举报

集群的时候缓存有几种方式,2W人在线的系统,应该如何J2EE架构,从哪些方面优化..
你能做
分模块部署系统吗.你知道nfs在集群部署会产生什么问题吗
哥就靠editplus直接写几万行的
JS应用.
你做过几个几百万的项目,线程并发库 


二叉树 递归 过滤重复的SQL 




1. 哪些情况会引起线程等待和阻塞?然后引伸更多的线程有关主题的讨论。比如线程与连接,线程池,自旋锁,偏向锁,并行计算等等。 


2. 那些因素可能会出现数据不一致现象?然后把话题引伸到事务管理,缓存策略和数据同步相关的讨论。 


3. 系统出现问题你一般是如何做检查的?然后把话题引伸到系统运行通常会遇到那些问题,如何尽量避免这些问题? 


4. 你通常用哪些方法来进行系统性能调优?你做过的系统里,遇到过哪些性能问题,你是如何试图去寻找解决方案的? 


5. 讲一下对象生命周期的过程和对象复制过程?然后引伸到面对对象设计的讨论。 


6. 如果要让你来设计一种网络通信协议,你会考虑哪些因素?..... 


7. 叙述一下javascript 对象的继承原理。...... 


8. IE 和 Firefox捕获事件机制有什么不一样?...... 


9. CSS 对div 几种定位的区别及应用场合?...... 


10. 在你工作中常用到哪些linux命令?通常你写shell脚本主要是解决哪些问题? 


   通常调整哪些系统参数能影响系统性能?...... 


11. 在你做过的系统里,哪些类型的bug较多?软件过程中哪些阶段引起的bug较多?..... 




我一般面试中高级开发测试架构, 
从简历入手,挑他做过的比较重要的两三个项目, 
问实际的问题,用到的技术,解决的方法,考虑的思路,最后的结果。 
==============>> 开发能力 
再问他技能列表里最擅长的一两个技术,从浅到深,一点点问, 
看他积累和思考的程度。 
==============>> 技术潜力 


前端最关键的就是用户体验和如何性能调优,前者主要是UI设计能力,后者主要靠一些技术手段 
支持,比如说CSS sprite,js压缩,客户端缓存等。 当然后端的性能也是必须要保证的。 


互联网公司真的是不一样啊,对并发和大数据量的关注是深入骨髓的。感觉真是惭愧。虽然这几年跑客户谈需求讲ppt自诩也是混场面的,但是从心里希望自己在技术上也能再往前走一步。


 


 


根据记忆整理如下:


 


1.有一个集合a,里面有n个正整数,乱序排列。给定一个正整数N,求,a中任意两个数相加等于N,共有哪些种组合情况。例如,集合为{1,3,44,2,4,5,54,222,368}  N=6,则结果集为{1,5},{2,4}


      这个题网上有类似的


 


2. Treemap的实现。


   各种集合类的结构和优缺点,大家都挺爱考的。以前做行业信息化,没什么感觉,但是如果很在意性能,搞清楚还是挺有用的。


 


3.有两个很大的文件,每个文件中都有1亿行,每行一个整数。问这两个集合的交集是什么。给定的前提是机器内存不足以完全装入任意一个文件。


   这个几乎是网上的原题了


 


4. 堆和栈的定义,堆和栈里面的对象,哪个运行速度快。


    还问了一些衍生的问题,记不清了,只要看清楚java教材关于这方面的介绍足矣


 


5.为了实现一个折线图,需要将数据存入一种数据结构,折线图横坐标是时间,纵坐标是值,经常的查询是按时间段进行查询,如select value from t where begin>’20110101’ and end<’20111212’ ,问,使用java中的那种数据结构比较好。


   还是考java中的各种集合类,本质上是问各种数据结构在顺序/随机的读取/插入上的效率


 


6.数据库的索引通常用什么数据结构实现?为什么用这种数据结构。


   就知道是btree,但是btree是咋回事,为啥不能用其他tree或者别的结构,这个看过一篇帖子以后才明白。算是学习了。


 


7.如果数据库中有2个表,表a字段为姓名、年龄,表b字段为姓名、单位。现在使用姓名字段做left join查询,假设姓名字段都有索引了。问数据库是怎么实现的。如果把这两个表看为在内存中的数组,要自己实现left join,怎么实现?


   面试官看我实在不知道数据库里leftjoin怎么实现的,就让我自己实现一个内存中的,勉强答出来了吧,但是可能不太好。


 


8.数据库各种事务隔离级别


   这个是纯不记得了,以前工作中从来用不到,真是汗颜。


 


9.       wait()方法和notify()方法干什么用的,wait()方法有什么使用限制,是哪儿都能用么?


   对于一个从来不用多线程的人,这么简单的问题也变得有点儿难。只知道干什么用的,不知道有什么限制。


 


10.   数据库中有一个表有上亿的数据量,怎么优化?(主要是拆分,除了按业务拆分外,还有什么从技术角度的,可扩展性好的水平拆分方式)


   思路是拆没错,但是面试官问的不是业务拆分策略,而是从技术上考虑。还得考虑扩展性,比如拆好以后,数据量增长迅速,又要拆了,怎么办。这个水平拆分策略有好多,网上能搜到。但是我说的都不是很有体系,以前没弄过,都是现场想。。


 


ps:当时上新东方的时候,老师说,有的时候虽然你英语不好,但是有几个单词只要你记住了,说的时候塞到句子里,人家就会觉得你特地道,比如absolutely之流。我觉得面试的时候也有这种key words,比如位排序之流,说的时候还得特举重若轻。适用于各类新手和平时工作中压根用不到各种排序算法的人,仅供参考。




java 数据结构
1.线性表 
2.堆栈和队列 
3.串 
4.数组.集合.矩阵 
5.递归算法 
7.树和二叉树 
8.图 
9.排序 
10.查找 
11.哈西表 




1.apidemos里哪些东西是重要的,看重点 

2.apidemos里怎样定位所用到的类,layout布局文件(一个完整的功能即如何跟踪一
个完整的流程) 
3.ApiDemos这个类有什么用,ApiDemosApplication的有什么用,会每次运行吗
 


4.android应用开发解密 4,8,15 (chapter)
  任职要求: 1、 至少读过两遍 think in java / 
   core java 并能够灵活应用; 2、 至少看过  
   effective java / code complete / design 
   pattern / domain driven design其中的一本 
   并在实际中运用过; 3、 
   使用过一种版本控制工具 cvs/ svn/ git/; 4、 
   使用过缓存框架, memcache, redis等 
   宏达以太android面试题 
   1.面向对象的特征,请简单说下? 2.abstract 
   class和interface的区别? 3.GC 垃圾回收机制 
   4.EJB 5.Broadcast 6.android中的异常 
   7.forseclose强制关闭是由什么造成的? 
   8.android分辨率的适配 9.android布局 
   10.xml解析的几种方式 11.单例,写一个单例 
   12.反射,求字段的值和方法名(做框架的公司有可
   能考这个) 


刚才电话面试 问啦好多问题 谈啦半个小时 大概记得 1.问了下有设计模式 我回答 单例 
观察者 建造 工厂 迭代 抽象 原型 组合 桥接 适配器 问我还有那些没答上来 
2.sqlserver 数据库和oracle数据库取当期时间 getDate()  sysdate 3.hibernate 
怎么优化 没答 会用不会说 4.ibatis 怎么优化 回答针对于 系统访问方面 
配置连接池,由于ibatis大部分是写sql就说了下sql优化以及ibatis使用细节 
5.口述解析txt文件再写到另外一个 在每行前加行号 public static void 
readFileByLines(String fileName) { File file = new File(fileName); 
BufferedReader reader = null; try { 
System.out.println("以行为单位读取文件内容,一次读一整行:"); reader = new 
BufferedReader(new FileReader(file)); String tempString = null; int line = 1; // 
一次读入一行,直到读入null为文件结束 while ((tempString = reader.readLine()) != 
null) { // 显示行号 System.out.println("line " + line + ": " + tempString); 
line++; } reader.close(); } catch (IOException e) { e.printStackTrace(); } 
finally { if (reader != null) { try { reader.close(); } catch (IOException e1) { 
} } } } 5.spring机制 回答 aop 面向切面统一接口管理 ioc 控制反转 
不用实例化对象可以调用对象 6.做啦那些项目口述有那些模块等等 7.细说单例模式 
就是一个类只有一个实例 8.linkList和arrayList有什么不同 前者链表后者数组 特性 
前者适合插入和删除 后者适合快速查询 其他不记得了


1、有一堆数字,只为[0-9]这9 
个数,但各个数重复的,无规则的进入一方法,输出为[0-9]进入该方法的顺序,怎么实现该
方法; 2、实现Spring式的事务管理方案。 
3、JVM线程多,资源快消耗被完,应该怎么处理。 4、了解过分布式不,缓存实现方式。 
5、重构代码:如现有一个List,里面元素为数组,但可能为int[],String[],或其它对象数
组,现遍历该数组,如果元素为int[]时,输出该数组的和,如果为String,输出该数组字符
窜相加,如果为其它对象,有相应的处理方式,现代码是用一个方法实现的,应该怎么重构
。 6、用过哪几种设计模式,了解过哪些 
7、现系统有主数据库一个,支持保存修改查询,四个从数据库只查询。主从数据库无须考虑
数据同步,当成数据一致;现在实现让service方法中根据方法名(说明数据库操作类型),
分配数据主从数据库连接。让调用者(开发人员)不关心具体使用的哪个数据库! 


补充: 
8、在最前面问了Map、List、Set的用法,再问了hash算法实现。看我说不出来,就提示性的
问了当重写equals及hashCode时,应该注意什么。看我还没反应过来,就直接问了两者有什
么关系统。。面试人员还是挺好的,能提示性的让回答完成问题。。 


还有其它的,想不起来了! LZ也工作三年了,有些问题还真答不上来。。。 1、int[10], 
值为进入的次序 2、考得是Spring事务源码 3、线程池啊,阻塞啊,reanctor模式等 
5、策略模式 7、参考ReentrantReadWriteLock 和 Semaphore 
我觉得这些题目挺好的,什么公司,我能去试试吗? 1、说是得考虑快速判重。。 
3、说是JVM方面的问题,我回答得是考虑分析dump文件 1.第一反应冒泡排序。。。 
2.第一反应是InvocationHandler动态代理 4.一致性哈希算法,听说过 7.Strategy 模式 
1.题目没理解,无规则进入方法是指多次调用?还是多线程调用? 
2.spring不输,直接说不会 3.资源消耗完 
要先确定什么资源消耗完。内存?cpu?内存的话确定是heap 还是stack消耗完 
或者是方法区内存等各种情况, 
都有不同的解决方案,这个聊聊就看面试者怎么应答了。单纯线程多就考虑换成线程池。io
资源消耗完就考虑io池 nio等技术 
4.分布式这个问题大了,我答的话会根据自己接触的一些实际例子来聊,不会罗列概念。具
体聊到哪看面试者交互。 缓存实现方式 
不太了解面试者意图?是指架构方面的考量还是啥?分布式系统缓存我自己经验主要考虑数
据一致性问题了。 
考虑用集中式缓存设计,memcache这些,不过我自己也没搞过,普通搞个本地内存缓存就够
了。还有命中率 退出机制啥的只知道 理论 自己没弄过。 
5.先把不同数组的处理类抽取出来:handle(String[]) handle(int[]) 
handle(object[]) 然后方法内根据list内保存的数据类型 用List.toArray(T[]) 
获取对应的数组,调用handle方法(overload)。 
个人感觉答得不太好,因为toArray比较耗资源,懒得想了,面试的时候估计也没多少时间考
虑。 6.这个随便聊了。。各人还接触过一些多线程的设计模式,可以多吹一点。。 
7.不太懂 8.map list set 
用法这个比较熟悉,hash算法实现原理懂也研究过hashMap源代码,让我写一个hash算法估计
有难度。 为啥注意equals呵hashCode自然跟hash算法原理有关。 
concurrent包的几个容器Queue blockingqueue也接触比较多,源代码也研究过 
可以稍微聊下 


俺也是3年经验,深圳有招人的吗? 3、JVM线程多,资源快消耗被完,应该怎么处理。  
线程多需要消耗的主要是栈空间和OS内存,如果资源不够,只能用池化的方式来解决,未执
行到的阻塞或者超过最大值的抛弃/自己定义策略,如果做了监控我们可以直观的看到一个机
器的load以及gc各个区的值, 线程栈主要是调整jvm的-Xxs值


给一个有趣的实现,第1题
Java代码  
package test;  
public class Test {  
    public static void main(String[] args) {  
        Test t = new Test();  
          
        int[] source = {1,1,1,1,1,2,5,6,5,6,4,8,5,4,5,4,2,1,2,3,2,1,2,3,8,5,2,2,2,4,4,4,3,2,7,9,0,3,4,5,5,5,5,5,5};  
          
        /** 
         * 其中count的加法是每个if后面都加一个,计算判断的次数吧,用循环次数对于这种小的循环,可能不够直观 
         */  
          
        /*方法1*/  
        int[] result = t.orderInt(source);  
        for(int i=0;i<result.length;i++){  
            System.out.println(""+result[i]);  
        }  
        System.out.println("执行判断的次数"+t.count);  
          
        /*方法2*/  
        int[] result2 = t.orderInt2(source);  
        for(int i=0;i<result2.length;i++){  
            System.out.println(""+result2[i]);  
        }  
        System.out.println("执行判断的次数"+t.count2);  
  
    }  
      
    private int count =0;  
    private int count2 =0;  
      
    /** 
     * 排序 
     * @param ord 
     * @return 
     */  
    public int[] orderInt(int[] ord){  
        int[] result = new int[10];  
        long max = 3L*5L*7L*11L*13L*17L*19L*23L*29L*31L;//100280245065L,用乘法的大家可能看得懂些  
        int resultCount = 0;  
        boolean flag = true;  
        for(int i=0;i<ord.length&&flag;i++){  
            int j = replaceInt(ord[i]);  
            if(max%j==0){  
                max = max/j;  
                result[resultCount++] = ord[i];  
                if(resultCount == 10){  
                    flag = false;  
                }  
                count++;  
            }  
            count++;  
        }  
        return result;  
    }  
      
    /** 
     * 替换 
     * @param ind 
     * @return 
     */  
    public int replaceInt(int ind){  
        int res = 1;  
        if(ind == 0){  
            count += 1;  
            return 3;  
        }else if(ind == 1){  
            count += 2;  
            return 5;  
        }else if(ind == 2){  
            count += 3;  
            return 7;  
        }else if(ind == 3){  
            count += 4;  
            return 11;  
        }else if(ind == 4){  
            count += 5;  
            return 13;  
        }else if(ind == 5){  
            count += 6;  
            return 17;  
        }else if(ind == 6){  
            count += 7;  
            return 19;  
        }else if(ind == 7){  
            count += 8;  
            return 23;  
        }else if(ind == 8){  
            count += 9;  
            return 29;  
        }else if(ind == 9){  
            count += 10;  
            return 31;  
        }  
        return res;  
    }  
      
    /** 
     * 排序2 
     * @param ord 
     * @return 
     */  
    public int[] orderInt2(int[] ord){  
        int[] result = new int[10];  
        int resultCount = 0;  
        boolean flag1 = true;  
        boolean flag2 = true;  
          
        for(int i=0;i<ord.length&&flag1;i++){  
            if(resultCount > 0){  
                for(int j=0;j<resultCount+1&&flag2;j++){  
                    if(ord[i] == result[j]){  
                        flag2 = false;  
                    }  
                    count2++;  
                }  
                if(flag2){  
                    result[resultCount++]=ord[i];  
                }  
                count2++;  
            }else {  
                result[resultCount++]=ord[i];  
                count2++;  
            }  
            count2++;  
              
            if(resultCount == 10){  
                flag1 = false;  
            }  
            count2++;  
            flag2 = true;  
        }  
  
        return result;  
    }  
      
}  
 
 第五题,给个实现,用的工厂方法,欢迎高手拍砖,说策略模式的同学来探讨下。
大致思路是,有一个抽象类ArrayHandler,定义process方法处理List里面的数组。分别有IntArrayHandler,StringArrayHandler以及其他继承ArrayHandler。
ArrayHandlerFactory是Handler的工厂,createHandler方法根据数组的类型返回不同的Handler
Client为调用工厂方法的类。代码如下
ArrayHandler
Java代码  
package zuoshu.pattern.q1;  
  
public abstract class ArrayHandler {  
    Object mArray;//用Object而不用Object[]是因为输入数组可能是int[]  
    //用抽象类而不用接口是因为要有构造函数来接收输入的数组  
    public ArrayHandler(Object array){  
        mArray = array;  
    }  
    public abstract void process();//处理数组的方法  
}  
 ArrayHandlerFactory
Java代码  
package zuoshu.pattern.q1;  
  
public class ArrayHandlerFactory {  
    public static ArrayHandler createHandler(Object array) {  
        Class c = array.getClass();  
        //int[]  
        if (c.equals(int[].class)) {  
            return new IntArrayHandler(array);  
        }   
        //String[]  
        else if (c.equals(String[].class)) {  
            return new StringArrayHandler(array);  
        }  
        //unimplement  
        else {  
            return new UnsupportArrayHandler(array);  
        }  
    }  
}  
 IntArrayHandler
Java代码  
package zuoshu.pattern.q1;  
  
public class IntArrayHandler extends ArrayHandler {  
    public IntArrayHandler(Object array) {  
        super(array);  
    }  
    @Override  
    public void process() {  
        System.out.println("processing int[]");  
    }  
  
}  
 StringArrayHandler
Java代码  
package zuoshu.pattern.q1;  
  
public class StringArrayHandler extends ArrayHandler {  
    public StringArrayHandler(Object array) {  
        super(array);  
    }  
  
    @Override  
    public void process() {  
        System.out.println("processing String[]");  
    }  
  
}  
 UnsupportArrayHandler
Java代码  
package zuoshu.pattern.q1;  
  
public class UnsupportArrayHandler extends ArrayHandler {  
  
    public UnsupportArrayHandler(Object array) {  
        super(array);  
    }  
  
    @Override  
    public void process() {  
        System.out.println("unimplemented array handler:" + mArray.getClass());  
    }  
  
}  
 客户端调用方法如下
Java代码  
package zuoshu.pattern.q1;  
  
import java.util.List;  
  
public class Client {  
    public void doTask(List<Object> list) {  
        ArrayHandler handler;  
        for (Object o : list) {  
            handler = ArrayHandlerFactory.createHandler(o);  
            handler.process();  
        }  
    }  
}  
 写了个测试如下
Java代码  
package zuoshu.pattern.q1;  
  
import java.util.ArrayList;  
import java.util.List;  
  
public class Q1 {  
    public static void main(String[] args) {  
        Integer[] intArray = new Integer[5];  
        String[] stringArray = new String[5];  
        Object[] objArray = new Object[5];  
        List<Object> list = new ArrayList<Object>();  
        list.add(intArray);  
        list.add(stringArray);  
        list.add(objArray);  
        Client c = new Client();  
        c.doTask(list);  
    }  
}  
 输出如下
processing int[]
processing String[]
unimplemented array handler:class [Ljava.lang.Object;
 
欢迎高手讨论


sql语句优化的步骤
1) 查看sql语句是否存在distinct、not in、or等可优化语句
2) 查看执行计划,看是否存在filter、table access full或者笛卡尔积
3) 根据业务实际需要进行优化


1) Not exists代替not in
2) 一定要注意or,可用union all代替
3) Count(1)查询,切记取消order by,distinct
4) 视图连接要小心,可能会用不到索引
5) 查询字段放到索引中
0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:271733次
    • 积分:1875
    • 等级:
    • 排名:千里之外
    • 原创:31篇
    • 转载:20篇
    • 译文:4篇
    • 评论:14条
    最新评论