面试题汇总

简述多进程、多线程

开发中遇到问题或程序出现未知错误时，如何解决

如何快速理解已有的项目代码？

秒杀程序，大并发下，如何不超卖？

订单系统，包含订单、商品、价格信息，并且要维护一些状态，设计系统时，有哪些建议

利用元类实现一个单例模式

利用装饰器实现一个单例模式

树的深度遍历，要求节点包含三个属性id、value、fatherid

 

 

树的深度遍历，要求节点包含三个属性id、value、fatherid

#!user/bin/python

#树的实体（包括 Id, value, fatherId）

class treeModel:

    '''tree view'''

    def __init__(self,Id,value,fatherId):

        self.Id=Id

        self.value=value

        self.fatherId=fatherId

    def show(self):

        return self.value

# 树的遍历和展示

class treeShow:

    '''tree show'''

    logList = [treeModel(0,'addTree',0)]  #记录已经遍历过的节点

    writtenList = [treeModel(0,'addTree',0)]  #记录已经打印出的节点

    def __init__(self,rootId,list):

        self.rootId = rootId

        self.list=list

    #通过Id获取节点 

    def getModelById(self,Id):

        for t in self.list:

            if t.Id == Id:

                return t

        return None

    #判断是否有子节点

    def haveChild(self,t):

        for t1 in self.list:

            if t1.fatherId == t.Id and not self.IsInLogList(t1):

                return True

        return False

    #获取第一个没有遍历的子节点

    def getFirstChild(self,t):

        for t1 in self.list:

            if t1.fatherId == t.Id and not self.IsInLogList(t1):

                return t1

        return None

    #判断某节点是否已经被遍历

    def IsInLogList(self,t):

        for t1 in self.logList:

            if t1.Id == t.Id:

                return True

        return False

    #判断某节点是否已经打印

    def IsInWrittenList(self,t):

        for t1 in self.writtenList:

            if t1.Id == t.Id:

                return True

        return False

    #获取父节点

    def getFatherTree(self,t):

        for t1 in self.list:

            if t1.Id == t.fatherId:

                return t1

        return None

    #遍历打印

    def show(self):

        currentTree = self.getModelById(self.rootId)

        s = '  '

        strNum = 1

        while(True):

            if self.haveChild(currentTree):

                if not self.IsInWrittenList(currentTree):

                    print s*strNum,currentTree.show()

                    self.writtenList.append(currentTree)

                currentTree = self.getFirstChild(currentTree)

                strNum += 1

                continue

            else:

                if(currentTree.Id == self.rootId):

                    break

                else:

                    if not self.IsInWrittenList(currentTree):

                        print s*strNum,currentTree.show()

                    self.logList.append(currentTree)

                    currentTree = self.getFatherTree(currentTree)

                    strNum -= 1

                    continue

#初始化一些节点实例

t1 = treeModel(1,'A-1',0)

t2 = treeModel(2,'B-1',1)

t3 = treeModel(3,'B-2',1)

t4 = treeModel(4,'C-1',2)

t5 = treeModel(5,'C-2',2)

t6 = treeModel(6,'C-3',3)

t7 = treeModel(7,'C-4',3)

t8 = treeModel(8,'D-1',4)

t9 = treeModel(9,'E-1',8)

t10 = treeModel(10,'E-2',8)

#将这些节点实例链式存储起来（就像数据库里存储一样）

list = [t1,t2,t3,t4,t5,t6,t7,t8,t9,t10]

#调用展示

ts = treeShow(1,list)

ts.show()

利用装饰器实现一个单例模式

def singleton(cls, *args, **kwargs):
    instance = {}
    def _instance():
        if cls not in instance:
            instance[cls] = cls(*args, *kwargs)
        return instance[cls]
    return _instance

@singleton
class Test_singleton:
    def __init__(self):
        self.num = 0

    def add(self):
        self.num = 99

ts1 = Test_singleton()
ts2 = Test_singleton()
print(ts1)
print(ts2)

 利用元类实现一个单例模式

class Singleton(type):
    def __new__(cls, name,bases,attrs):
        print("__new__")
        attrs["_instance"] = None
        return  super(Singleton,cls).__new__(cls,name,bases,attrs)

    def __call__(self, *args, **kwargs):
        print("__call__")
        if self._instance is None:
            self._instance = super(Singleton,self).__call__(*args, **kwargs)
        return self._instance

class Foo(object):
    __metaclass__ = Singleton

foo1 = Foo()
foo2 = Foo()
print(Foo.__dict__ )
print(foo1 is foo2 )

 

秒杀程序，大并发下，如何不超卖？

 思考题3     秒杀系统可以基于rabbitmq中的流量削峰的功能实现，当请求超过一定的阈yu值,超过的部分的请求就会被丢弃，例如秒杀小米手机为什么抢不到，就是因为请求被丢弃了！  如果面试官再进一步问，你就说我就了解过这么多 ;

 思考题3 可以将参加秒杀的商品信息事先缓存到redis缓存中，这样可以大大的提高系统的吞吐量，减少关系型数据库的读写压力。

订单系统，包含订单、商品、价格信息，并且要维护一些状态，设计系统时，有哪些建议

思考题2 用到了消息队列的概念，例如生产者和消费者的中的生产者把订单的这些信息放在消息队列中，可以使用rabbitmq中ack确认机制 当服务器宕机了，数据不会丢失，这里用到了rabbitmq的数据可恢复性功能！ 也可以围绕redis持久化 RDB和AOF机制说 主体就是不能让订单数据丢了，做数据持久化

如何快速理解已有的项目代码？

1.通读需求文档，了解项目用途；
一个企业级的项目，一定会保留一些相关文档吧！比如需求文档，设计文档，项目计划等，先通读这些文档，了解项目的用途、主要功能等。

2.熟悉开发工具、常用功能；
每个公司用的开发环境都会有些不同，要熟悉新的开发环境，了解常用的功能、快捷键等，特别是前后使用习惯相差比较大的开发环境，如从MyEclipse到IntelliJ IDEA。Java的开发环境用的比较多的有MyEclipse(Eclipse)、Intellij IDEA. C++就比较多了，从VC6到VS2008、VS2010、VS2012、VS2013都有人用，还有一些用开源的开发工具如Qt。

3.部署环境，把项目跑起来；
了解开发环境后，就把相关的配置部署好，把项目跑起来。好处是：1.可以进一步实践新的开发环境；2.把项目跑起来后可以快速地了解项目的用途和功能。

4.整体浏览代码，了解代码结构；
整体浏览一下代码，对项目的代码有个整体结构的把握。最好能把类图画出来，可以用一些UML工具(如EA、PowerDesign)的逆向工程把源码导出类图。

5.抽取其中的一部分进行细读；
对一个企业级的项目，特别是一些大型项目或积淀比较深厚的项目，不可一下就把所有代码都熟悉。那就选择其中的一部分，如其中一个小功能，从界面开始，通过debug模式一步一步地跟下去，以点带面地去熟悉整个项目。

6.尝试修改一些程序bug；
修改bug是熟悉项目最好的方法。根据出现的bug，通过debug模式一步步地定位出现问题的位置，再分析出现问题的原因。当你能够修改bug，并且已经改了好几个bug的时候，就说明你对项目有了一定了解了，基本熟悉这个项目的结构和逻辑了。

2、开发中遇到问题或程序出现未知错误时，如何解决

1、简述多进程、多线程