我要提问
- 关于
数据处理指令有什么用
的搜索结果
回答
亲，关于这个操作系统的选择，以下的内容供参考
第一，设计初衷不同。64位操作系统的设计初衷是：满足机械设计和分析、三维动画、视频编辑和创作，以及科学计算和高性能计算应用程序等领域中需要大量内存和浮点性能的客户需求。换句简明的话说就是：它们是高科技人员使用本行业特殊软件的运行平台。而32位操作系统是为普通用户设计的。
第二，要求配置不同。64位操作系统只能安装在64位电脑上(CPU必须是64位的)。同时需要安装64位常用软件以发挥64位（x64）的最佳性能。32位操作系统则可以安装在32位(32位CPU)或64位(64位CPU)电脑上。当然，32位操作系统安装在64位电脑上，其硬件恰似“大马拉小车”：64位效能就会大打折扣。
第三，运算速度不同。64位CPU GPRs(General-Purpose Registers，通用寄存器)的数据宽度为64位，64位指令集可以运行64位数据指令，也就是说处理器一次可提取64位数据(只要两个指令，一次提取8个字节的数据)，比32位(需要四个指令,一次提取4个字节的数据)提高了一倍，理论上性能会相应提升1倍。
第四，寻址能力不同。64位处理器的优势还体现在系统对内存的控制上。由于地址使用的是特殊的整数，因此一个ALU（算术逻辑运算器）和寄存器可以处理更大的整数，也就是更大的地址。比如，Windows Vista x64 Edition支持多达128 GB的内存和多达16 TB的虚拟内存，而32位CPU和操作系统最大只可支持4G内存。
第五，软件普及不同。目前，64位常用软件比32位常用软件，要少得多的多。道理很简单：使用64位操作系统的用户相对较少。因此，软件开发商必须考虑“投入产出比”，将有限资金投入到更多使用群体的软件之中。这也是为什么64位软件价格相对昂贵的重要原因(将成本摊入较少的发售之中)。
总而言之，Microsoft Windows 64位操作系统，必须“上”靠64位主机硬件的支撑，“下”靠64位常用软件的协助，才能将64位的优势发挥到极致，“三位一体”缺一不可(道理很简单：操作系统只是承上启下的运行平台)。至于64位电脑可以安装32位操作系统，64位操作系统可以安装32位软件，那是设计上的“向下兼容”，不是64位设计初衷的本来含义。
如果你的CPU是双核以上，那肯定支持64位操作系统了
如果你的电脑内存大于4G，那就要用64位的系统了，因为32位的Windows 7也好，Vista也好，最大都只支持3.25G的内存。而64位的windows 7最大将支持128G的内存。
以下是引用网络上一段文字：
64bit计算主要有两大优点：可以进行更大范围的整数运算；可以支持更大的内存。
不能因为数字上的变化，而简单的认为64bit处理器的性能是 32bit处理器性能的两倍。实际上在32bit应用下，32bit处理器的性能甚至会更强，即使是64bit处理器，目前情况下也是在32bit应用下性能更强。所以要认清64bit处理器的优势，但不可迷信64bit。
-------------------------
回 7楼(fxlyx) 的帖子
好吧，下次我简单粗暴直接点~~
回答
楼主这是节点遍历时，通过函数指针动态加载节点处理函数的设计方法。这个几年前写过，后来不这么写了。主要有以下几个问题。 1、每个节点被访问时，操作可能不一样，通用的函数指针的入口参数，要么可变参，要么多套，入口指针，都是很繁琐的事情，把代码逻辑结构搞的会更复杂。 2、操作函数和操作对象没有绑定，这个在规模开发时，很容易引起混乱。这样设计的代码，我自己到后面都觉得混乱，更别说基于我的架子让别人开发，楼主你的例子不够复杂可能感觉不到。 3、上面两个问题，也导致，代码复用率不高。 现在我的设计思想，如果是基础的数据结构，如同你这个例子中就是个线形表，我都全部独立成模版，在头文件中。 特定数据的处理不会和处理方法绑定，而是调用不同通用模块来处理，这样是尽可能的让数据和处理松耦合。而关联数据再怎么关联，处理时，也是一类整体处理的，同时一批数据再怎么复合，总可以拆成不同大部分串联处理（例如，读取、处理、写出，通过增加cache的方式可以分批分步骤完成，而不是读、处理、写 、一个完整操作周期，仅针对一个单元）。所以这类数据的整体处理落在通用模块里，通过数据和处理的紧耦合的提升效率。 ###### 另外，补充说一下，楼主的函数式风格，和我的函数式风格理解相差颇大。我的理解如下，所谓函数式风格，是将一批数据的若干处理，分解为正交串接的多个子步骤，每个步骤都是对整体数据的某个操作的实现。楼主的方案实质是对一个处理，可以挂接不同的操作方法。 我的理解函数式的风格在于每个独立模块处理极少的有逻辑关联的操作，可以看作针对一个数据池的原子操作。依次将数据池的数据灌入不同的独立模块，实现数据处理。当然差异的模块调用顺序和不同处理模块的组合，可以有不同的效果。 但无论如何，都是函数与数据松耦合的设计。这个和面向对象是反过来的。 ######相互嵌套耦合，牵一发动全身######楼主的代码有很浓重的其他语言的味道######楼主文章不错，我看现在的C模块基本就是你所说的面向对象风格，其实就是用数据结构组织起来。######
引用来自“中山野鬼”的答案
楼主这是节点遍历时，通过函数指针动态加载节点处理函数的设计方法。这个几年前写过，后来不这么写了。主要有以下几个问题。 1、每个节点被访问时，操作可能不一样，通用的函数指针的入口参数，要么可变参，要么多套，入口指针，都是很繁琐的事情，把代码逻辑结构搞的会更复杂。 2、操作函数和操作对象没有绑定，这个在规模开发时，很容易引起混乱。这样设计的代码，我自己到后面都觉得混乱，更别说基于我的架子让别人开发，楼主你的例子不够复杂可能感觉不到。 3、上面两个问题，也导致，代码复用率不高。 现在我的设计思想，如果是基础的数据结构，如同你这个例子中就是个线形表，我都全部独立成模版，在头文件中。 特定数据的处理不会和处理方法绑定，而是调用不同通用模块来处理，这样是尽可能的让数据和处理松耦合。而关联数据再怎么关联，处理时，也是一类整体处理的，同时一批数据再怎么复合，总可以拆成不同大部分串联处理（例如，读取、处理、写出，通过增加cache的方式可以分批分步骤完成，而不是读、处理、写 、一个完整操作周期，仅针对一个单元）。所以这类数据的整体处理落在通用模块里，通过数据和处理的紧耦合的提升效率。
你说的问题#1和文章中函数式风格一节抱怨employee_read无法和Callback兼容的问题是类似的，说到底就是因为C语言静态类型等语法特性导致了对函数式风格支持不好；同时也反向说明了为什么大多数支持函数式风格的语言会选择“动态类型”，并且支持灵活的可变个数参数等特性，都是为了辅助函数式风格的编码。 #2这一点我不太同意。C语言里虽然没有类的概念把数据和函数在语法层次上绑定在一起，但通过规范地命令提供隐喻，比如代码中，所有操作Employee对象的函数都以employee_前缀开头。而且，这些接口之间也有层级关系，符合下表描述的抽象屏障。如果你把Employee相关的声明、操作独立出来放在一个文件里，然后头文件里只放置公开的接口信息，这样就变得简洁多了。
最高层：使用API的程序 main 基于Employee的接口实现的高级操作 employee_print, employee_adjust_salary 基于最底层的C，对象Employee的最基础的操作，包括读入、释放、遍历等 employee_read, employee_free, foreach, with_open_file C语言本身提供的最底层的工具 struct Empoloyee, for, free, calloc... 例如C语言自带的操作文件的接口同样符合这样的抽象屏障：我们只需要使用fopen、fclose、fread、fwrite等一系列操作FILE对象的接口，无需关心FILE结构体里有些什么内容，表示什么意思，以及各个接口是怎么实现的。 #3的确是一个问题，而且我在文章里也可以没有提及，因为这不是这篇文章要表达的重点。它最本质的问题在于将集合的数据结构和单个对象的信息保存在同一个地方。其他语言，例如Java的java.util.*容器、C++的STL容器，都符合你的设计，将容器这个单一职责抽象出来。当然，我自己实际的工作也是这样做的。 ######
引用来自“中山野鬼”的答案
另外，补充说一下，楼主的函数式风格，和我的函数式风格理解相差颇大。我的理解如下，所谓函数式风格，是将一批数据的若干处理，分解为正交串接的多个子步骤，每个步骤都是对整体数据的某个操作的实现。楼主的方案实质是对一个处理，可以挂接不同的操作方法。 我的理解函数式的风格在于每个独立模块处理极少的有逻辑关联的操作，可以看作针对一个数据池的原子操作。依次将数据池的数据灌入不同的独立模块，实现数据处理。当然差异的模块调用顺序和不同处理模块的组合，可以有不同的效果。 但无论如何，都是函数与数据松耦合的设计。这个和面向对象是反过来的。
我认为你说的是“责任单一原则”，让每个函数、每个模块责任都尽可能地单一，然后通过类似搭积木一样的灵活组合，完成不同的任务。就像UNIX下的命令，每个单独命令都只完成一件事情，通过管道等把这些功能单一的命令组织在一起，协作完成一个复杂的任务！ 我个人认为这是一种设计思想，和源自Lambda演算的函数式风格并没有太大关系。 ######
引用来自“杨同学”的答案
楼主的代码有很浓重的其他语言的味道
因为其他语言也能写“面向对象风格”和“函数式风格”的代码，并且看起来比C更“专业”。 ######
引用来自“优游幻世”的答案
楼主文章不错，我看现在的C模块基本就是你所说的面向对象风格，其实就是用数据结构组织起来。
嗯，将数据和操作数据的方法集中在一起会让代码更容易维护。 就像我在六楼回复里提到的，很多C模块往往还会更进一步，把容器和对象也分离开来。这样容器能容纳各种不同的对象，对象则只保留数据本身，不关心和其他对象是以什么形式组织在一起的。 ######
引用来自“redraiment”的答案
引用来自“中山野鬼”的答案
楼主这是节点遍历时，通过函数指针动态加载节点处理函数的设计方法。这个几年前写过，后来不这么写了。主要有以下几个问题。 1、每个节点被访问时，操作可能不一样，通用的函数指针的入口参数，要么可变参，要么多套，入口指针，都是很繁琐的事情，把代码逻辑结构搞的会更复杂。 2、操作函数和操作对象没有绑定，这个在规模开发时，很容易引起混乱。这样设计的代码，我自己到后面都觉得混乱，更别说基于我的架子让别人开发，楼主你的例子不够复杂可能感觉不到。 3、上面两个问题，也导致，代码复用率不高。 现在我的设计思想，如果是基础的数据结构，如同你这个例子中就是个线形表，我都全部独立成模版，在头文件中。 特定数据的处理不会和处理方法绑定，而是调用不同通用模块来处理，这样是尽可能的让数据和处理松耦合。而关联数据再怎么关联，处理时，也是一类整体处理的，同时一批数据再怎么复合，总可以拆成不同大部分串联处理（例如，读取、处理、写出，通过增加cache的方式可以分批分步骤完成，而不是读、处理、写 、一个完整操作周期，仅针对一个单元）。所以这类数据的整体处理落在通用模块里，通过数据和处理的紧耦合的提升效率。
你说的问题#1和文章中函数式风格一节抱怨employee_read无法和Callback兼容的问题是类似的，说到底就是因为C语言静态类型等语法特性导致了对函数式风格支持不好；同时也反向说明了为什么大多数支持函数式风格的语言会选择“动态类型”，并且支持灵活的可变个数参数等特性，都是为了辅助函数式风格的编码。 #2这一点我不太同意。C语言里虽然没有类的概念把数据和函数在语法层次上绑定在一起，但通过规范地命令提供隐喻，比如代码中，所有操作Employee对象的函数都以employee_前缀开头。而且，这些接口之间也有层级关系，符合下表描述的抽象屏障。如果你把Employee相关的声明、操作独立出来放在一个文件里，然后头文件里只放置公开的接口信息，这样就变得简洁多了。
最高层：使用API的程序 main 基于Employee的接口实现的高级操作 employee_print, employee_adjust_salary 基于最底层的C，对象Employee的最基础的操作，包括读入、释放、遍历等 employee_read, employee_free, foreach, with_open_file C语言本身提供的最底层的工具 struct Empoloyee, for, free, calloc... 例如C语言自带的操作文件的接口同样符合这样的抽象屏障：我们只需要使用fopen、fclose、fread、fwrite等一系列操作FILE对象的接口，无需关心FILE结构体里有些什么内容，表示什么意思，以及各个接口是怎么实现的。 #3的确是一个问题，而且我在文章里也可以没有提及，因为这不是这篇文章要表达的重点。它最本质的问题在于将集合的数据结构和单个对象的信息保存在同一个地方。其他语言，例如Java的java.util.*容器、C++的STL容器，都符合你的设计，将容器这个单一职责抽象出来。当然，我自己实际的工作也是这样做的。
第二个问题其实是不同设计思想的核心问题。你举的例子只能说是些简单的系统中的模块。如果是个大系统中的底层模块特别是引擎方面（会产生数据加工的），这种方法最终组合出来的系统，会比面向对象出来的类套类更复杂。说实话，还不如用面相对象实现。 面向对象，是将数据和操作，进行耦合，并且封装在类里面。这种做法是有它的好处的。这样不会导致数据和操作之间出现问题。而c如果这么写，说实话还不如用c++的类进行实现，因为类描述这些逻辑更为清晰，而且语法和编译器可以帮你做大量的事情。 而相反面向数据，是一批数据（不是一个具体数据单元），存在一批不同操作。如何分析数据之间的无关性和前后操作的无关性是重点，这两个分析清楚，那么并发计算，和分步骤计算就得以实现。并发计算不谈，分步骤计算的思想就是原子操作，或者微指令集管道设计思想。这样设计，可以令复杂的数据处理，根据流程细分到步骤，每个步骤细分到子步骤单元，而每个子步骤单元只负责处理，不负责数据的格式问题。 上面这段的设计思想和面向对象是反过来的，数据和操作松耦合。数据的特殊性导致的操作，是通过各种操作模块组合调用实现（这些操作模块可以看作上面独立的子步骤单元和外部特定数据结构无关的）。 这样做的好处是，模块的设计，可以独立进行，让外部数据格式依赖自身，而不是操作对应数据格式（面向对象是后者，成员变量类型决定了成员函数的实际操作），模块复用率高，同时是整批数据处理，只要数据流程（调用不同模块的系统设计良好），运行效率会很高。而且便于并发操作。 并发操作并不单单是一批数据，分层几组让同一个操作的多个进程处理。流水线技术的使用，一样可以实现。 这里顺带喷下hadoop。貌似hadoop的map reduce并没有在流水线方面有什么突破的思路，这块需要考虑到不同计算单元之间数据流动的费用， hadoop整天扯分布计算，根本不考虑数据整体计算周期内的相关性的问题，基本上都是推给用户自己处理，而用户应该无法控制具体计算硬件设备，最后能有好效果就扯淡了。
回答
楼主这是节点遍历时，通过函数指针动态加载节点处理函数的设计方法。这个几年前写过，后来不这么写了。主要有以下几个问题。
1、每个节点被访问时，操作可能不一样，通用的函数指针的入口参数，要么可变参，要么多套，入口指针，都是很繁琐的事情，把代码逻辑结构搞的会更复杂。
2、操作函数和操作对象没有绑定，这个在规模开发时，很容易引起混乱。这样设计的代码，我自己到后面都觉得混乱，更别说基于我的架子让别人开发，楼主你的例子不够复杂可能感觉不到。
3、上面两个问题，也导致，代码复用率不高。
现在我的设计思想，如果是基础的数据结构，如同你这个例子中就是个线形表，我都全部独立成模版，在头文件中。
特定数据的处理不会和处理方法绑定，而是调用不同通用模块来处理，这样是尽可能的让数据和处理松耦合。而关联数据再怎么关联，处理时，也是一类整体处理的，同时一批数据再怎么复合，总可以拆成不同大部分串联处理（例如，读取、处理、写出，通过增加cache的方式可以分批分步骤完成，而不是读、处理、写 、一个完整操作周期，仅针对一个单元）。所以这类数据的整体处理落在通用模块里，通过数据和处理的紧耦合的提升效率。 ######
另外，补充说一下，楼主的函数式风格，和我的函数式风格理解相差颇大。我的理解如下，所谓函数式风格，是将一批数据的若干处理，分解为正交串接的多个子步骤，每个步骤都是对整体数据的某个操作的实现。楼主的方案实质是对一个处理，可以挂接不同的操作方法。
我的理解函数式的风格在于每个独立模块处理极少的有逻辑关联的操作，可以看作针对一个数据池的原子操作。依次将数据池的数据灌入不同的独立模块，实现数据处理。当然差异的模块调用顺序和不同处理模块的组合，可以有不同的效果。
但无论如何，都是函数与数据松耦合的设计。这个和面向对象是反过来的。 ######相互嵌套耦合，牵一发动全身######楼主的代码有很浓重的其他语言的味道######楼主文章不错，我看现在的C模块基本就是你所说的面向对象风格，其实就是用数据结构组织起来。######
引用来自“中山野鬼”的答案
楼主这是节点遍历时，通过函数指针动态加载节点处理函数的设计方法。这个几年前写过，后来不这么写了。主要有以下几个问题。
1、每个节点被访问时，操作可能不一样，通用的函数指针的入口参数，要么可变参，要么多套，入口指针，都是很繁琐的事情，把代码逻辑结构搞的会更复杂。
2、操作函数和操作对象没有绑定，这个在规模开发时，很容易引起混乱。这样设计的代码，我自己到后面都觉得混乱，更别说基于我的架子让别人开发，楼主你的例子不够复杂可能感觉不到。
3、上面两个问题，也导致，代码复用率不高。
现在我的设计思想，如果是基础的数据结构，如同你这个例子中就是个线形表，我都全部独立成模版，在头文件中。
特定数据的处理不会和处理方法绑定，而是调用不同通用模块来处理，这样是尽可能的让数据和处理松耦合。而关联数据再怎么关联，处理时，也是一类整体处理的，同时一批数据再怎么复合，总可以拆成不同大部分串联处理（例如，读取、处理、写出，通过增加cache的方式可以分批分步骤完成，而不是读、处理、写 、一个完整操作周期，仅针对一个单元）。所以这类数据的整体处理落在通用模块里，通过数据和处理的紧耦合的提升效率。
你说的问题#1和文章中函数式风格一节抱怨employee_read无法和Callback兼容的问题是类似的，说到底就是因为C语言静态类型等语法特性导致了对函数式风格支持不好；同时也反向说明了为什么大多数支持函数式风格的语言会选择“动态类型”，并且支持灵活的可变个数参数等特性，都是为了辅助函数式风格的编码。
#2这一点我不太同意。C语言里虽然没有类的概念把数据和函数在语法层次上绑定在一起，但通过规范地命令提供隐喻，比如代码中，所有操作Employee对象的函数都以employee_前缀开头。而且，这些接口之间也有层级关系，符合下表描述的抽象屏障。如果你把Employee相关的声明、操作独立出来放在一个文件里，然后头文件里只放置公开的接口信息，这样就变得简洁多了。
最高层：使用API的程序 main 基于Employee的接口实现的高级操作 employee_print, employee_adjust_salary 基于最底层的C，对象Employee的最基础的操作，包括读入、释放、遍历等 employee_read, employee_free, foreach, with_open_file C语言本身提供的最底层的工具 struct Empoloyee, for, free, calloc...
例如C语言自带的操作文件的接口同样符合这样的抽象屏障：我们只需要使用fopen、fclose、fread、fwrite等一系列操作FILE对象的接口，无需关心FILE结构体里有些什么内容，表示什么意思，以及各个接口是怎么实现的。
#3的确是一个问题，而且我在文章里也可以没有提及，因为这不是这篇文章要表达的重点。它最本质的问题在于将集合的数据结构和单个对象的信息保存在同一个地方。其他语言，例如Java的java.util.*容器、C++的STL容器，都符合你的设计，将容器这个单一职责抽象出来。当然，我自己实际的工作也是这样做的。
######
引用来自“中山野鬼”的答案
另外，补充说一下，楼主的函数式风格，和我的函数式风格理解相差颇大。我的理解如下，所谓函数式风格，是将一批数据的若干处理，分解为正交串接的多个子步骤，每个步骤都是对整体数据的某个操作的实现。楼主的方案实质是对一个处理，可以挂接不同的操作方法。
我的理解函数式的风格在于每个独立模块处理极少的有逻辑关联的操作，可以看作针对一个数据池的原子操作。依次将数据池的数据灌入不同的独立模块，实现数据处理。当然差异的模块调用顺序和不同处理模块的组合，可以有不同的效果。
但无论如何，都是函数与数据松耦合的设计。这个和面向对象是反过来的。
我认为你说的是“责任单一原则”，让每个函数、每个模块责任都尽可能地单一，然后通过类似搭积木一样的灵活组合，完成不同的任务。就像UNIX下的命令，每个单独命令都只完成一件事情，通过管道等把这些功能单一的命令组织在一起，协作完成一个复杂的任务！
我个人认为这是一种设计思想，和源自Lambda演算的函数式风格并没有太大关系。
######
引用来自“杨同学”的答案
楼主的代码有很浓重的其他语言的味道
因为其他语言也能写“面向对象风格”和“函数式风格”的代码，并且看起来比C更“专业”。
######
引用来自“优游幻世”的答案
楼主文章不错，我看现在的C模块基本就是你所说的面向对象风格，其实就是用数据结构组织起来。
嗯，将数据和操作数据的方法集中在一起会让代码更容易维护。
就像我在六楼回复里提到的，很多C模块往往还会更进一步，把容器和对象也分离开来。这样容器能容纳各种不同的对象，对象则只保留数据本身，不关心和其他对象是以什么形式组织在一起的。
######
引用来自“redraiment”的答案
引用来自“中山野鬼”的答案
楼主这是节点遍历时，通过函数指针动态加载节点处理函数的设计方法。这个几年前写过，后来不这么写了。主要有以下几个问题。
1、每个节点被访问时，操作可能不一样，通用的函数指针的入口参数，要么可变参，要么多套，入口指针，都是很繁琐的事情，把代码逻辑结构搞的会更复杂。
2、操作函数和操作对象没有绑定，这个在规模开发时，很容易引起混乱。这样设计的代码，我自己到后面都觉得混乱，更别说基于我的架子让别人开发，楼主你的例子不够复杂可能感觉不到。
3、上面两个问题，也导致，代码复用率不高。
现在我的设计思想，如果是基础的数据结构，如同你这个例子中就是个线形表，我都全部独立成模版，在头文件中。
特定数据的处理不会和处理方法绑定，而是调用不同通用模块来处理，这样是尽可能的让数据和处理松耦合。而关联数据再怎么关联，处理时，也是一类整体处理的，同时一批数据再怎么复合，总可以拆成不同大部分串联处理（例如，读取、处理、写出，通过增加cache的方式可以分批分步骤完成，而不是读、处理、写 、一个完整操作周期，仅针对一个单元）。所以这类数据的整体处理落在通用模块里，通过数据和处理的紧耦合的提升效率。
你说的问题#1和文章中函数式风格一节抱怨employee_read无法和Callback兼容的问题是类似的，说到底就是因为C语言静态类型等语法特性导致了对函数式风格支持不好；同时也反向说明了为什么大多数支持函数式风格的语言会选择“动态类型”，并且支持灵活的可变个数参数等特性，都是为了辅助函数式风格的编码。
#2这一点我不太同意。C语言里虽然没有类的概念把数据和函数在语法层次上绑定在一起，但通过规范地命令提供隐喻，比如代码中，所有操作Employee对象的函数都以employee_前缀开头。而且，这些接口之间也有层级关系，符合下表描述的抽象屏障。如果你把Employee相关的声明、操作独立出来放在一个文件里，然后头文件里只放置公开的接口信息，这样就变得简洁多了。
最高层：使用API的程序 main 基于Employee的接口实现的高级操作 employee_print, employee_adjust_salary 基于最底层的C，对象Employee的最基础的操作，包括读入、释放、遍历等 employee_read, employee_free, foreach, with_open_file C语言本身提供的最底层的工具 struct Empoloyee, for, free, calloc...
例如C语言自带的操作文件的接口同样符合这样的抽象屏障：我们只需要使用fopen、fclose、fread、fwrite等一系列操作FILE对象的接口，无需关心FILE结构体里有些什么内容，表示什么意思，以及各个接口是怎么实现的。
#3的确是一个问题，而且我在文章里也可以没有提及，因为这不是这篇文章要表达的重点。它最本质的问题在于将集合的数据结构和单个对象的信息保存在同一个地方。其他语言，例如Java的java.util.*容器、C++的STL容器，都符合你的设计，将容器这个单一职责抽象出来。当然，我自己实际的工作也是这样做的。
第二个问题其实是不同设计思想的核心问题。你举的例子只能说是些简单的系统中的模块。如果是个大系统中的底层模块特别是引擎方面（会产生数据加工的），这种方法最终组合出来的系统，会比面向对象出来的类套类更复杂。说实话，还不如用面相对象实现。
面向对象，是将数据和操作，进行耦合，并且封装在类里面。这种做法是有它的好处的。这样不会导致数据和操作之间出现问题。而c如果这么写，说实话还不如用c++的类进行实现，因为类描述这些逻辑更为清晰，而且语法和编译器可以帮你做大量的事情。
而相反面向数据，是一批数据（不是一个具体数据单元），存在一批不同操作。如何分析数据之间的无关性和前后操作的无关性是重点，这两个分析清楚，那么并发计算，和分步骤计算就得以实现。并发计算不谈，分步骤计算的思想就是原子操作，或者微指令集管道设计思想。这样设计，可以令复杂的数据处理，根据流程细分到步骤，每个步骤细分到子步骤单元，而每个子步骤单元只负责处理，不负责数据的格式问题。
上面这段的设计思想和面向对象是反过来的，数据和操作松耦合。数据的特殊性导致的操作，是通过各种操作模块组合调用实现（这些操作模块可以看作上面独立的子步骤单元和外部特定数据结构无关的）。
这样做的好处是，模块的设计，可以独立进行，让外部数据格式依赖自身，而不是操作对应数据格式（面向对象是后者，成员变量类型决定了成员函数的实际操作），模块复用率高，同时是整批数据处理，只要数据流程（调用不同模块的系统设计良好），运行效率会很高。而且便于并发操作。
并发操作并不单单是一批数据，分层几组让同一个操作的多个进程处理。流水线技术的使用，一样可以实现。
这里顺带喷下hadoop。貌似hadoop的map reduce并没有在流水线方面有什么突破的思路，这块需要考虑到不同计算单元之间数据流动的费用， hadoop整天扯分布计算，根本不考虑数据整体计算周期内的相关性的问题，基本上都是推给用户自己处理，而用户应该无法控制具体计算硬件设备，最后能有好效果就扯淡了。
回答
分布式事务的解决方案有如下几种：
全局消息基于可靠消息服务的分布式事务TCC最大努力通知方案1：全局事务（DTP模型）全局事务基于DTP模型实现。DTP是由X/Open组织提出的一种分布式事务模型——X/Open Distributed Transaction Processing Reference Model。它规定了要实现分布式事务，需要三种角色：
AP：Application 应用系统 它就是我们开发的业务系统，在我们开发的过程中，可以使用资源管理器提供的事务接口来实现分布式事务。
TM：Transaction Manager 事务管理器
分布式事务的实现由事务管理器来完成，它会提供分布式事务的操作接口供我们的业务系统调用。这些接口称为TX接口。事务管理器还管理着所有的资源管理器，通过它们提供的XA接口来同一调度这些资源管理器，以实现分布式事务。DTP只是一套实现分布式事务的规范，并没有定义具体如何实现分布式事务，TM可以采用2PC、3PC、Paxos等协议实现分布式事务。RM：Resource Manager 资源管理器
能够提供数据服务的对象都可以是资源管理器，比如：数据库、消息中间件、缓存等。大部分场景下，数据库即为分布式事务中的资源管理器。资源管理器能够提供单数据库的事务能力，它们通过XA接口，将本数据库的提交、回滚等能力提供给事务管理器调用，以帮助事务管理器实现分布式的事务管理。XA是DTP模型定义的接口，用于向事务管理器提供该资源管理器(该数据库)的提交、回滚等能力。DTP只是一套实现分布式事务的规范，RM具体的实现是由数据库厂商来完成的。有没有基于DTP模型的分布式事务中间件？DTP模型有啥优缺点？方案2：基于可靠消息服务的分布式事务这种实现分布式事务的方式需要通过消息中间件来实现。假设有A和B两个系统，分别可以处理任务A和任务B。此时系统A中存在一个业务流程，需要将任务A和任务B在同一个事务中处理。下面来介绍基于消息中间件来实现这种分布式事务。
title
在系统A处理任务A前，首先向消息中间件发送一条消息消息中间件收到后将该条消息持久化，但并不投递。此时下游系统B仍然不知道该条消息的存在。消息中间件持久化成功后，便向系统A返回一个确认应答；系统A收到确认应答后，则可以开始处理任务A；任务A处理完成后，向消息中间件发送Commit请求。该请求发送完成后，对系统A而言，该事务的处理过程就结束了，此时它可以处理别的任务了。 但commit消息可能会在传输途中丢失，从而消息中间件并不会向系统B投递这条消息，从而系统就会出现不一致性。这个问题由消息中间件的事务回查机制完成，下文会介绍。消息中间件收到Commit指令后，便向系统B投递该消息，从而触发任务B的执行；当任务B执行完成后，系统B向消息中间件返回一个确认应答，告诉消息中间件该消息已经成功消费，此时，这个分布式事务完成。上述过程可以得出如下几个结论：
消息中间件扮演者分布式事务协调者的角色。
系统A完成任务A后，到任务B执行完成之间，会存在一定的时间差。在这个时间差内，整个系统处于数据不一致的状态，但这短暂的不一致性是可以接受的，因为经过短暂的时间后，系统又可以保持数据一致性，满足BASE理论。
上述过程中，如果任务A处理失败，那么需要进入回滚流程，如下图所示： title
若系统A在处理任务A时失败，那么就会向消息中间件发送Rollback请求。和发送Commit请求一样，系统A发完之后便可以认为回滚已经完成，它便可以去做其他的事情。消息中间件收到回滚请求后，直接将该消息丢弃，而不投递给系统B，从而不会触发系统B的任务B。此时系统又处于一致性状态，因为任务A和任务B都没有执行。
上面所介绍的Commit和Rollback都属于理想情况，但在实际系统中，Commit和Rollback指令都有可能在传输途中丢失。那么当出现这种情况的时候，消息中间件是如何保证数据一致性呢？——答案就是超时询问机制。
title
系统A除了实现正常的业务流程外，还需提供一个事务询问的接口，供消息中间件调用。当消息中间件收到一条事务型消息后便开始计时，如果到了超时时间也没收到系统A发来的Commit或Rollback指令的话，就会主动调用系统A提供的事务询问接口询问该系统目前的状态。该接口会返回三种结果：
提交 若获得的状态是“提交”，则将该消息投递给系统B。回滚 若获得的状态是“回滚”，则直接将条消息丢弃。处理中 若获得的状态是“处理中”，则继续等待。消息中间件的超时询问机制能够防止上游系统因在传输过程中丢失Commit/Rollback指令而导致的系统不一致情况，而且能降低上游系统的阻塞时间，上游系统只要发出Commit/Rollback指令后便可以处理其他任务，无需等待确认应答。而Commit/Rollback指令丢失的情况通过超时询问机制来弥补，这样大大降低上游系统的阻塞时间，提升系统的并发度。
下面来说一说消息投递过程的可靠性保证。 当上游系统执行完任务并向消息中间件提交了Commit指令后，便可以处理其他任务了，此时它可以认为事务已经完成，接下来消息中间件一定会保证消息被下游系统成功消费掉！那么这是怎么做到的呢？这由消息中间件的投递流程来保证。
消息中间件向下游系统投递完消息后便进入阻塞等待状态，下游系统便立即进行任务的处理，任务处理完成后便向消息中间件返回应答。消息中间件收到确认应答后便认为该事务处理完毕！
如果消息在投递过程中丢失，或消息的确认应答在返回途中丢失，那么消息中间件在等待确认应答超时之后就会重新投递，直到下游消费者返回消费成功响应为止。当然，一般消息中间件可以设置消息重试的次数和时间间隔，比如：当第一次投递失败后，每隔五分钟重试一次，一共重试3次。如果重试3次之后仍然投递失败，那么这条消息就需要人工干预。 title
title
有的同学可能要问：消息投递失败后为什么不回滚消息，而是不断尝试重新投递？
这就涉及到整套分布式事务系统的实现成本问题。 我们知道，当系统A将向消息中间件发送Commit指令后，它便去做别的事情了。如果此时消息投递失败，需要回滚的话，就需要让系统A事先提供回滚接口，这无疑增加了额外的开发成本，业务系统的复杂度也将提高。对于一个业务系统的设计目标是，在保证性能的前提下，最大限度地降低系统复杂度，从而能够降低系统的运维成本。
不知大家是否发现，上游系统A向消息中间件提交Commit/Rollback消息采用的是异步方式，也就是当上游系统提交完消息后便可以去做别的事情，接下来提交、回滚就完全交给消息中间件来完成，并且完全信任消息中间件，认为它一定能正确地完成事务的提交或回滚。然而，消息中间件向下游系统投递消息的过程是同步的。也就是消息中间件将消息投递给下游系统后，它会阻塞等待，等下游系统成功处理完任务返回确认应答后才取消阻塞等待。为什么这两者在设计上是不一致的呢？
首先，上游系统和消息中间件之间采用异步通信是为了提高系统并发度。业务系统直接和用户打交道，用户体验尤为重要，因此这种异步通信方式能够极大程度地降低用户等待时间。此外，异步通信相对于同步通信而言，没有了长时间的阻塞等待，因此系统的并发性也大大增加。但异步通信可能会引起Commit/Rollback指令丢失的问题，这就由消息中间件的超时询问机制来弥补。
那么，消息中间件和下游系统之间为什么要采用同步通信呢？
异步能提升系统性能，但随之会增加系统复杂度；而同步虽然降低系统并发度，但实现成本较低。因此，在对并发度要求不是很高的情况下，或者服务器资源较为充裕的情况下，我们可以选择同步来降低系统的复杂度。 我们知道，消息中间件是一个独立于业务系统的第三方中间件，它不和任何业务系统产生直接的耦合，它也不和用户产生直接的关联，它一般部署在独立的服务器集群上，具有良好的可扩展性，所以不必太过于担心它的性能，如果处理速度无法满足我们的要求，可以增加机器来解决。而且，即使消息中间件处理速度有一定的延迟那也是可以接受的，因为前面所介绍的BASE理论就告诉我们了，我们追求的是最终一致性，而非实时一致性，因此消息中间件产生的时延导致事务短暂的不一致是可以接受的。
方案3：最大努力通知（定期校对）最大努力通知也被称为定期校对，其实在方案二中已经包含，这里再单独介绍，主要是为了知识体系的完整性。这种方案也需要消息中间件的参与，其过程如下：
title
上游系统在完成任务后，向消息中间件同步地发送一条消息，确保消息中间件成功持久化这条消息，然后上游系统可以去做别的事情了；消息中间件收到消息后负责将该消息同步投递给相应的下游系统，并触发下游系统的任务执行；当下游系统处理成功后，向消息中间件反馈确认应答，消息中间件便可以将该条消息删除，从而该事务完成。上面是一个理想化的过程，但在实际场景中，往往会出现如下几种意外情况：
消息中间件向下游系统投递消息失败上游系统向消息中间件发送消息失败对于第一种情况，消息中间件具有重试机制，我们可以在消息中间件中设置消息的重试次数和重试时间间隔，对于网络不稳定导致的消息投递失败的情况，往往重试几次后消息便可以成功投递，如果超过了重试的上限仍然投递失败，那么消息中间件不再投递该消息，而是记录在失败消息表中，消息中间件需要提供失败消息的查询接口，下游系统会定期查询失败消息，并将其消费，这就是所谓的“定期校对”。
如果重复投递和定期校对都不能解决问题，往往是因为下游系统出现了严重的错误，此时就需要人工干预。
对于第二种情况，需要在上游系统中建立消息重发机制。可以在上游系统建立一张本地消息表，并将 任务处理过程 和 向本地消息表中插入消息 这两个步骤放在一个本地事务中完成。如果向本地消息表插入消息失败，那么就会触发回滚，之前的任务处理结果就会被取消。如果这量步都执行成功，那么该本地事务就完成了。接下来会有一个专门的消息发送者不断地发送本地消息表中的消息，如果发送失败它会返回重试。当然，也要给消息发送者设置重试的上限，一般而言，达到重试上限仍然发送失败，那就意味着消息中间件出现严重的问题，此时也只有人工干预才能解决问题。
对于不支持事务型消息的消息中间件，如果要实现分布式事务的话，就可以采用这种方式。它能够通过重试机制+定期校对实现分布式事务，但相比于第二种方案，它达到数据一致性的周期较长，而且还需要在上游系统中实现消息重试发布机制，以确保消息成功发布给消息中间件，这无疑增加了业务系统的开发成本，使得业务系统不够纯粹，并且这些额外的业务逻辑无疑会占用业务系统的硬件资源，从而影响性能。
因此，尽量选择支持事务型消息的消息中间件来实现分布式事务，如RocketMQ。
方案4：TCC（两阶段型、补偿型）TCC即为Try Confirm Cancel，它属于补偿型分布式事务。顾名思义，TCC实现分布式事务一共有三个步骤：
Try：尝试待执行的业务 这个过程并未执行业务，只是完成所有业务的一致性检查，并预留好执行所需的全部资源Confirm：执行业务 这个过程真正开始执行业务，由于Try阶段已经完成了一致性检查，因此本过程直接执行，而不做任何检查。并且在执行的过程中，会使用到Try阶段预留的业务资源。Cancel：取消执行的业务 若业务执行失败，则进入Cancel阶段，它会释放所有占用的业务资源，并回滚Confirm阶段执行的操作。下面以一个转账的例子来解释下TCC实现分布式事务的过程。
假设用户A用他的账户余额给用户B发一个100元的红包，并且余额系统和红包系统是两个独立的系统。
Try
创建一条转账流水，并将流水的状态设为交易中将用户A的账户中扣除100元（预留业务资源）Try成功之后，便进入Confirm阶段Try过程发生任何异常，均进入Cancel阶段Confirm
向B用户的红包账户中增加100元将流水的状态设为交易已完成Confirm过程发生任何异常，均进入Cancel阶段Confirm过程执行成功，则该事务结束Cancel
将用户A的账户增加100元将流水的状态设为交易失败在传统事务机制中，业务逻辑的执行和事务的处理，是在不同的阶段由不同的部件来完成的：业务逻辑部分访问资源实现数据存储，其处理是由业务系统负责；事务处理部分通过协调资源管理器以实现事务管理，其处理由事务管理器来负责。二者没有太多交互的地方，所以，传统事务管理器的事务处理逻辑，仅需要着眼于事务完成（commit/rollback）阶段，而不必关注业务执行阶段。
TCC全局事务必须基于RM本地事务来实现全局事务TCC服务是由Try/Confirm/Cancel业务构成的， 其Try/Confirm/Cancel业务在执行时，会访问资源管理器（Resource Manager，下文简称RM）来存取数据。这些存取操作，必须要参与RM本地事务，以使其更改的数据要么都commit，要么都rollback。
这一点不难理解，考虑一下如下场景：
title
假设图中的服务B没有基于RM本地事务（以RDBS为例，可通过设置auto-commit为true来模拟），那么一旦[B:Try]操作中途执行失败，TCC事务框架后续决定回滚全局事务时，该[B:Cancel]则需要判断[B:Try]中哪些操作已经写到DB、哪些操作还没有写到DB：假设[B:Try]业务有5个写库操作，[B:Cancel]业务则需要逐个判断这5个操作是否生效，并将生效的操作执行反向操作。
不幸的是，由于[B:Cancel]业务也有n（0<=n<=5）个反向的写库操作，此时一旦[B:Cancel]也中途出错，则后续的[B:Cancel]执行任务更加繁重。因为，相比第一次[B:Cancel]操作，后续的[B:Cancel]操作还需要判断先前的[B:Cancel]操作的n（0<=n<=5）个写库中哪几个已经执行、哪几个还没有执行，这就涉及到了幂等性问题。而对幂等性的保障，又很可能还需要涉及额外的写库操作，该写库操作又会因为没有RM本地事务的支持而存在类似问题。。。可想而知，如果不基于RM本地事务，TCC事务框架是无法有效的管理TCC全局事务的。
反之，基于RM本地事务的TCC事务，这种情况则会很容易处理：[B:Try]操作中途执行失败，TCC事务框架将其参与RM本地事务直接rollback即可。后续TCC事务框架决定回滚全局事务时，在知道“[B:Try]操作涉及的RM本地事务已经rollback”的情况下，根本无需执行[B:Cancel]操作。
换句话说，基于RM本地事务实现TCC事务框架时，一个TCC型服务的cancel业务要么执行，要么不执行，不需要考虑部分执行的情况。
TCC事务框架应该提供Confirm/Cancel服务的幂等性保障一般认为，服务的幂等性，是指针对同一个服务的多次(n>1)请求和对它的单次(n=1)请求，二者具有相同的副作用。
在TCC事务模型中，Confirm/Cancel业务可能会被重复调用，其原因很多。比如，全局事务在提交/回滚时会调用各TCC服务的Confirm/Cancel业务逻辑。执行这些Confirm/Cancel业务时，可能会出现如网络中断的故障而使得全局事务不能完成。因此，故障恢复机制后续仍然会重新提交/回滚这些未完成的全局事务，这样就会再次调用参与该全局事务的各TCC服务的Confirm/Cancel业务逻辑。
既然Confirm/Cancel业务可能会被多次调用，就需要保障其幂等性。 那么，应该由TCC事务框架来提供幂等性保障？还是应该由业务系统自行来保障幂等性呢？ 个人认为，应该是由TCC事务框架来提供幂等性保障。如果仅仅只是极个别服务存在这个问题的话，那么由业务系统来负责也是可以的；然而，这是一类公共问题，毫无疑问，所有TCC服务的Confirm/Cancel业务存在幂等性问题。TCC服务的公共问题应该由TCC事务框架来解决；而且，考虑一下由业务系统来负责幂等性需要考虑的问题，就会发现，这无疑增大了业务系统的复杂度。
回答
两天多了没人回答，很冷清啊。所有的页面显示都是HTML，无论是原生HTML或者说是此基础上的模板或者其它，最终的形式都是HTML。
然后这些所谓的模板，就是在原本单一的HTML 基础之上做了许多便于开发的事情。比如逻辑判断，比如运算，比如过滤器。当然了，还有比较重要的数据绑定。
数据绑定的功能得到的结果就是写页面，相似的页面仅需提供一个“模板”，相应的地方丢进去需要的数据即可，此处的“模板”是一个可以理解为数据容器，相当于商场柜台，商场本身已经提供了展示柜，即为此处“模板”，而里面需要展示的东西即为值。这也就使得一个网站 “动态” 化了。
然后回到你问的模板，你所提到的‘网上的“html模板”’，并不知道你指代的是什么。Jinja2 是模板，Flask这个框架把它整合在内，对于一种很简单的使用情况，函数返回到相应模板并给定需要传递的值，页面即可获取并解析、显示。
如下代码：
@app.route('/')
def index():
return render_template("index.html", data="world")
以及
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
</head>
<body>
Hello {{ data }} !
</body>
</html>
假设是这种使用情形下需要前后端分离，需要做好的就是前后端约定好需要传递、接受的数据即可。
还有一种模板，纯JS的，如AngularJS 的 ng-template。它所做的事情，也是将获取到的值传递给页面并显示出来。只是多了很多额外的功能。比如自定义指令：
var app = angular.module('MyApp', [], function(){});
app.directive('helloWorld',
function() {
return {
restrict: 'E',
template: '<div>Hello World!</div>'
};
})
以及
<hello-world></hello-world>
这里的hello－world标签显然是HTML自身所不具备的，但是通过以上自定义指令，通过Angular解析即可使用。而这种使用情境下的前后端分离，体现在了服务端仅仅提供数据，服务端不关心数据如何进一步处理，如何解析到页面。这样的话，前端更近一步的分离出来了，到了可以不关心后台使用何种语言，无论Python、Java或者其它，只要能提供数据即可。
对于Flask里用到的Jinja2，AngularJS 里的ng-template，均可以理解为框架已整合好，开箱即用的。基于这种情况必然会有人对此不满不喜欢而希望有其它的东西，因而必然有其它模板。比如Jade，一种以Python风格写HTML的模板，比如Transparency。
那么，问题来了，假如没有这些模板，你该怎样去写页面呢？
另外，以上的回答，可能全都是错的，所以需要你自己去考证， XD。
回答
一、基础篇 1.1、Java基础 面向对象的特征：继承、封装和多态
final, finally, finalize 的区别
Exception、Error、运行时异常与一般异常有何异同
请写出5种常见到的runtime exception
int 和 Integer 有什么区别，Integer的值缓存范围
包装类，装箱和拆箱
String、StringBuilder、StringBuffer
重载和重写的区别
抽象类和接口有什么区别
说说反射的用途及实现
说说自定义注解的场景及实现
HTTP请求的GET与POST方式的区别
Session与Cookie区别
列出自己常用的JDK包
MVC设计思想
equals与==的区别
hashCode和equals方法的区别与联系
什么是Java序列化和反序列化，如何实现Java序列化？或者请解释Serializable 接口的作用
Object类中常见的方法，为什么wait notify会放在Object里边？
Java的平台无关性如何体现出来的
JDK和JRE的区别
Java 8有哪些新特性
1.2、Java常见集合 List 和 Set 区别
Set和hashCode以及equals方法的联系
List 和 Map 区别
Arraylist 与 LinkedList 区别
ArrayList 与 Vector 区别
HashMap 和 Hashtable 的区别
HashSet 和 HashMap 区别
HashMap 和 ConcurrentHashMap 的区别
HashMap 的工作原理及代码实现，什么时候用到红黑树
多线程情况下HashMap死循环的问题
HashMap出现Hash DOS攻击的问题
ConcurrentHashMap 的工作原理及代码实现，如何统计所有的元素个数
手写简单的HashMap
看过那些Java集合类的源码
1.3、进程和线程
线程和进程的概念、并行和并发的概念
创建线程的方式及实现
进程间通信的方式
说说 CountDownLatch、CyclicBarrier 原理和区别
说说 Semaphore 原理
说说 Exchanger 原理
ThreadLocal 原理分析，ThreadLocal为什么会出现OOM，出现的深层次原理
讲讲线程池的实现原理
线程池的几种实现方式
线程的生命周期，状态是如何转移的
可参考：《Java多线程编程核心技术》
1.4、锁机制 说说线程安全问题，什么是线程安全，如何保证线程安全
重入锁的概念，重入锁为什么可以防止死锁
产生死锁的四个条件（互斥、请求与保持、不剥夺、循环等待）
如何检查死锁（通过jConsole检查死锁）
volatile 实现原理（禁止指令重排、刷新内存）
synchronized 实现原理（对象监视器）
synchronized 与 lock 的区别
AQS同步队列
CAS无锁的概念、乐观锁和悲观锁
常见的原子操作类
什么是ABA问题，出现ABA问题JDK是如何解决的
乐观锁的业务场景及实现方式
Java 8并法包下常见的并发类
偏向锁、轻量级锁、重量级锁、自旋锁的概念
可参考：《Java多线程编程核心技术》
1.5、JVM JVM运行时内存区域划分
内存溢出OOM和堆栈溢出SOE的示例及原因、如何排查与解决
如何判断对象是否可以回收或存活
常见的GC回收算法及其含义
常见的JVM性能监控和故障处理工具类：jps、jstat、jmap、jinfo、jconsole等
JVM如何设置参数
JVM性能调优
类加载器、双亲委派模型、一个类的生命周期、类是如何加载到JVM中的
类加载的过程：加载、验证、准备、解析、初始化
强引用、软引用、弱引用、虚引用
Java内存模型JMM
1.6、设计模式 常见的设计模式
设计模式的的六大原则及其含义
常见的单例模式以及各种实现方式的优缺点，哪一种最好，手写常见的单利模式
设计模式在实际场景中的应用
Spring中用到了哪些设计模式
MyBatis中用到了哪些设计模式
你项目中有使用哪些设计模式
说说常用开源框架中设计模式使用分析
动态代理很重要！！！
1.7、数据结构
树（二叉查找树、平衡二叉树、红黑树、B树、B+树）
深度有限算法、广度优先算法
克鲁斯卡尔算法、普林母算法、迪克拉斯算法
什么是一致性Hash及其原理、Hash环问题
常见的排序算法和查找算法：快排、折半查找、堆排序等
1.8、网络/IO基础 BIO、NIO、AIO的概念
什么是长连接和短连接
Http1.0和2.0相比有什么区别，可参考《Http 2.0》
Https的基本概念
三次握手和四次挥手、为什么挥手需要四次
从游览器中输入URL到页面加载的发生了什么？可参考《从输入URL到页面加载发生了什么》
二、数据存储和消息队列
2.1、数据库 MySQL 索引使用的注意事项
DDL、DML、DCL分别指什么
explain命令
left join，right join，inner join
数据库事物ACID（原子性、一致性、隔离性、持久性）
事物的隔离级别（读未提交、读以提交、可重复读、可序列化读）
脏读、幻读、不可重复读
数据库的几大范式
数据库常见的命令
说说分库与分表设计
分库与分表带来的分布式困境与应对之策（如何解决分布式下的分库分表，全局表？）
说说 SQL 优化之道
MySQL遇到的死锁问题、如何排查与解决
存储引擎的 InnoDB与MyISAM区别，优缺点，使用场景
索引类别（B+树索引、全文索引、哈希索引）、索引的原理
什么是自适应哈希索引（AHI）
为什么要用 B+tree作为MySQL索引的数据结构
聚集索引与非聚集索引的区别
遇到过索引失效的情况没，什么时候可能会出现，如何解决
limit 20000 加载很慢怎么解决
如何选择合适的分布式主键方案
选择合适的数据存储方案
常见的几种分布式ID的设计方案
常见的数据库优化方案，在你的项目中数据库如何进行优化的
2.2、Redis Redis 有哪些数据类型，可参考《Redis常见的5种不同的数据类型详解》
Redis 内部结构
Redis 使用场景
Redis 持久化机制，可参考《使用快照和AOF将Redis数据持久化到硬盘中》
Redis 集群方案与实现
Redis 为什么是单线程的？
缓存雪崩、缓存穿透、缓存预热、缓存更新、缓存降级
使用缓存的合理性问题
Redis常见的回收策略
2.3、消息队列 消息队列的使用场景
消息的重发补偿解决思路
消息的幂等性解决思路
消息的堆积解决思路
自己如何实现消息队列
如何保证消息的有序性
三、开源框架和容器 3.1、SSM/Servlet Servlet的生命周期
转发与重定向的区别
BeanFactory 和 ApplicationContext 有什么区别
Spring Bean 的生命周期
Spring IOC 如何实现
Spring中Bean的作用域，默认的是哪一个
说说 Spring AOP、Spring AOP 实现原理
动态代理（CGLib 与 JDK）、优缺点、性能对比、如何选择
Spring 事务实现方式、事务的传播机制、默认的事务类别
Spring 事务底层原理
Spring事务失效（事务嵌套），JDK动态代理给Spring事务埋下的坑，可参考《JDK动态代理给Spring事务埋下的坑！》
如何自定义注解实现功能
Spring MVC 运行流程
Spring MVC 启动流程
Spring 的单例实现原理
Spring 框架中用到了哪些设计模式
Spring 其他产品（Srping Boot、Spring Cloud、Spring Secuirity、Spring Data、Spring AMQP 等）
有没有用到Spring Boot，Spring Boot的认识、原理
MyBatis的原理
可参考《为什么会有Spring》
可参考《为什么会有Spring AOP》
3.2、Netty 为什么选择 Netty
说说业务中，Netty 的使用场景
原生的 NIO 在 JDK 1.7 版本存在 epoll bug
什么是TCP 粘包/拆包
TCP粘包/拆包的解决办法
Netty 线程模型
说说 Netty 的零拷贝
Netty 内部执行流程
Netty 重连实现
3.3、Tomcat
Tomcat的基础架构（Server、Service、Connector、Container）
Tomcat如何加载Servlet的
Pipeline-Valve机制
可参考：《四张图带你了解Tomcat系统架构！》
四、分布式 4.1、Nginx 请解释什么是C10K问题或者知道什么是C10K问题吗？
Nginx简介，可参考《Nginx简介》
正向代理和反向代理.
Nginx几种常见的负载均衡策略
Nginx服务器上的Master和Worker进程分别是什么
使用“反向代理服务器”的优点是什么?
4.2、分布式其他 谈谈业务中使用分布式的场景
Session 分布式方案
Session 分布式处理
分布式锁的应用场景、分布式锁的产生原因、基本概念
分布是锁的常见解决方案
分布式事务的常见解决方案
集群与负载均衡的算法与实现
说说分库与分表设计，可参考《数据库分库分表策略的具体实现方案》
分库与分表带来的分布式困境与应对之策
4.3、Dubbo
什么是Dubbo，可参考《Dubbo入门》
什么是RPC、如何实现RPC、RPC 的实现原理，可参考《基于HTTP的RPC实现》
Dubbo中的SPI是什么概念
Dubbo的基本原理、执行流程
五、微服务
5.1、微服务
前后端分离是如何做的？
微服务哪些框架
Spring Could的常见组件有哪些？可参考《Spring Cloud概述》
领域驱动有了解吗？什么是领域驱动模型？充血模型、贫血模型
JWT有了解吗，什么是JWT，可参考《前后端分离利器之JWT》
你怎么理解 RESTful
说说如何设计一个良好的 API
如何理解 RESTful API 的幂等性
如何保证接口的幂等性
说说 CAP 定理、BASE 理论
怎么考虑数据一致性问题
说说最终一致性的实现方案
微服务的优缺点，可参考《微服务批判》
微服务与 SOA 的区别
如何拆分服务、水平分割、垂直分割
如何应对微服务的链式调用异常
如何快速追踪与定位问题
如何保证微服务的安全、认证
5.2、安全问题 如何防范常见的Web攻击、如何方式SQL注入
服务端通信安全攻防
HTTPS原理剖析、降级攻击、HTTP与HTTPS的对比
5.3、性能优化 性能指标有哪些
如何发现性能瓶颈
性能调优的常见手段
说说你在项目中如何进行性能调优
六、其他 6.1、设计能力 说说你在项目中使用过的UML图
你如何考虑组件化、服务化、系统拆分
秒杀场景如何设计
可参考：《秒杀系统的技术挑战、应对策略以及架构设计总结一二！》
6.2、业务工程 说说你的开发流程、如何进行自动化部署的
你和团队是如何沟通的
你如何进行代码评审
说说你对技术与业务的理解
说说你在项目中遇到感觉最难Bug，是如何解决的
介绍一下工作中的一个你认为最有价值的项目，以及在这个过程中的角色、解决的问题、你觉得你们项目还有哪些不足的地方
6.3、软实力 说说你的优缺点、亮点
说说你最近在看什么书、什么博客、在研究什么新技术、再看那些开源项目的源代码
说说你觉得最有意义的技术书籍
工作之余做什么事情、平时是如何学习的，怎样提升自己的能力
说说个人发展方向方面的思考
说说你认为的服务端开发工程师应该具备哪些能力
说说你认为的架构师是什么样的，架构师主要做什么
如何看待加班的问题
回答
有必要；
Redis事务使用总结： Redis的事务机制允许同时执行多条指令，它是原子性操作，事务中的命令要么全部执行，要么全部不执行，另外，事务中的所有指令都会被序列化，而且其开始执行过程中，不回被即时过来的指令所打断，其需要经历三个过程，分别为开始事务、命令入队以及执行事务。 · 相关命令 · 如何使用 · 脚本事务 · 遇到问题 · 例子演示 一、相关命令 1、MULTI 该命令用来开启事务，它总是返回ok结果，当其执行之后，客户端可以继续发送任意条数量的指令，这些指令不会立即被执行，而是被放到了队列中，直到EXEC被调用之后，所有命令才会被序列化执行。 2、EXEC 该命令负责触发并执行队列中所有的命令。 NOTE: 如果MULTI开启之后，因为某些原因没有成功执行EXEC，那么事务中所有的命令都不会被执行的。 3、DISCARD 该命令用来刷新事务中所有排队等待执行的指令，它总是返回ok结果，并且将服务连接状态恢复到正常。如果已经使用WATCH，那么其会将释放所有被WATCH的key。 4、WATCH 标记所有指定的key被监控起来，使其在事务中有条件的执行（乐观锁）。 NOTE: A、WATCH使得EXEC命令需要有条件的执行，也就是事务只能在所有被监视的键没有被修改的前提下才能执行。另外，在EXEC被执行之后，所有的WATCH都会被取消。 B、UNWATCH手动取消对所有键的WATCH，如果执行了EXEC或者DISCARD，则不需要手动执行UNWATCH命令。 二、如何使用 Redis原生使用(Redis-cli)： 127.0.0.1:6379> multi // 事务开始的动作标志下面即为入队 OK 127.0.0.1:6379> set book-name "Thinking in Java" QUEUED 127.0.0.1:6379> get book-name QUEUED 127.0.0.1:6379> sadd tag "java" "Programming""Thinking" QUEUED 127.0.0.1:6379> smembers tag QUEUED 127.0.0.1:6379> exec // 执行事务 1) OK 2) "Thinking in Java" 3) (integer) 3 4) 1) "Thinking" 2) "Programming" 3) "java" 127.0.0.1:6379> discard // 事务已执行完毕 已经自动取消 (error) ERR DISCARD without MULTI 127.0.0.1:6379> multi OK 127.0.0.1:6379> set book-name "Patterns in Java" QUEUED 127.0.0.1:6379> get book-name QUEUED 127.0.0.1:6379> sadd tag "Java" "Thinking""Programming" QUEUED 127.0.0.1:6379> smembers tag QUEUED 127.0.0.1:6379> discard // 事务未执行 可以刷新队列指令状态 取消执行 OK 127.0.0.1:6379> exec // 事务已经被取消不能再执行 (error) ERR EXEC without MULTI 三、脚本事务 Redis 2.6开始支持了脚本，而该脚本本身就是一种事务机制，所以任何在事务里可以完成的事，在脚本里面也能完成，并且使用脚本更简单些，并且速度也更快。不过因为事务提供了一种即使不使用脚本，也可以避免竞争条件的方法，并且事务本身的实现并不复杂，所以现在的使用也比较多，但不排除日后可能被替代或是占据主要地位的可能。 NOTE： Redis为什么引入两种处理事务的方式？脚本功能是 Redis 2.6 才引入的，而事务功能则在更早之前就存在，所以 Redis 才会同时存在两种处理事务的方法。另外，事务脚本会在后续文章中总结介绍。 四、遇到问题 1、乐观锁实现 举个例子，假设我们需要原子性为某个键加1操作（假设INCR不存在），那么应该是这样的执行语句： SET mykey 1 val = GET mykey val = val + 1 SET mykey ${val} 单个客户端访问操作没有任何问题，如果是多个客户端同时访问mykey，就会产生资源共享访问问题，比如：现在有个两个客户端访问同一个键mykey，那么mykey的可能是2，但是我们期望的值应该是3才对，这个类似于高并发下的sync锁机制，所以我们需要使用WATCH来监控被共享的键mykey，如下： WATCH mykey（可监控多个键） val = GET mykey val = val + 1 MULTI SET mykey ${val} EXEC NOTE： 虽然大多情况下，多个客户端访问操作同一个键的情况很少或没有，但是不能排除这个特殊情况，所以建议在有可能产生键共享的指令中使用WATCH在EXEC执行前对其监管。 2、Redis不支持回滚(Roll Back) Redis的事务不支持回滚，这点不同于关系数据库中的事务，所以它的内部保持了简单且快速的特点。另外，Redis不支持回滚是这样考虑的：Redis事务中命令之所以会失败，是由于错误的编程所造成，通过事务回滚是不能回避这个根本问题。 NOTE： Redis事务中命令执行失败，仍会继续执行后面的执行，在没有特殊干预前提下，直到执行完队列中所有指令为止。 3、使用事务可能遇到的问题 A、事务在执行 EXEC 之前，入队的命令可能会出错，举个例子：命令可能会产生语法错误（参数数量错误，参数名错误等），或者其他更严重的错误，比如内存不足（如果服务器使用maxmemory 设置了最大内存限制的话）。 B、事务在执行 EXEC 之前，举个例子：事务中的命令可能处理了错误类型的键，比如将列表命令用在了字符串键上面等。 对于发生在 EXEC 执行之前的错误，客户端以前的做法是检查命令入队所得的返回值：如果命令入队时返回QUEUED ，那么入队成功；否则，就是入队失败。如果有命令在入队时失败，那么大部分客户端都会停止并取消这个事务。 从 Redis 2.6.5 开始，服务器会对命令入队失败的情况进行记录，并在客户端调用 EXEC 命令时，拒绝执行并自动放弃这个事务。 在 Redis 2.6.5 以前， Redis 只执行事务中那些入队成功的命令，而忽略那些入队失败的命令。而新的处理方式则使得在管道技术中包含事务变得简单，因为发送事务和读取事务的回复都只需要和服务器进行一次通讯即可。 至于那些在 EXEC 命令执行之后所产生的错误，并没有对它们进行特别处理： 即使事务中有某个/某些命令在执行时产生了错误， 事务中的其他命令仍然会继续执行。 五、例子演示
connect('127.0.0.1',6379); $result = array(); // 开启事务 $redis->multi(); // 添加指令到队列 $redis->set('book-name','Thinking in PHP!'); $redis->sAdd('tags','PHP','Programming','Thinking'); $bookname = $redis->get('book-name'); $tags = $redis->sMembers('tags'); // 执行事务 $redis->exec(); // 显示结果 echo '书名：'.$bookname.' 标签：'.$tags; ?> 结果：
答案来源于网络
回答
算法的本质是解决问题的方法，是思想
在早期的时候，人们遇到新问题，必须要去解决它，经过“冥思苦想”，“反复探索尝试”， 最后总结归纳。这才形成了今天我们学习的各种算法。如果无法领会到解决问题的思想，无法总结归纳，就会有：“学算法有什么用。”。不知道为什么学，自然会认为学了没意义，没有用处。
2.一个算法应该具有以下五个重要的特征：
①有穷性: 算法的有穷性是指算法必须能在执行有限个步骤之后终止，换句话说就是一个算法必须总是在执行有穷步之后结束，且每一步都可在有穷时间内完成。②确定性：算法中的每条指令必须有确切的定义，不会产生二义性，并且对于相同的输入只能得出相同的输出。③可行性：算法中执行的任何计算步骤都是可以被分解为基本的可执行的操作步，即每个计算步都可以在有限时间内完成（也称之为有效性）。④输入： 一个算法有0个或多个输入，以刻画运算对象的初始情况，所谓0个输入是指算法本身定出了初始条件，这些输入取自于某个特定的对象集合。
⑤输出：一个算法有一个或多个的输出，这些输出是同输入有着特定关系的量，没有输出的算法是毫无意义的。
算法总是要解决特定的问题，问题来源就是算法的输入，期望的结果就是算法的输出，没有输入输出的算法是无意义的。3.算法设计的5个要求：①正确性：最基本要求，算法必须能解决某个问题的需求。②可读性：算法的可读性有助于人的阅读与交流，容易调试和修改。③健壮性：当输入的数据非法时，算法能适当做出反应或进行处理，而不会产生莫名其妙的输出结果。④效率性：算法是为了解决大规模问题，因此需要运行效率足够快。⑤存储性：算法在执行过程中，所需要的最大存储空间，应该尽可能的占用小。效率性与存储性都与问题规模有关，求100人的平均分与求1000人的平均分，同一个算法的所花费的执行时间与存储空间显然是不一样的。
正确性，可读性，健壮性不仅仅是算法设计的要求，而是贯穿整个软件设计层次。单对于算法本身来说，我们最关注的层面是效率性。千万不能死板的认为，算法就是计算机程序。算法是一切解决问题的思想，语言描述，伪代码，流程图，各种符号或者控制表格同样是算法。
回答
有必要；
Redis事务使用总结： Redis的事务机制允许同时执行多条指令，它是原子性操作，事务中的命令要么全部执行，要么全部不执行，另外，事务中的所有指令都会被序列化，而且其开始执行过程中，不回被即时过来的指令所打断，其需要经历三个过程，分别为开始事务、命令入队以及执行事务。 · 相关命令 · 如何使用 · 脚本事务 · 遇到问题 · 例子演示 一、相关命令 1、MULTI 该命令用来开启事务，它总是返回ok结果，当其执行之后，客户端可以继续发送任意条数量的指令，这些指令不会立即被执行，而是被放到了队列中，直到EXEC被调用之后，所有命令才会被序列化执行。 2、EXEC 该命令负责触发并执行队列中所有的命令。 NOTE: 如果MULTI开启之后，因为某些原因没有成功执行EXEC，那么事务中所有的命令都不会被执行的。 3、DISCARD 该命令用来刷新事务中所有排队等待执行的指令，它总是返回ok结果，并且将服务连接状态恢复到正常。如果已经使用WATCH，那么其会将释放所有被WATCH的key。 4、WATCH 标记所有指定的key被监控起来，使其在事务中有条件的执行（乐观锁）。 NOTE: A、WATCH使得EXEC命令需要有条件的执行，也就是事务只能在所有被监视的键没有被修改的前提下才能执行。另外，在EXEC被执行之后，所有的WATCH都会被取消。 B、UNWATCH手动取消对所有键的WATCH，如果执行了EXEC或者DISCARD，则不需要手动执行UNWATCH命令。 二、如何使用 Redis原生使用(Redis-cli)： 127.0.0.1:6379> multi // 事务开始的动作标志下面即为入队 OK 127.0.0.1:6379> set book-name "Thinking in Java" QUEUED 127.0.0.1:6379> get book-name QUEUED 127.0.0.1:6379> sadd tag "java" "Programming""Thinking" QUEUED 127.0.0.1:6379> smembers tag QUEUED 127.0.0.1:6379> exec // 执行事务 1) OK 2) "Thinking in Java" 3) (integer) 3 4) 1) "Thinking" 2) "Programming" 3) "java" 127.0.0.1:6379> discard // 事务已执行完毕 已经自动取消 (error) ERR DISCARD without MULTI 127.0.0.1:6379> multi OK 127.0.0.1:6379> set book-name "Patterns in Java" QUEUED 127.0.0.1:6379> get book-name QUEUED 127.0.0.1:6379> sadd tag "Java" "Thinking""Programming" QUEUED 127.0.0.1:6379> smembers tag QUEUED 127.0.0.1:6379> discard // 事务未执行 可以刷新队列指令状态 取消执行 OK 127.0.0.1:6379> exec // 事务已经被取消不能再执行 (error) ERR EXEC without MULTI 三、脚本事务 Redis 2.6开始支持了脚本，而该脚本本身就是一种事务机制，所以任何在事务里可以完成的事，在脚本里面也能完成，并且使用脚本更简单些，并且速度也更快。不过因为事务提供了一种即使不使用脚本，也可以避免竞争条件的方法，并且事务本身的实现并不复杂，所以现在的使用也比较多，但不排除日后可能被替代或是占据主要地位的可能。 NOTE： Redis为什么引入两种处理事务的方式？脚本功能是 Redis 2.6 才引入的，而事务功能则在更早之前就存在，所以 Redis 才会同时存在两种处理事务的方法。另外，事务脚本会在后续文章中总结介绍。 四、遇到问题 1、乐观锁实现 举个例子，假设我们需要原子性为某个键加1操作（假设INCR不存在），那么应该是这样的执行语句： SET mykey 1 val = GET mykey val = val + 1 SET mykey ${val} 单个客户端访问操作没有任何问题，如果是多个客户端同时访问mykey，就会产生资源共享访问问题，比如：现在有个两个客户端访问同一个键mykey，那么mykey的可能是2，但是我们期望的值应该是3才对，这个类似于高并发下的sync锁机制，所以我们需要使用WATCH来监控被共享的键mykey，如下： WATCH mykey（可监控多个键） val = GET mykey val = val + 1 MULTI SET mykey ${val} EXEC NOTE： 虽然大多情况下，多个客户端访问操作同一个键的情况很少或没有，但是不能排除这个特殊情况，所以建议在有可能产生键共享的指令中使用WATCH在EXEC执行前对其监管。 2、Redis不支持回滚(Roll Back) Redis的事务不支持回滚，这点不同于关系数据库中的事务，所以它的内部保持了简单且快速的特点。另外，Redis不支持回滚是这样考虑的：Redis事务中命令之所以会失败，是由于错误的编程所造成，通过事务回滚是不能回避这个根本问题。 NOTE： Redis事务中命令执行失败，仍会继续执行后面的执行，在没有特殊干预前提下，直到执行完队列中所有指令为止。 3、使用事务可能遇到的问题 A、事务在执行 EXEC 之前，入队的命令可能会出错，举个例子：命令可能会产生语法错误（参数数量错误，参数名错误等），或者其他更严重的错误，比如内存不足（如果服务器使用maxmemory 设置了最大内存限制的话）。 B、事务在执行 EXEC 之前，举个例子：事务中的命令可能处理了错误类型的键，比如将列表命令用在了字符串键上面等。 对于发生在 EXEC 执行之前的错误，客户端以前的做法是检查命令入队所得的返回值：如果命令入队时返回QUEUED ，那么入队成功；否则，就是入队失败。如果有命令在入队时失败，那么大部分客户端都会停止并取消这个事务。 从 Redis 2.6.5 开始，服务器会对命令入队失败的情况进行记录，并在客户端调用 EXEC 命令时，拒绝执行并自动放弃这个事务。 在 Redis 2.6.5 以前， Redis 只执行事务中那些入队成功的命令，而忽略那些入队失败的命令。而新的处理方式则使得在管道技术中包含事务变得简单，因为发送事务和读取事务的回复都只需要和服务器进行一次通讯即可。 至于那些在 EXEC 命令执行之后所产生的错误，并没有对它们进行特别处理： 即使事务中有某个/某些命令在执行时产生了错误， 事务中的其他命令仍然会继续执行。 五、例子演示 <?php $redis = new \Redis(); $redis->connect('127.0.0.1',6379); $result = array(); // 开启事务 $redis->multi(); // 添加指令到队列 $redis->set('book-name','Thinking in PHP!'); $redis->sAdd('tags','PHP','Programming','Thinking'); $bookname = $redis->get('book-name'); $tags = $redis->sMembers('tags'); // 执行事务 $redis->exec(); // 显示结果 echo '书名：'.$bookname.' 标签：'.$tags; ?> 结果：
答案来源于网络
回答
相信对于很多Java开发来说，在刚刚接触Java语言的时候，就听说过Java是一门跨平台的语言，Java是平台无关性的，这也是Java语言可以迅速崛起并风光无限的一个重要原因。那么，到底什么是平台无关性？Java又是如何实现平台无关性的呢？本文就来简单介绍一下。
什么是平台无关性
平台无关性就是一种语言在计算机上的运行不受平台的约束，一次编译，到处执行（Write Once ,Run Anywhere）。
也就是说，用Java创建的可执行二进制程序，能够不加改变的运行于多个平台。
平台无关性好处
作为一门平台无关性语言，无论是在自身发展，还是对开发者的友好度上都是很突出的。
因为其平台无关性，所以Java程序可以运行在各种各样的设备上，尤其是一些嵌入式设备，如打印机、扫描仪、传真机等。随着5G时代的来临，也会有更多的终端接入网络，相信平台无关性的Java也能做出一些贡献。
对于Java开发者来说，Java减少了开发和部署到多个平台的成本和时间。真正的做到一次编译，到处运行。
平台无关性的实现
对于Java的平台无关性的支持，就像对安全性和网络移动性的支持一样，是分布在整个Java体系结构中的。其中扮演者重要的角色的有Java语言规范、Class文件、Java虚拟机（JVM）等。
编译原理基础
讲到Java语言规范、Class文件、Java虚拟机就不得不提Java到底是是如何运行起来的。
我们在Java代码的编译与反编译那些事儿中介绍过，在计算机世界中，计算机只认识0和1，所以，真正被计算机执行的其实是由0和1组成的二进制文件。
但是，我们日常开发使用的C、C++、Java、Python等都属于高级语言，而非二进制语言。所以，想要让计算机认识我们写出来的Java代码，那就需要把他"翻译"成由0和1组成的二进制文件。这个过程就叫做编译。负责这一过程的处理的工具叫做编译器。
在深入分析Java的编译原理中我们介绍过，在Java平台中，想要把Java文件，编译成二进制文件，需要经过两步编译，前端编译和后端编译：
前端编译主要指与源语言有关但与目标机无关的部分。Java中，我们所熟知的javac的编译就是前端编译。除了这种以外，我们使用的很多IDE，如eclipse，idea等，都内置了前端编译器。主要功能就是把.java代码转换成.class代码。
这里提到的.class代码，其实就是Class文件。
后端编译主要是将中间代码再翻译成机器语言。Java中，这一步骤就是Java虚拟机来执行的。
所以，我们说的，Java的平台无关性实现主要作用于以上阶段。如下图所示：
我们从后往前介绍一下这三位主演：Java虚拟机、Class文件、Java语言规范
Java虚拟机
所谓平台无关性，就是说要能够做到可以在多个平台上都能无缝对接。但是，对于不同的平台，硬件和操作系统肯定都是不一样的。
对于不同的硬件和操作系统，最主要的区别就是指令不同。比如同样执行a+b，A操作系统对应的二进制指令可能是10001000，而B操作系统对应的指令可能是11101110。那么，想要做到跨平台，最重要的就是可以根据对应的硬件和操作系统生成对应的二进制指令。
而这一工作，主要由我们的Java虚拟机完成。虽然Java语言是平台无关的，但是JVM确实平台有关的，不同的操作系统上面要安装对应的JVM。
上图是Oracle官网下载JDK的指引，不同的操作系统需要下载对应的Java虚拟机。
有了Java虚拟机，想要执行a+b操作，A操作系统上面的虚拟机就会把指令翻译成10001000，B操作系统上面的虚拟机就会把指令翻译成11101110。
ps：图中的Class文件中内容为mock内容
所以，Java之所以可以做到跨平台，是因为Java虚拟机充当了桥梁。他扮演了运行时Java程序与其下的硬件和操作系统之间的缓冲角色。
字节码
各种不同的平台的虚拟机都使用统一的程序存储格式——字节码（ByteCode）是构成平台无关性的另一个基石。Java虚拟机只与由字节码组成的Class文件进行交互。
我们说Java语言可以Write Once ,Run Anywhere。这里的Write其实指的就是生成Class文件的过程。
因为Java Class文件可以在任何平台创建，也可以被任何平台的Java虚拟机装载并执行，所以才有了Java的平台无关性。
Java语言规范
已经有了统一的Class文件，以及可以在不同平台上将Class文件翻译成对应的二进制文件的Java虚拟机，Java就可以彻底实现跨平台了吗？
其实并不是的，Java语言在跨平台方面也是做了一些努力的，这些努力被定义在Java语言规范中。
比如，Java中基本数据类型的值域和行为都是由其自己定义的。而C/C++中，基本数据类型是由它的占位宽度决定的，占位宽度则是由所在平台决定的。所以，在不同的平台中，对于同一个C++程序的编译结果会出现不同的行为。
举一个简单的例子，对于int类型，在Java中，int占4个字节，这是固定的。
但是在C++中却不是固定的了。在16位计算机上，int类型的长度可能为两字节；在32位计算机上，可能为4字节；当64位计算机流行起来后，int类型的长度可能会达到8字节。（这里说的都是可能哦！）
通过保证基本数据类型在所有平台的一致性，Java语言为平台无关性提供强了有力的支持。
小结
对于Java的平台无关性的支持是分布在整个Java体系结构中的。其中扮演着重要角色的有Java语言规范、Class文件、Java虚拟机等。
Java语言规范
通过规定Java语言中基本数据类型的取值范围和行为 Class文件
所有Java文件要编译成统一的Class文件 Java虚拟机
通过Java虚拟机将Class文件转成对应平台的二进制文件等
Java的平台无关性是建立在Java虚拟机的平台有关性基础之上的，是因为Java虚拟机屏蔽了底层操作系统和硬件的差异。
语言无关性
其实，Java的无关性不仅仅体现在平台无关性上面，向外扩展一下，Java还具有语言无关性。
前面我们提到过。JVM其实并不是和Java文件进行交互的，而是和Class文件，也就是说，其实JVM运行的时候，并不依赖于Java语言。
时至今日，商业机构和开源机构已经在Java语言之外发展出一大批可以在JVM上运行的语言了，如Groovy、Scala、Jython等。之所以可以支持，就是因为这些语言也可以被编译成字节码（Class文件）。而虚拟机并不关心字节码是有哪种语言编译而来的。详见牛逼了，教你用九种语言在JVM上输出HelloWorld
参考资料
《深入理解Java虚拟机（第二版）》 《深入Java虚拟机》 《Java语言规范——基于Java SE 8》 《Java虚拟机规范第8版》
回答
Kotlin的简介
Kotlin是由JetBrains公司（IDEA开发者）所开发的编程语言，其名称来自于开发团队附近的科特林岛。
多平台开发 JVM ：Android; Server-Side Javascript:前端 Native(beta) :开发原生应用 windows、macos、linux
Swift与Kotlin非常像 http://nilhcem.com/swift-is-like-kotlin/
kotlin发展历程 image.png
java发展历程 image.png
JVM语言的原理 image.png JVM规范与java规范是相互独立的 只要生成的编译文件匹配JVM字节码规范，任何语言都可以由JVM编译运行. Kotlin也是一种JVM语言，完全兼容java，可以与java相互调用；Kotlin语言的设计受到Java、C#、JavaScript、Scala、Groovy等语言的启发
kotlin的特性 下面不会罗列kotlin中具体的语法，会介绍我认为比较重要的特性，以及特性背后的东西。
类型推断 空类型设计 函数式编程 类型推断 image.png
类型推断是指编程语言中在编译期自动推导出值的数据类型。推断类型的能力让很多编程任务变得容易，让程序员可以忽略类型标注的同时仍然允许类型检查。 在开发环境中，我们往往写出表达式，然后可以用快捷键来生成变量声明，往往都是很准的，这说明了编译器其实是可以很准确的推断出来类型的。编程语言所具备的类型推断能力可以把类型声明的任务由开发者转到了编译器.
java中声明变量的方式是类型写在最前面，后面跟着变量名，这就迫使开发者在声明变量时就要先思考变量的类型要定义成什么，而在一些情况下比如使用集合、泛型类型的变量，定义类型就会变得比较繁琐。
Kotlin中声明变量，类型可以省略，或者放到变量名后面，这可以降低类型的权重，从必选变为可选，降低开发者思维负担。java10中也引入了类型推断。
Javascript中声明变量也是用关键字var,但是还是有本质区别的，Kotlin中的类型推断并不是变成动态类型、弱类型，类型仍然是在编译期就已经决定了的，Kotlin仍然是静态类型、强类型的编程语言。javascript由于是弱类型语言，同一个变量可以不经过强制类型转换就被赋不同数据类型的值，
编程语言的一个趋势就是抽象程度越来越高，编译器做更多的事情。
空类型设计 空类型的由来 image.png 托尼·霍尔（Tony Hoare），图灵奖得主 托尼·霍尔是ALGOL语言的设计者，该语言在编程语言发展历史上非常重要,对其他编程语言产生重大影响，大多数近代编程语言(包括C语言)皆使用类似ALGOL的语法。他在一次大会上讨论了null应用的设计：
“我把 null 引用称为自己的十亿美元错误。它的发明是在1965 年，那时我用一个面向对象语言( ALGOL W )设计了第一个全面的引用类型系统。我加入了null引用设计，仅仅是因为实现起来非常容易。它导致了数不清的错误、漏洞和系统崩溃，可能在之后 40 年中造成了十亿美元的损失。”
null引用存在的问题 以java为例，看null引用的设计到底存在哪些问题
空指针问题NPE 编译时不能对空指针做出检查，运行时访问null对象就会出现错误，这个就是工程中常见的空指针异常。
null本身没有语义，会存在歧义 值未被初始化 值不存在 也许表示一种状态
逻辑上有漏洞 Java中，null可以赋值给任何引用，比如赋值给String类型变量，String a = null，但是null并不是String类型： a instanceof String 返回的是false，这个其实是有些矛盾的。所以当持有一个String类型的变量，就存在两种情况，null或者真正的String.
解决NPE的方式 防御式代码 在访问对象前判空，但会有冗余代码；会规避问题，而隐藏真正的问题
抛出异常给调用方处理 方法中传参传入的空值、无效值，抛出受检查异常给上层调用方
增加注解 Android中可以增加@NonNull注解，编译时做额外检查
空状态对象设计模式 空状态对象是一个实现接口但是不做任何业务逻辑的对象，可以取代判空检查；这样的空状态对象也可以在数据不可用的时候提供默认的行为
java8 Optional类 java8中引入了Optional类，来解决广泛存在的null引用问题.官方javadoc文档介绍
A container object which may or may not contain a non-null value. If a value is present, isPresent() will return true and get() will return the value.
Additional methods that depend on the presence or absence of a contained value are provided, such as orElse() (return a default value if value not present) and ifPresent() (execute a block of code if the value is present).
来看一下是如何实现的。 举一个访问对象读取熟悉的例子 java 8 之前 : image.png java 8: image.png
总结： 1.用Optional还是会比较繁琐，这个也说明了设计一个替代null的方案还是比较难的。
optional的耗时大约是普通判空的数十倍，主要是涉及泛型、使用时多创键了一个对象的创建；数据比较大时，会造成性能损失。 java8 引入Optional的意义在于提示调用者，用特殊类型包装的变量可能为空，在使用取出时需要判断 Kotlin的空类型设计 Kotlin中引入了可空类型和不可空类型的区分，可以区分一个引用可以容纳null,还是不能容纳null。
String vs String? String 类型表示变量不能为空，String?则表示变量可以为空 String?含义是String or null.这两种是不同的类型. 比如：
var a:String = “abc” //ok var a:String = null //不允许 var b :String? = null //ok a=b // 不允许 String?类型的值不能给String类型的值赋值 这样就将类型分成了可空类型和不可能类型,每一个类型都有这样的处理;Kotlin中访问非空类型变量永远不会出现空指针异常。 同样上面的例子，采用Kotlin去写，就会简洁很多 image.png
编程范式-函数式编程 编程范式是什么？ 编程范式是程序员看待程序和写程序的观点
主要的类型 非结构化编程 结构化编程 面向对象编程 命令式编程 函数式编程
这些类型并不是彼此互斥的，而是按照不同的维度做的划分，一种编程语言可能都支持多个编程范式
非结构化编程 第一代的高级语言往往是非结构化编程 比如 BASIC语言 每一行的代码前面都有一个数字作为行号,通常使用GOTO的跳跃指令来实现判断和循环. 看一下下面这段代码是做什么的： image.png
实际上做的是：程序在屏幕上显示数字 1 到 10 及其对应的平方 采用这种方式写程序，大量的使用goto实现逻辑的跳转，代码一长，可读性和维护性就比较差了，形成“面条式代码”
结构化编程 采用顺序、分支、循环结构来表达，禁用或者少用GOTO; 并用子程序来组织代码，采用自顶向下的方式来写程序 代表语言是C语言 实现同样的逻辑： image.png 可见采用结构化编程，代码的逻辑会更清晰。
面向对象编程 思想： 将计算机程序视为一组对象的集合，而每个对象都可以接收其他对象发过来的消息，并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递。 特性： 封装性、继承性、多态性。
命令式编程 把计算机程序视为一系列的命令集合 主要思想是关注计算机执行的步骤，即一步一步告诉计算机先做什么再做什么。 “先做这，再做那”，强调“怎么做”
实现： 用变量来储存数据，用语句来执行指令，改变变量状态。 基本所有的常见的编程语言都具有此范式
函数式编程 声明式语法，描述要什么，而不是怎么做 类似于SQL语句 语言： kotlin swift python javascript scala
函数是第一等公民 可以赋值给变量，可作为参数传入另一个函数，也可作为函数的返回值
纯函数 y=f(x) 只要输入相同，返回值不变 没有副作用：不修改函数的外部状态
举个栗子 公司部门要进行outing，去哪里是个问题，要考虑多个因素，比如花费、距离、天数等等，有多个备选地点进行选择。 定义一个数据类： image.png
要进行筛选了，分别用sql,kotlin,java来实现 找出花费低于2000元的outing地点信息
SQL image.png
Kotlin image.png
java 7 image.png 可见kotin的写法还是比较接近于sql的思想的，声明式的写法，而不管具体如何实现；其中的：place->place.money<2000 就是函数，可以作为参数传递给fliter这个高阶函数；而且这个函数没有副作用，不改变外部状态。
再来一个复杂一点的： 找出花费低于5000元，时间不多于4天，按照距离排序的outing地点名称
SQL image.png
Kotlin: image.png
java 7 image.png
由此可见用kotlin的函数式写法，会更简洁，逻辑也更清晰，这段代码的目标一目了然，这种清晰在于实现了业务逻辑与控制逻辑的分离，业务逻辑就是由函数实现的，比如place->place.money<500,而控制逻辑是由filter,sorterBy等高阶函数实现的。
而java的传统写法是基于对数据的操作，避免不了遍历的操作，业务逻辑与控制逻辑交织在了一起，这段代码的目的就不是那么容易清晰看到的了。
总结 kotlin是实用的现代编程语言，吸收了众多编程语言的优点，支持类型推断、空类型安全、函数式编程、DSL等特性，非常值得学习和使用。
回答
转自：思否
话说当下技术圈的朋友，一起聚个会聊个天，如果不会点大数据的知识，感觉都融入不了圈子，为了以后聚会时让你有聊有料，接下来就跟随我的讲述，一起与大数据混个脸熟吧，不过在“撩”大数据之前，还是先揭秘一下研发这些年我们都经历了啥？
缘起：应用系统架构的从 0 到 1
揭秘：研发这些年我们都经历了啥？ 大道至简。生活在技术圈里，大家静下来想想，无论一个应用系统多庞大、多复杂，无非也就是由一个漂亮的网站门面 + 一个丑陋的管理模块 + 一个闷头干活的定时任务三大板块组成。
我们负责的应用系统当然也不例外，起初设计的时候三大模块绑在一起（All in one），线上跑一个 Tomcat 轻松就搞定，可谓是像极了一个大泥球。
衍化至繁。由于网站模块、管理平台、定时任务三大模块绑定在一起，开发协作会比较麻烦，时不时会有代码合并冲突出现；线上应用升级时，也会导致其它模块暂时不能使用，例如如果修改了一个定时任务的配置，可能会导致网站、管理平台的服务暂时不能用。面对诸多的不便，就不得不对 All in one 的大泥球系统进行拆解。
随着产品需求的快速迭代，网站 WEB 功能逐渐增多，我们起初设计时雄心勃勃（All in one 的单体架构），以为直接按模块设计叠加实现就好了，谁成想系统越发显得臃肿（想想也是走弯路啦！）。所以不得不改变实现思路，让模块服务下沉，分布式思想若现——让原来网站 WEB 一个系统做的事，变成由子系统分担去完成。
应用架构的演变，服务模块化拆分，随之而来的就是业务日志、业务数据散落在各处。随着业务的推广，业务量逐日增多，沉淀的数据日益庞大，在业务层面、运维层面上的很多问题，逐渐开始暴露。
在业务层面上，面对监管机构的监管，整合提取散落在各地的海量数据稍显困难；海量数据散落，想做个统计分析报表也非常不易。在运维层面上，由于缺少统一的日志归档，想基于日志做快速分析也比较困难；如果想从散落在各模块的日志中，进行调用链路的分析也是相当费劲。
面对上述问题，此时一个硕大的红色问号出现在我们面前，到底该如何解决？
面对结构化的业务数据，不妨先考虑采用国内比较成熟的开源数据库中间件 Sharding-JDBC、MyCat 看是否能够解决业务问题；面对日志数据，可以考虑采用 ELK 等开源组件。如果以上方案或者能尝试的方式都无法帮我们解决，尝试搬出大数据吧。
那到底什么时候需要用大数据呢？大数据到底能帮我们解决什么问题呢？注意，前方高能预警，门外汉“撩”大数据的正确姿势即将开启。
邂逅：一起撬开大数据之门
槽点：门外汉“撩”大数据的正确姿势 与大数据的邂逅，源于两个头痛的问题。第一个问题是海量数据的存储，如何解决？第二个问题是海量数据的计算，如何解决？
面对这两个头痛的问题，不得不提及谷歌的“三驾马车”（分布式文件系统 GFS、MapReduce 和 BigTable），谷歌“三驾马车”的出现，奠定了大数据发展的基石，毫不夸张地说，没有谷歌的“三驾马车”就没有大数据，所以接下来很有必要逐一认识。
大家都知道，谷歌搜索引擎每天要抓取数以亿计的网页，那么抓取的海量数据该怎么存储？
谷歌痛则思变，重磅推出分布式文件系统 GFS。面对谷歌推出的分布式文件系统 GFS 架构，如 PPT 中示意，参与角色着实很简单，主要分为 GFS Master（主服务器）、GFS Chunkserver（块存储服务器）、GFS Client（客户端）。
不过对于首次接触这个的你，可能还是一脸懵 ，大家心莫慌，接下来容我抽象一下。
GFS Master 我们姑且认为是古代的皇上，统筹全局，运筹帷幄。主要负责掌控管理所有文件系统的元数据，包括文件和块的命名空间、从文件到块的映射、每个块所在的节点位置。说白了，就是要维护哪个文件存在哪些文件服务器上的元数据信息，并且定期通过心跳机制与每一个 GFS Chunkserver 通信，向其发送指令并收集其状态。
GFS Chunkserver 可以认为是宰相，因为宰相肚子里面能撑船，能够海纳百川。主要提供数据块的存储服务，以文件的形式存储于 Chunkserver 上。
GFS Client 可以认为是使者，对外提供一套类似传统文件系统的 API 接口，对内主要通过与皇帝通信来获取元数据，然后直接和宰相交互，来进行所有的数据操作。
为了让大家对 GFS 背后的读写流程有更多认识，献上两首歌谣。
到这里，大家应该对分布式文件系统 GFS 不再陌生，以后在饭桌上讨论该话题时，也能与朋友交涉两嗓子啦。
不过这还只是了解了海量数据怎么存储，那如何从海量数据存储中，快速计算出我们想要的结果呢？
面对海量数据的计算，谷歌再次创新，推出了 MapReduce 编程模型及实现。
MapReduce 主要是采取分而治之的思想，通俗地讲，主要是将一个大规模的问题，分成多个小规模的问题，把多个小规模问题解决，然后再合并小规模问题的结果，就能够解决大规模的问题。
也有人说 MapReduce 就像光头强的锯子和锤子，世界上的万事万物都可以先锯几下，然后再锤几下，就能轻松搞定，至于锯子怎么锯，锤子怎么锤，那就是个人的手艺了。
这么解释不免显得枯燥乏味，我们不妨换种方式，走进生活真实感受 MapReduce。
斗地主估计大家都玩过，每次开玩之前，都会统计一副牌的张数到底够不够，最快的步骤莫过于：分几份给大家一起数，最后大家把数累加，算总张数，接着就可以愉快地玩耍啦... ...这不就是分而治之的思想吗？！不得不说架构思想来源于人们的生活！
再举个不太贴切的例子来感受MapReduce 背后的运转流程，估计很多人掰过玉米，每当玉米成熟的季节，地主家就开始忙碌起来。
首先地主将一亩地的玉米分给处于空闲状态的长工来处理；专门负责掰玉米的长工领取任务，开始掰玉米操作（Map 操作），并把掰好的玉米放到在麻袋里（缓冲区），麻袋装不下时，会被装到木桶中（溢写），木桶被划分为蓝色的生玉米木桶、红色的熟玉米木桶（分区），地主通知二当家来“收”属于自己的那部分玉米，二当家收到地主的通知后，就到相应的长工那儿“拿回”属于自己的那部分玉米（Fetch 操作），二当家对收取的玉米进行处理（Reduce 操作），并把处理后的结果放入粮仓。
一个不太贴切的生活体验 + 一张画得不太对的丑图 = 苦涩难懂的技术，也不知道这样解释，你了解了多少？不过如果以后再谈大数据，知道 MapReduce 这个词的存在，那这次的分享就算成功（哈哈）。
MapReduce 解决了海量数据的计算问题，可谓是力作，但谷歌新的业务需求一直在不断出现。众所周知，谷歌要存储爬取的海量网页，由于网页会不断更新，所以要不断地针对同一个 URL 进行爬取，那么就需要能够存储一个 URL 不同时期的多个版本的网页内容。谷歌面临很多诸如此类的业务场景，面对此类头痛的需求，该怎么办？
谷歌重磅打造了一款类似以“URL + contents + time stamp”为 key，以“html 网页内容”为值的存储系统，于是就有了 BigTable 这个键值系统的存在（本文不展开详述）。
至此，两个头痛的问题就算解决了。面对海量数据存储难题，谷歌推出了分布式文件系统 GFS、结构化存储系统 BigTable；面对海量数据的计算难题，谷歌推出了 MapReduce。
不过静下来想想，GFS 也好、MapReduce 也罢，无非都是秉承了大道至简、一人掌权、其它人办事、人多力量大的设计理念。另外画龙画虎难画骨，建议闲暇之余也多些思考：为什么架构要这么设计？架构设计的目标到底是如何体现的？
基于谷歌的“三驾马车”，出现了一大堆开源的轮子，不得不说谷歌的“三驾马车”开启了大数据时代。了解了谷歌的“三驾马车”的设计理念后，再去看这些开源的轮子，应该会比较好上手。
好了，门外汉“撩”大数据就聊到这儿吧，希望通过上文的分享能够了解几个关键词：大道至简、衍化至繁、谷歌三驾马车（GFS、MapReduce、BigTable）、痛则思变、开源轮子。
白头：番外篇
扯淡：不妨换一种态度 本文至此也即将接近尾声，最后是番外篇~
首先，借用日本剑道学习心诀“守、破、离”，希望我们一起做一个精进的人。
最后，在有限的时间内要多学习，不要停下学习的脚步，在了解和使用已经有的成熟技术之时，更要多思考，开创适合自己工作场景的解决方案。
文章来源：宜信技术学院 & 宜信支付结算团队技术分享第6期-宜信支付结算部支付研发团队高级工程师许赛赛《揭秘：“撩”大数据的正确姿势》 分享者：宜信支付结算部支付研发团队高级工程师许赛赛
原文首发于公号-野指针
回答
前言
这期我想写很久了，但是因为时间的原因一直拖到了现在，我以为一两天就写完了，结果从构思到整理资料，再到写出来用了差不多一周的时间吧。
你们也知道丙丙一直都是创作鬼才来的，所以我肯定不会一本正经的写，我想了好几个切入点，最后决定用一个完整的电商系统作为切入点，带着大家看看，我们需要学些啥，我甚至还收集配套视频和资料，暖男石锤啊，这期是呕心沥血之作，不要白嫖了。
正文
在写这个文章之前，我花了点时间，自己臆想了一个电商系统，基本上算是麻雀虽小五脏俱全，我今天就用它开刀，一步步剖析，我会讲一下我们可能会接触的技术栈可能不全，但是够用，最后给个学习路线。
Tip：请多欣赏一会，每个点看一下，看看什么地方是你接触过的，什么技术栈是你不太熟悉的，我觉得还算是比较全的，有什么建议也可以留言给我。
不知道大家都看了一下没，现在我们就要庖丁解牛了，我从上到下依次分析。
前端
你可能会会好奇，你不是讲后端学习路线嘛，为啥还有前端的部分，我只能告诉你，傻瓜，肤浅。
我们可不能闭门造车，谁告诉你后端就不学点前端了？
前端现在很多也了解后端的技术栈的，你想我们去一个网站，最先接触的，最先看到的是啥？
没错就是前端，在大学你要是找不到专门的前端同学，去做系统肯定也要自己顶一下前端的，那我觉得最基本的技术栈得熟悉和了解吧，丙丙现在也是偶尔会开发一下我们的管理系统主要是VUE和React。
在这里我列举了我目前觉得比较简单和我们后端可以了解的技术栈，都是比较基础的。
作为一名后端了解部分前端知识还是很有必要的，在以后开发的时候，公司有前端那能帮助你前后端联调更顺畅，如果没前端你自己也能顶一下简单的页面。
HTML、CSS、JS、Ajax我觉得是必须掌握的点，看着简单其实深究或者去操作的话还是有很多东西的，其他作为扩展有兴趣可以了解，反正入门简单，只是精通很难很难。
在这一层不光有这些还有Http协议和Servlet，request、response、cookie、session这些也会伴随你整个技术生涯，理解他们对后面的你肯定有不少好处。
Tip：我这里最后删除了JSP相关的技术，我个人觉得没必要学了，很多公司除了老项目之外，新项目都不会使用那些技术了。
前端在我看来比后端难，技术迭代比较快，知识好像也没特定的体系，所以面试大厂的前端很多朋友都说难，不是技术多难，而是知识多且复杂，找不到一个完整的体系，相比之下后端明朗很多，我后面就开始讲后端了。
网关层：
互联网发展到现在，涌现了很多互联网公司，技术更新迭代了很多个版本，从早期的单机时代，到现在超大规模的互联网时代，几亿人参与的春运，几千亿成交规模的双十一，无数互联网前辈的造就了现在互联网的辉煌。
微服务，分布式，负载均衡等我们经常提到的这些名词都是这些技术在场景背后支撑。
单机顶不住，我们就多找点服务器，但是怎么将流量均匀的打到这些服务器上呢？
负载均衡，LVS
我们机器都是IP访问的，那怎么通过我们申请的域名去请求到服务器呢？
DNS
大家刷的抖音，B站，快手等等视频服务商，是怎么保证同时为全国的用户提供快速的体验？
CDN
我们这么多系统和服务，还有这么多中间件的调度怎么去管理调度等等？
zk
这么多的服务器，怎么对外统一访问呢，就可能需要知道反向代理的服务器。
Nginx
这一层做了反向负载、服务路由、服务治理、流量管理、安全隔离、服务容错等等都做了，大家公司的内外网隔离也是这一层做的。
我之前还接触过一些比较有意思的项目，所有对外的接口都是加密的，几十个服务会经过网关解密，找到真的路由再去请求。
这一层的知识点其实也不少，你往后面学会发现分布式事务，分布式锁，还有很多中间件都离不开zk这一层，我们继续往下看。
服务层：
这一层有点东西了，算是整个框架的核心，如果你跟我帅丙一样以后都是从事后端开发的话，我们基本上整个技术生涯，大部分时间都在跟这一层的技术栈打交道了，各种琳琅满目的中间件，计算机基础知识，Linux操作，算法数据结构，架构框架，研发工具等等。
我想在看这个文章的各位，计算机基础肯定都是学过的吧，如果大学的时候没好好学，我觉得还是有必要再看看的。
为什么我们网页能保证安全可靠的传输，你可能会了解到HTTP，TCP协议，什么三次握手，四次挥手。
还有进程、线程、协程，什么内存屏障，指令乱序，分支预测，CPU亲和性等等，在之后的编程生涯，如果你能掌握这些东西，会让你在遇到很多问题的时候瞬间get到点，而不是像个无头苍蝇一样乱撞（然而丙丙还做得不够）。
了解这些计算机知识后，你就需要接触编程语言了，大学的C语言基础会让你学什么语言入门都会快点，我选择了面向对象的JAVA，但是也不知道为啥现在还没对象。
JAVA的基础也一样重要，面向对象（包括类、对象、方法、继承、封装、抽象、 多态、消息解析等），常见API，数据结构，集合框架，设计模式（包括创建型、结构型、行为型），多线程和并发，I/O流，Stream，网络编程你都需要了解。
代码会写了，你就要开始学习一些能帮助你把系统变得更加规范的框架，SSM可以会让你的开发更加便捷，结构层次更加分明。
写代码的时候你会发现你大学用的Eclipse在公司看不到了，你跟大家一样去用了IDEA，第一天这是什么玩意，一周后，真香，但是这玩意收费有点贵，那免费的VSCode真的就是不错的选择了。
代码写的时候你会接触代码的仓库管理工具maven、Gradle，提交代码的时候会去写项目版本管理工具Git。
代码提交之后，发布之后你会发现很多东西需要自己去服务器亲自排查，那Linux的知识点就可以在里面灵活运用了，查看进程，查看文件，各种Vim操作等等。
系统的优化很多地方没优化的空间了，你可能会尝试从算法，或者优化数据结构去优化，你看到了HashMap的源码，想去了解红黑树，然后在算法网上看到了二叉树搜索树和各种常见的算法问题，刷多了，你也能总结出精华所在，什么贪心，分治，动态规划等。
这么多个服务，你发现HTTP请求已经开始有点不满足你的需求了，你想开发更便捷，像访问本地服务一样访问远程服务，所以我们去了解了Dubbo，Spring cloud。
了解Dubbo的过程中，你发现了RPC的精华所在，所以你去接触到了高性能的NIO框架，Netty。
代码写好了，服务也能通信了，但是你发现你的代码链路好长，都耦合在一起了，所以你接触了消息队列，这种异步的处理方式，真香。
他还可以帮你在突发流量的时候用队列做缓冲，但是你发现分布式的情况，事务就不好管理了，你就了解到了分布式事务，什么两段式，三段式，TCC，XA，阿里云的全局事务服务GTS等等。
分布式事务的时候你会想去了解RocketMQ，因为他自带了分布式事务的解决方案，大数据的场景你又看到了Kafka。
我上面提到过zk，像Dubbo、Kafka等中间件都是用它做注册中心的，所以很多技术栈最后都组成了一个知识体系，你先了解了体系中的每一员，你才能把它们联系起来。
服务的交互都从进程内通信变成了远程通信，所以性能必然会受到一些影响。
此外由于很多不确定性的因素，例如网络拥塞、Server 端服务器宕机、挖掘机铲断机房光纤等等，需要许多额外的功能和措施才能保证微服务流畅稳定的工作。
**Spring Cloud **中就有 Hystrix 熔断器、Ribbon客户端负载均衡器、Eureka注册中心等等都是用来解决这些问题的微服务组件。
你感觉学习得差不多了，你发现各大论坛博客出现了一些前沿技术，比如容器化，你可能就会去了解容器化的知识，像**Docker，Kubernetes（K8s）**等。
微服务之所以能够快速发展，很重要的一个原因就是：容器化技术的发展和容器管理系统的成熟。
这一层的东西呢其实远远不止这些的，我不过多赘述，写多了像个劝退师一样，但是大家也不用慌，大部分的技术都是慢慢接触了，工作中慢慢去了解，去深入的。
好啦我们继续沿着图往下看，那再往下是啥呢？
数据层：
数据库可能是整个系统中最值钱的部分了，在我码文字的前一天，刚好发生了微盟程序员删库跑路的操作，删库跑路其实是我们在网上最常用的笑话，没想到还是照进了现实。
这里也提一点点吧，36小时的故障，其实在互联网公司应该是个笑话了吧，权限控制没做好类似rm -rf 、fdisk、drop等等这样的高危命令是可以实时拦截掉的，备份，全量备份，增量备份，延迟备份，异地容灾全部都考虑一下应该也不至于这样，一家上市公司还是有点点不应该。
数据库基本的事务隔离级别，索引，SQL，主被同步，读写分离等都可能是你学的时候要了解到的。
上面我们提到了安全，不要把鸡蛋放一个篮子的道理大家应该都知道，那分库的意义就很明显了，然后你会发现时间久了表的数据大了，就会想到去接触分表，什么TDDL、Sharding-JDBC、DRDS这些插件都会接触到。
你发现流量大的时候，或者热点数据打到数据库还是有点顶不住，压力太大了，那非关系型数据库就进场了，Redis当然是首选，但是MongoDB、memcache也有各自的应用场景。
Redis使用后，真香，真快，但是你会开始担心最开始提到的安全问题，这玩意快是因为在内存中操作，那断点了数据丢了怎么办？你就开始阅读官方文档，了解RDB，AOF这些持久化机制，线上用的时候还会遇到缓存雪崩击穿、穿透等等问题。
单机不满足你就用了，他的集群模式，用了集群可能也担心集群的健康状态，所以就得去了解哨兵，他的主从同步，时间久了Key多了，就得了解内存淘汰机制……
他的大容量存储有问题，你可能需要去了解Pika….
其实远远没完，每个的点我都点到为止，但是其实要深究每个点都要学很久，我们接着往下看。
实时/离线/大数据
等你把几种关系型非关系型数据库的知识点，整理清楚后，你会发现数据还是大啊，而且数据的场景越来越多多样化了，那大数据的各种中间件你就得了解了。
你会发现很多场景，不需要实时的数据，比如你查你的支付宝去年的，上个月的账单，这些都是不会变化的数据，没必要实时，那你可能会接触像ODPS这样的中间件去做数据的离线分析。
然后你可能会接触Hadoop系列相关的东西，比如于Hadoop（HDFS）的一个数据仓库工具Hive，是建立在 Hadoop 文件系统之上的分布式面向列的数据库HBase 。
写多的场景，适合做一些简单查询，用他们又有点大材小用，那Cassandra就再合适不过了。
离线的数据分析没办法满足一些实时的常见，类似风控，那Flink你也得略知一二，他的窗口思想还是很有意思。
数据接触完了，计算引擎Spark你是不是也不能放过……
搜索引擎：
传统关系型数据库和NoSQL非关系型数据都没办法解决一些问题，比如我们在百度，淘宝搜索东西的时候，往往都是几个关键字在一起一起搜索东西的，在数据库除非把几次的结果做交集，不然很难去实现。
那全文检索引擎就诞生了，解决了搜索的问题，你得思考怎么把数据库的东西实时同步到ES中去，那你可能会思考到logstash去定时跑脚本同步，又或者去接触伪装成一台MySQL从服务的Canal，他会去订阅MySQL主服务的binlog，然后自己解析了去操作Es中的数据。
这些都搞定了，那可视化的后台查询又怎么解决呢？Kibana，他他是一个可视化的平台，甚至对Es集群的健康管理都做了可视化，很多公司的日志查询系统都是用它做的。
学习路线
看了这么久你是不是发现，帅丙只是一直在介绍每个层级的技术栈，并没说到具体的一个路线，那是因为我想让大家先有个认知或者说是扫盲吧，我一样用脑图的方式汇总一下吧，如果图片被平台二压了。
资料/学习网站
Tip：本来这一栏有很多我准备的资料的，但是都是外链，或者不合适的分享方式，博客的运营小姐姐提醒了我，所以大家去公众号回复【路线】好了。
絮叨
如果你想去一家不错的公司，但是目前的硬实力又不到，我觉得还是有必要去努力一下的，技术能力的高低能决定你走多远，平台的高低，能决定你的高度。
如果你通过努力成功进入到了心仪的公司，一定不要懈怠放松，职场成长和新技术学习一样，不进则退。
丙丙发现在工作中发现我身边的人真的就是实力越强的越努力，最高级的自律，享受孤独（周末的歪哥）。
总结
我提到的技术栈你想全部了解，我觉得初步了解可能几个月就够了，这里的了解仅限于你知道它，知道他是干嘛的，知道怎么去使用它，并不是说深入了解他的底层原理，了解他的常见问题，熟悉问题的解决方案等等。
你想做到后者，基本上只能靠时间上的日积月累，或者不断的去尝试积累经验，也没什么速成的东西，欲速则不达大家也是知道的。
技术这条路，说实话很枯燥，很辛苦，但是待遇也会高于其他一些基础岗位。
所实话我大学学这个就是为了兴趣，我从小对电子，对计算机都比较热爱，但是现在打磨得，现在就是为了钱吧，是不是很现实？若家境殷实，谁愿颠沛流离。
但是至少丙丙因为做软件，改变了家庭的窘境，自己日子也向小康一步步迈过去。
说做程序员改变了我和我家人的一生可能夸张了，但是我总有一种下班辈子会因为我选择走这条路而改变的错觉。
我是敖丙，一个在互联网苟且偷生的工具人。
创作不易，本期硬核，不想被白嫖，各位的「三连」就是丙丙创作的最大动力，我们下次见！
本文 GitHub https://github.com/JavaFamily 已经收录，有大厂面试完整考点，欢迎Star。
该回答来自：敖丙
回答
http://ajaxpatterns.org/Timeout文章里面提到的方式应该是比较好的方案了，主要是在客户端处理，当即将超时时，给用户一个提示，让用户处理，当最后客户端真的超时时，再给用户一次机会处理。超时后停止掉ajax轮询，把超时信息发送给服务端，invalidate session。如果要采用自动地方式，需要捕捉鼠标，键盘事件。 ######请求每个模块时，session储存下最后一次操作时间，ajax模式获取数据时，服务器端判断下是不是ajax请求，是的话，服务器端看下session最后一次操作时间，不满足要求就清空，退出处理。 不要依赖系统设置的session存活时间，这个不靠谱 ######
这位兄弟说的的确不失为一种做法。 不过我们这边的系统目前session超时只是依赖的web.xml里的配置的时间，不会放在程序里面写。因为必须做到随时能够修改时间。
我想寻找一种改动尽量小一点的，毕竟这是正式投入生产的系统，我的主管不会让我为了这么一个需求，在每个模块里面存时间。
这个问题换一种说法就是，既然说我点击每一个模块，tomcat都当做我是发起了一次请求，那么我如何做到ajax请求过来的时候，我不把它当做请求。可以有最简单的方法么。
开发语言是java，开发工具eclipse/tomcat
@cgf986916 ######回复
@cgf986916 : 恩，我试试，非常感谢######单入口的话，更好弄了，入口处添加新session直接保存下最后操作时间，这个规则内做ajax请求判断，其他弄个包吧，引入下做个判断，或者做个拦截器也行，你自己看下那个符合你需求就行了。######
大哥，你不会自己实现session啊。就是tomcat 里有个Set<userId> ajax不更新不完了。弄个拦截器。你也可以采用类似360的token机制。原理一样。
再一个方案是你弄个fiter。然后存用户最后时间，不合适的logout。哎目测你新手
######恩，其实session这东西本身我就没弄太清楚。受教了######可以写一个全局的filter，在filter里存储session的最后一次操作时间啊，不必在每个模块里都写######我这边的要求是尽量不要有大的改动，因为访问量很大，如果加一个过滤器，会拦截每一次请求，又增添了系统的压力。 我听说有一种做法是直接在页面层套一个iframe还是什么的(只是听说)，我现在必须是既完成任务，又要改动最小。######
如果要求不是特别高的话，就在cookie里面加入时间戳，如果是ajax的话，时间戳就不加进去，这样也可用做判断。 ######这是最好的.######
写一个filter 判断request的header是不是AJAX请求（X-Requested-With）， ######当是AJAX请求的时候，不去确认登录与否######但是怎么才能让session不更新最后访问时间呢？######既然每隔两分钟就要扫表，干脆在后台做成定时任务好了，完全不需要前台的ajax来处理。管理员登录就开始这个Job，登出后就撤销。######回复
@liuxin : 非常感谢######回复
@龙王巴哈姆特 : 肯定不会啊，服务器端程序，并不需要登录或者请求的######扫完表以后要去更新页面导航上的一个数字，就跟QQ消息条数一样的。job做不到吧。 顺便问下，job扫表，容器会不会认为这也算一个操作行为，并认为这个session用户是活跃的？ 本人初学，望多指点######找到解决方案了，你用一个JSP来实现这个扫表的功能，在JSP的开头加上<%@ page session="false" %>，这样就把session功能关闭了，不管你请求多少次，都不影响现有的用户。亲测可行。######
@antipro
这个头的作用是1.该JSP无法直接访问内置session变量 2.不会自动创建session。我试过ajax 2分钟扫一次，设置session超时是3分钟。我等了5分钟后，session仍然没有过期。这个头并不能阻止ajax在请求的时候自动记录session最后更新时间。
并且还有另外一个问题，就是我这里的ajax，是跟用户名，修改密码，退出一起的如下图：
代码结构大致是一个ul，li结构
<ul>
<li>用户名XXX</li>
<li>风险交易XXX</li>
<li>修改密码</li>
<li>退出</li>
</ul>
，我把代码都放在一个JSP里面，然后include去了“风险交易”那个li里面，并加上了头<%@ page session="false" %>结果我发现整个页面都不能使用session变量了。导致我的用户名也显示不出来了。
昨天说的最多的加一个Filter也被我的主管无情的否决掉了。不管这个问题最后解决没，还是希望朋友们多交流，能让我多多学习下。
session超时的一篇文章：
http://zmx.iteye.com/blog/1846181
######回复
@龙王巴哈姆特 : 你用的是include指令包含的子页面？这样恐怕不行。######回复
@antipro : 我测试的时候，确实是只让那个jsp页面返回18，丢在我那个li里面，我试过了不行。并且外层页面也不能使用session变量了。跟他同级的用户名就是取的session VO里的数据也失效了。这种定时扫表，并且之后要更新页面数字的，除了用ajax还有更好的选择吗？######你怎么把整个页面都用来实现你的功能了，我设想的JSP只要返回一个18就可以了，其他内容都还是用原来的功能啊。######我不知道你是怎么测试的，但是我亲自测试了是正常的。至于不能用session的问题，禁止了session当然不能再用了，难道就没有其他的方法访问你要的数据了吗？要灵活处理啊。
回答
可以不开放十分钟后自动解封，必须要用户手动解封，这样就有点掌握主动权的意思了。
虽然最终还是跪了，但是可以改变攻击者一个指令就可以连续攻击几天的问题，两个IP就可以把攻击者折腾得不知道攻击哪边好，让攻击者把有限的流量，丢进无限的黑洞里。
当然，这是针对那种流量几十秒内慢慢递增的攻击方式，突发流量的话没有什么好办法。
-------------------------
回 3楼(ivmmff) 的帖子
是的，5G/s 流量黑洞是个天花板，可以称之为大黑洞。
5G/s 以下的流量可以称作小黑洞，给用户自定义。小黑洞的时间可以很短。
-------------------------
回 3楼(ivmmff) 的帖子
不过我已经想到基于现有API实现这个想法的可能了，我这几天抽时间实现一下。
-------------------------
起得早，实验了一下我的想法，实证完全可行，但是发现代码量不小，最重要的是关键的API没有开放，云盾流量实时统计这个API没有，所以还是暂时放弃用API完全实现的想法。既然代码无法实现，我说一下我的思路：利用阿里云VPC可以随时解绑和绑定IP的这个功能 + 云盾攻击流量统计 + 后端系统组成一套小黑洞系统，在5G/s流量之前，就自己黑洞掉，免得掉入150分钟黑洞的坑。需要注意的是，VPC的IP解绑跟BGP路由的黑洞的广播是不一样的，就算在VPC解绑了IP，攻击流量还是会到阿里云的数据中心，虽然没有进入云盾实例的流量统计，但流量还是到了阿里云的数据中心，多少有些不完美，这是两种完全不同的处理方式，阿里云有躺枪的可能，但还是减少了流量清洗的压力。从长远来看，是值得的。而黑洞就不一样了，流量在进入运营商骨干网后就被直接丢弃了，黑洞时间过长和不可控是一个遗憾。甘瓜苦蒂，天下物无全美。阿里云的安全团队是我见过最接地气的团队了，但资源这种东西，是要用钱堆出来的，所以大家也不要过分苛求。
-------------------------
回 17楼(无所谓已) 的帖子
您不能这么简单的算，虽然目前的价格我也认为很不合理，但您指出一个IP 14.4 是明显偏低了的。
首先，ESN需要一个庞大的检活集群，检测一个IP是否黑洞，因为据我所知是这么实现的。
其次，ESN需要有一个DNS系统，这个系统需要达到秒级切换的要求。
还有很多，虽然看起来只是简单的IP切换，但背后的技术实现也不简单。
-------------------------
刚才听到云栖大会上，阿里云总监说的，即将调整黑洞阙值，我很欣慰。
-------------------------
回 21楼(安全百晓生) 的帖子
其实还可以开放黑洞和解封的API，只要没有超过防护流量，想什么时候黑就什么时候黑，那就更厉害了。黑洞一次成本大概有多少？BGP黑洞居然也有成本这个我真没想到，不过也可以给API调用方自己付费就行了。
-------------------------
回 24楼(lslqtz) 的帖子
这个阿里云也有API，我也想过，但这个基本没有什么用。
1、切换IP对服务体验有损失，黑洞了再重连，对于一些客户损失很大。
2、这是占阿里云的便宜，我也是后来才了解到的，运营商给阿里云的黑洞总数有限，阿里云可以随时在代码加判断，如果IP黑洞直接不给你换，辛辛苦苦写完代码，到头白忙一场。
3、安全网络就是这么干的，而且安全网络跟高防用的是同一套清洗系统，比你自己写一套切换系统然后用基础防御强多了。
-------------------------
回 25楼(lslqtz) 的帖子
价格不合理，换商家就是了，何必吊死在阿里云身上，阿里云也没有强买强卖嘛，而且DDoS防御是一个多维度的战场，远远不是多少防御多少流量能够一言以蔽之的。
回答
大多配置就是把不需要配置的做成xml配置, 为的就是增加代码 实际上和业务相关真正需要配置的, 可管理的, 都需要通过数据来做 要做到上面这点,需要大量的工作, 大多码农基本的sql都写不出, 根本做不到这点 所以我们看到大多软件动则几十个M以上, 实际上, 什么实际的功能都没有. "可配置", "可管理" 需要对业务非常了解才能做到, 这是最基本的. ######有些东西还是要用xml来配置的，比如浏览器用html来配置，嘿嘿。######凡是呢？###### 但是！但是！！！ 有一个最大的前提，谁是甲方，谁是乙方。如果你不迎合客户！导致你的东西没人要，这又要怎么办。 所以都是很矛盾的！要寻求平衡点，而不是简单的拒绝 ######事实上，做需求调查时开发人员也必须是全程参与的，否则就会出现矛盾了。###### 我草，你又开喷了，看你喷的兴奋，我也打算搞个 “喷下程序员30岁以后，3P/双飞的持久性问题”， ######邮箱：orionup@163.com######视具体项目而言，尽量减少配置。你这种过激的想法是不对滴。######osc现在能看的也就是一些推荐的博客了，到处都是喷。开源，java，ssh 什么都喷，现在连配置文件都喷，又不是喷气式飞机。还有就是博主，每次搞出一些文章“ 哈，喷下马克思的理论”，“喷喷计算机”。。。。 可不可以不要这么标题党。能不能就事论事。这样和x浪，x易里面的小编有什么区别
软件可配置是必须的, 这点无须质疑.
但是哪些功能或者需求是需要配置的,需要双方沟通 对于码农来说，很不喜欢搞配置，配置规则的制定和解析都需要额外的代码量； 但是对于产品来说，不可配置的产品意味着可重用性降低。 比方说，你给A客户成功开发了一个x86平台下的通信协议（比如tcpip） 然后B客户觉得很好，也要移植到他们的arm mips或者ppc平台下 如果不做配置工作，每次移植你不得不把代码中和处理器架构相关的代码全部改一遍（比如关于字节对齐 大小端 以及涉及到某些特殊指令的地方）。如果移植工作还是同一个人做还好说，如果换一个人来做，可以想象到各种问题各种拖延工期 如果一开始就做好配置工作，虽然给A客户开发时需要多一部分工作量，但是后续的维护和移植就变得很容易，软件的生命力也会更强 ######零零乱乱 看了下， 然后滚动条拉到顶部， 看看右侧“ 中山野鬼的其他问题” 然后， 呵呵，我是来看笑话的...######犀利！######
引用来自“SmallWarm”的答案
osc现在能看的也就是一些推荐的博客了，到处都是喷。开源，java，ssh 什么都喷，现在连配置文件都喷，又不是喷气式飞机。还有就是博主，每次搞出一些文章“ 哈，喷下马克思的理论”，“喷喷计算机”。。。。 可不可以不要这么标题党。能不能就事论事。这样和x浪，x易里面的小编有什么区别
是闲得蛋疼了 ######嘴巴选手
回答
PHP面试干货
1、进程和线程
进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。进程和线程的区别在于：
简而言之,一个程序至少有一个进程,一个进程至少有一个线程.
线程的划分尺度小于进程，使得多线程程序的并发性高。
另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。
2、apache默认使用进程管理还是线程管理？如何判断并设置最大连接数？
一个进程可以开多个线程 默认是进程管理 默认有一个主进程
Linux: ps -aux | grep httpd | more 一个子进程代表一个用户的连接
Conf/extra/httpd-mpm.conf 多路功能模块 http -l 查询当前apache处于什么模式下
3、单例模式
单例模式需求:只能实例化产生一个对象
如何实现:
私有化构造函数
禁止克隆对象
提供一个访问这个实例的公共的静态方法（通常为getInstance方法），从而返回唯一对象
需要一个保存类的静态属性
class demo {
private static $MyObject; //保存对象的静态属性
private function __construct(){ //私有化构造函数
}
private function __clone(){ //禁止克隆
}
public static function getInstance(){
if(! (self::$MyObject instanceof self)){
self::$MyObject = new self;
}
return self::$MyObject;
}
}
4、安装完Apache后，在http.conf中配置加载PHP文件以Apache模块的方式安装PHP，在文件http.conf中首先要用语句LoadModule php5_module "e:/php/php5apache2.dll"动态装载PHP模块，然后再用语句AddType application/x-httpd-php .php 使得Apache把所有扩展名为PHP的文件都作为PHP脚本处理
5、debug_backtrace()函数能返回脚本里的任意行中调用的函数的名称。该函数同时还经常被用在调试中，用来判断错误是如何发生的
function one($str1, $str2)
{
two("Glenn", "Quagmire");
}
function two($str1, $str2)
{
three("Cleveland", "Brown");
}
function three($str1, $str2)
{
print_r(debug_backtrace());
}
one("Peter", "Griffin");
Array
(
[0] => Array
(
[file] => D:\www\test\result.php
[line] => 9
[function] => three
[args] => Array
(
[0] => Cleveland
[1] => Brown
)
)
[1] => Array
(
[file] => D:\www\test\result.php
[line] => 5
[function] => two
[args] => Array
(
[0] => Glenn
[1] => Quagmire
)
)
[2] => Array
(
[file] => D:\www\test\result.php
[line] => 16
[function] => one
[args] => Array
(
[0] => Peter
[1] => Griffin
)
)
)
6、输出用户的IP地址，并且判断用户的IP地址是否在192.168.1.100 — 192.168.1.150之间
echo $ip=getenv('REMOTE_ADDR');
$ip=str_replace('.','',$ip);
if($ip<1921681150 && $ip>1921681100)
{
echo 'ip在192.168.1.100—–192.168.1.150之间';
}
else
{
echo 'ip不在192.168.1.100—–192.168.1.150之间';
}
7、请将2维数组按照name的长度进行重新排序，按照顺序将id赋值
$tarray = array(
array('id' => 0, 'name' => '123'),
array('id' => 0, 'name' => '1234'),
array('id' => 0, 'name' => '1235'),
array('id' => 0, 'name' => '12356'),
array('id' => 0, 'name' => '123abc')
);
foreach($tarray as $key=>$val)
{
$c[]=$val['name'];
}
function aa($a,$b)
{
if(strlen($a)==strlen($b)) return 0;
return strlen($a)>strlen($b)?-1:1;
}
usort($c,'aa');
$len=count($c);
for($i=0;$i<$len;$i++)
{
$t[$i]['id']=$i+1;
$t[$i]['name']=$c[$i];
}
print_r($t);
8、表单数据提交方式POST和GET的区别，URL地址传递的数据最大长度是多少？
POST方式提交数据用户不可见，是数据更安全，最大长度不受限制，而GET方式传值在URL地址可以看到，相对不安全，对大长度是2048字节。
9、SESSION和COOKIE的作用和区别，SESSION信息的存储方式，如何进行遍历
SESSION和COOKIE都能够使值在页面之间进行传递，SESSION存储在服务器端，数据更安全，COOKIE保存在客户端，用户使用手段可以进行修改，SESSION依赖于COOKIE进行传递的。Session遍历使用$_SESSION[]取值，cookie遍历使用$_COOKIE[]取值。
10、什么是数据库索引，主键索引，唯一索引的区别，索引的缺点是什么
索引用来快速地寻找那些具有特定值的记录。
主键索引和唯一索引的区别：主键是一种唯一性索引，但它必须指定为“PRIMARY KEY”,每个表只能有一个主键。唯一索引索引列的所有值都只能出现一次，即必须唯一。
索引的缺点：
1、创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加。
2、索引需要占用物理空间，除了数据表占数据空间之外，每一个索引还要占一定的物理空间，如果要建立聚簇索引，需要的空间就会更大。
3、当对表中的数据进行增加、删除、修改的时候，索引也要动态的维护，这样就降低了数据的维护速度。
11、数据库设计时，常遇到的性能瓶颈有哪些，常有的解决方案
瓶颈主要有：
1、磁盘搜索 优化方法是：将数据分布在多个磁盘上
2、磁盘读/写 优化方法是：从多个磁盘并行读写。
3、CPU周期 优化方法：扩充内存
4、内存带宽
12、include和require区别
include引入文件的时候，如果碰到错误，会给出提示，并继续运行下边的代码。
require引入文件的时候，如果碰到错误，会给出提示，并停止运行下边的代码。
13、文件上传时设计到点
和文件上传有关的php.ini配置选项（File Uploads）：
file_uploads=On/Off:文件是否允许上传
upload_max_filesize上传文件时，单个文件的最大大小
post_max_size:提交表单时，整个post表单的最大大小
max_file_uploads =20上传文件的个数
内存占用，脚本最大执行时间也间接影响到文件的上传
14、header常见状态
//200 正常状态
header('HTTP/1.1 200 OK');
// 301 永久重定向，记得在后面要加重定向地址 Location:$url
header('HTTP/1.1 301 Moved Permanently');
// 重定向，其实就是302 暂时重定向
header('Location: http://www.maiyoule.com/');
// 设置页面304 没有修改
header('HTTP/1.1 304 Not Modified');
// 显示登录框，
header('HTTP/1.1 401 Unauthorized');
header('WWW-Authenticate: Basic realm="登录信息"');
echo '显示的信息！';
// 403 禁止访问
header('HTTP/1.1 403 Forbidden');
// 404 错误
header('HTTP/1.1 404 Not Found');
// 500 服务器错误
header('HTTP/1.1 500 Internal Server Error');
// 3秒后重定向指定地址(也就是刷新到新页面与 <meta http-equiv="refresh" content="10;http://www.maiyoule.com/ /> 相同)
header('Refresh: 3; url=http://www.maiyoule.com/');
echo '10后跳转到http://www.maiyoule.com';
// 重写 X-Powered-By 值
header('X-Powered-By: PHP/5.3.0');
header('X-Powered-By: Brain/0.6b');
//设置上下文语言
header('Content-language: en');
// 设置页面最后修改时间（多用于防缓存）
$time = time() - 60; //建议使用filetime函数来设置页面缓存时间
header('Last-Modified: '.gmdate('D, d M Y H:i:s', $time).' GMT');
// 设置内容长度
header('Content-Length: 39344');
// 设置头文件类型，可以用于流文件或者文件下载
header('Content-Type: application/octet-stream');
header('Content-Disposition: attachment; filename="example.zip"');
header('Content-Transfer-Encoding: binary');
readfile('example.zip');//读取文件到客户端
//禁用页面缓存
header('Cache-Control: no-cache, no-store, max-age=0, must-revalidate');
header('Expires: Mon, 26 Jul 1997 05:00:00 GMT');
header('Pragma: no-cache');
//设置页面头信息
header('Content-Type: text/html; charset=iso-8859-1');
header('Content-Type: text/html; charset=utf-8');
header('Content-Type: text/plain');
header('Content-Type: image/jpeg');
header('Content-Type: application/zip');
header('Content-Type: application/pdf');
header('Content-Type: audio/mpeg');
header('Content-Type: application/x-shockwave-flash');
//.... 至于Content-Type 的值 可以去查查 w3c 的文档库，那里很丰富
15、ORM和ActiveRecord
ORM:object relation mapping,即对象关系映射，简单的说就是对象模型和关系模型的一种映射。为什么要有这么一个映射？很简单，因为现在的开发语言基本都是oop的，但是传统的数据库却是关系型的。为了可以靠贴近面向对象开发，我们想要像操作对象一样操作数据库。还可以隔离底层数据库层，我们不需要关心我们使用的是mysql还是其他的关系型数据库
ActiveRecord也属于ORM层，由Rails最早提出，遵循标准的ORM模型：表映射到记录，记录映射到对象，字段映射到对象属性。配合遵循的命名和配置惯例，能够很大程度的快速实现模型的操作，而且简洁易懂。
ActiveRecord的主要思想是：
1. 每一个数据库表对应创建一个类，类的每一个对象实例对应于数据库中表的一行记录；通常表的每个字段在类中都有相应的Field；
2. ActiveRecord同时负责把自己持久化，在ActiveRecord中封装了对数据库的访问，即CURD;；
3. ActiveRecord是一种领域模型(Domain Model)，封装了部分业务逻辑；
ActiveRecord比较适用于：
1. 业务逻辑比较简单，当你的类基本上和数据库中的表一一对应时, ActiveRecord是非常方便的，即你的业务逻辑大多数是对单表操作；
2. 当发生跨表的操作时, 往往会配合使用事务脚本(Transaction Script)，把跨表事务提升到事务脚本中；
3. ActiveRecord最大优点是简单, 直观。 一个类就包括了数据访问和业务逻辑. 如果配合代码生成器使用就更方便了；
这些优点使ActiveRecord特别适合WEB快速开发。
16、斐波那契方法，也就是1 1 2 3 5 8 ……，这里给出两种方法，大家可以对比下，看看哪种快，以及为什么
function fibonacci($n){
if($n == 0){
return 0;
}
if($n == 1){
return 1;
}
return fibonacci($n-1)+fibonacci($n-2);
}
function fibonacci($n){
for($i=0; $i<$n; $i++){
$r[] = $i<2 ? 1 : $r[$i-1]+$r[$i-2];
}
return $r[--$i];
}
17、约瑟夫环，也就是常见的数猴子，n只猴子围成一圈，每只猴子下面标了编号，从1开始数起，数到m那么第m只猴子便退出，依次类推，每数到m，那么那个位置的猴子退出，那么最后剩下的猴子下的编号是啥。
function yuesefu($n,$m) {
$r=0;
for($i=2; $i<=$n; $i++) {
$r=($r+$m)%$i;
}
return $r+1;
}
18、冒泡排序，大致是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换,这样一趟过去后,最大或最小的数字被交换到了最后一位,然后再从头开始进行两两比较交换,直到倒数第二位时结束
function bubbleSort($arr){
for($i=0, $len=count($arr); $i<$len; $i++){
for($j=0; $j<$len; $j++){
if($arr[$i]<$arr[$j]){
$tmp = $arr[$j];
$arr[$j] = $arr[$i];
$arr[$i] = $tmp;
}
}
}
return $arr;
}
19、快速排序，也就是找出一个元素（理论上可以随便找一个）作为基准,然后对数组进行分区操作,使基准左边元素的值都不大于基准值,基准右边的元素值 都不小于基准值，如此作为基准的元素调整到排序后的正确位置。递归快速排序，将其他n-1个元素也调整到排序后的正确位置。最后每个元素都是在排序后的正 确位置，排序完成。所以快速排序算法的核心算法是分区操作，即如何调整基准的位置以及调整返回基准的最终位置以便分治递归。
function quickSort($arr){
$len = count($arr);
if($len <=1){
return $arr;
}
$key = $arr[0];
$leftArr = $rightArr= array();
for($i=1; $i<$len; $i++){
if($arr[$i] <= $key){
$leftArr[] = $arr[$i];
} else{
$rightArr[] = $arr[$i];
}
}
$leftArr = quickSort($leftArr);
$rightArr = quickSort($rightArr);
return array_merge($leftArr, array($key), $rightArr);
}
20、（递归的）列出目录下所有文件及目录，这里也有两种方法
function listDir($path){
$res = dir($path);
while($file = $res->read()){
if($file == '.' || $file == '..'){
continue;
}
if(is_dir($path . '/' .$file)){
echo $path . '/' .$file . "\r\n";
listDir($path . '/' .$file);
} else{
echo $path . '/' .$file . "\r\n";
}
}
$res->close();
}
function listDir($path){
if(is_dir($path)){
if(FALSE !== ($res = opendir($path))){
while(FALSE !== ($file = readdir($res))){
if($file == '.' || $file == '..'){
continue;
}
$subPath = $path . '/' . $file;
if(is_dir($subPath)){
echo $subPath . "\r\n";
listDir($subPath);
} else{
echo $subPath . "\r\n";
}
}
}
}
}
21、找出相对的目录，比如/a/b/c/d/e.php相对于/a/b/13/34/c.php是/c/d/
function ralativePath($a, $b){
$a = explode('/', dirname($a));
$b = explode('/', dirname($b));
$c = '/';
foreach ($a as $k=> $v){
if($v != $b[$k]){
$c .= $v . '/';
}
}
echo $c;
}
22、快速找出url中php后缀
function get_ext($url){
$data = parse_url($url);
return pathinfo($data['path'], PATHINFO_EXTENSION);
}
23、正则题，使用正则抓取网页，以网页meta为utf8为准，若是抓取的网页编码为big5之类的，需要转化为utf8再收录
function preg_meta($meta){
$replacement = "\\1utf8\\6\\7";
$pattern = '#(<meta\s+http-equiv=(\'|"|)Content-Type(\'|"|)\s+content=(\'|"|)text/html; charset=)(\w+)(\'|"|)(>)#i';
return preg_replace($pattern, $replacement, $meta);
}
echo preg_meta("<meta http-equiv=Content-Type content='text/html; charset=big5'><META http-equiv=\"Content-Type\" content='text/html; charset=big5'>");
24、不用php的反转函数倒序输出字符串，如abc，反序输出cba
function revstring($str){
for($i=strlen($str)-1; $i>=0; $i--){
echo $str{$i};
}
}
revstring('abc');
25、常见端口
TCP 21端口：FTP 文件传输服务
SSH 22端口：SSH连接linux服务器，通过SSH连接可以远程管理Linux等设备
TCP 23端口：TELNET 终端仿真服务
TCP 25端口：SMTP 简单邮件传输服务
UDP 53端口：DNS 域名解析服务
TCP 80端口：HTTP 超文本传输服务
TCP 110端口：POP3 “邮局协议版本3”使用的端口
TCP 443端口：HTTPS 加密的超文本传输服务
TCP 1521端口：Oracle数据库服务
TCP 1863端口：MSN Messenger的文件传输功能所使用的端口
TCP 3389端口：Microsoft RDP 微软远程桌面使用的端口
TCP 5631端口：Symantec pcAnywhere 远程控制数据传输时使用的端口
UDP 5632端口：Symantec pcAnywhere 主控端扫描被控端时使用的端口
TCP 5000端口：MS SQL Server使用的端口
UDP 8000端口：腾讯QQ
26、linux常用的命令
top linux进程实时监控
ps 在Linux中是查看进程的命令。ps查看正处于Running的进程
mv 为文件或目录改名或将文件由一个目录移入另一个目录中。
find 查找文件
df 可显示所有文件系统对i节点和磁盘块的使用情况。
cat 打印文件类容
chmod 变更文件或目录的权限
chgrp 文件或目录的权限的掌控以拥有者及所诉群组来管理。可以使用chgrp指令取变更文件与目录所属群组
grep 是一种强大的文本搜索工具,它能使用正则表达式搜索文本,并把匹 配的行打印出来。
wc 为统计指定文件中的字节数、字数、行数,并将统计结果显示输出
27、对于大流量的网站,您采用什么样的方法来解决访问量问题
首先，确认服务器硬件是否足够支持当前的流量
其次，优化数据库访问。
第三，禁止外部的盗链。
第四，控制大文件的下载。
第五，使用不同主机分流主要流量
第六，使用流量分析统计软件
28、$_SERVER常用的字段
$_SERVER['PHP_SELF'] #当前正在执行脚本的文件名
$_SERVER['SERVER_NAME'] #当前运行脚本所在服务器主机的名称
$_SERVER['REQUEST_METHOD'] #访问页面时的请求方法。例如：“GET”、“HEAD”，“POST”，“PUT”
$_SERVER['QUERY_STRING'] #查询(query)的字符串
$_SERVER['HTTP_HOST'] #当前请求的 Host: 头部的内容
$_SERVER['HTTP_REFERER'] #链接到当前页面的前一页面的 URL 地址
$_SERVER['REMOTE_ADDR'] #正在浏览当前页面用户的 IP 地址
$_SERVER['REMOTE_HOST'] #正在浏览当前页面用户的主机名
$_SERVER['SCRIPT_FILENAME'] #当前执行脚本的绝对路径名
$_SERVER['SCRIPT_NAME'] #包含当前脚本的路径。这在页面需要指向自己时非常有用
$_SERVER['REQUEST_URI'] #访问此页面所需的 URI。例如，“/index.html”
29、安装php扩展
进入扩展的目录
phpize命令得到configure文件
./configure --with-php-config=/usr/local/php/bin/php-config
make & make install
在php.ini中加入扩展名称.so
重启web服务器(nginx/apache)
30、php-fpm与nginx
PHP-FPM也是一个第三方的FastCGI进程管理器，它是作为PHP的一个补丁来开发的，在安装的时候也需要和PHP源码一起编译，也就是说PHP-FPM被编译到PHP内核中，因此在处理性能方面更加优秀；同时它在处理高并发方面也比spawn-fcgi引擎好很多，因此，推荐Nginx+PHP/PHP-FPM这个组合对PHP进行解析。
FastCGI 的主要优点是把动态语言和HTTP Server分离开来，所以Nginx与PHP/PHP-FPM经常被部署在不同的服务器上，以分担前端Nginx服务器的压力，使Nginx专一处理静态请求和转发动态请求，而PHP/PHP-FPM服务器专一解析PHP动态请求
#fastcgi
FastCGI是一个可伸缩地、高速地在HTTP server和动态脚本语言间通信的接口。多数流行的HTTP server都支持FastCGI，包括Apache、Nginx和lighttpd等，同时，FastCGI也被许多脚本语言所支持，其中就有PHP。
FastCGI是从CGI发展改进而来的。传统CGI接口方式的主要缺点是性能很差，因为每次HTTP服务器遇到动态程序时都需要重新启动脚本解析器来执行解析，然后结果被返回给HTTP服务器。这在处理高并发访问时，几乎是不可用的。另外传统的CGI接口方式安全性也很差，现在已经很少被使用了。
FastCGI接口方式采用C/S结构，可以将HTTP服务器和脚本解析服务器分开，同时在脚本解析服务器上启动一个或者多个脚本解析守护进程。当HTTP服务器每次遇到动态程序时，可以将其直接交付给FastCGI进程来执行，然后将得到的结果返回给浏览器。这种方式可以让HTTP服务器专一地处理静态请求或者将动态脚本服务器的结果返回给客户端，这在很大程度上提高了整个应用系统的性能。
Nginx+FastCGI运行原理
Nginx不支持对外部程序的直接调用或者解析，所有的外部程序（包括PHP）必须通过FastCGI接口来调用。FastCGI接口在Linux下是socket，（这个socket可以是文件socket，也可以是ip socket）。为了调用CGI程序，还需要一个FastCGI的wrapper（wrapper可以理解为用于启动另一个程序的程序），这个wrapper绑定在某个固定socket上，如端口或者文件socket。当Nginx将CGI请求发送给这个socket的时候，通过FastCGI接口，wrapper接纳到请求，然后派生出一个新的线程，这个线程调用解释器或者外部程序处理脚本并读取返回数据；接着，wrapper再将返回的数据通过FastCGI接口，沿着固定的socket传递给Nginx；最后，Nginx将返回的数据发送给客户端，这就是Nginx+FastCGI的整个运作过程。
31、ajax全称“Asynchronous Javascript And XML”（异步JavaScript和XML）
回答
PHP面试干货
1、进程和线程
进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。进程和线程的区别在于：
简而言之,一个程序至少有一个进程,一个进程至少有一个线程.
线程的划分尺度小于进程，使得多线程程序的并发性高。
另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。
2、apache默认使用进程管理还是线程管理？如何判断并设置最大连接数？
一个进程可以开多个线程 默认是进程管理 默认有一个主进程
Linux: ps -aux | grep httpd | more 一个子进程代表一个用户的连接
Conf/extra/httpd-mpm.conf 多路功能模块 http -l 查询当前apache处于什么模式下
3、单例模式
单例模式需求:只能实例化产生一个对象
如何实现:
私有化构造函数
禁止克隆对象
提供一个访问这个实例的公共的静态方法（通常为getInstance方法），从而返回唯一对象
需要一个保存类的静态属性
class demo {
private static $MyObject; //保存对象的静态属性
private function __construct(){ //私有化构造函数
}
private function __clone(){ //禁止克隆
}
public static function getInstance(){
if(! (self::$MyObject instanceof self)){
self::$MyObject = new self;
}
return self::$MyObject;
}
}
4、安装完Apache后，在http.conf中配置加载PHP文件以Apache模块的方式安装PHP，在文件http.conf中首先要用语句LoadModule php5_module "e:/php/php5apache2.dll"动态装载PHP模块，然后再用语句AddType application/x-httpd-php .php 使得Apache把所有扩展名为PHP的文件都作为PHP脚本处理
5、debug_backtrace()函数能返回脚本里的任意行中调用的函数的名称。该函数同时还经常被用在调试中，用来判断错误是如何发生的
function one($str1, $str2)
{
two("Glenn", "Quagmire");
}
function two($str1, $str2)
{
three("Cleveland", "Brown");
}
function three($str1, $str2)
{
print_r(debug_backtrace());
}
one("Peter", "Griffin");
Array
(
[0] => Array
(
[file] => D:\www\test\result.php
[line] => 9
[function] => three
[args] => Array
(
[0] => Cleveland
[1] => Brown
)
)
[1] => Array
(
[file] => D:\www\test\result.php
[line] => 5
[function] => two
[args] => Array
(
[0] => Glenn
[1] => Quagmire
)
)
[2] => Array
(
[file] => D:\www\test\result.php
[line] => 16
[function] => one
[args] => Array
(
[0] => Peter
[1] => Griffin
)
)
)
6、输出用户的IP地址，并且判断用户的IP地址是否在192.168.1.100 — 192.168.1.150之间
echo $ip=getenv('REMOTE_ADDR');
$ip=str_replace('.','',$ip);
if($ip<1921681150 && $ip>1921681100)
{
echo 'ip在192.168.1.100—–192.168.1.150之间';
}
else
{
echo 'ip不在192.168.1.100—–192.168.1.150之间';
}
7、请将2维数组按照name的长度进行重新排序，按照顺序将id赋值
$tarray = array(
array('id' => 0, 'name' => '123'),
array('id' => 0, 'name' => '1234'),
array('id' => 0, 'name' => '1235'),
array('id' => 0, 'name' => '12356'),
array('id' => 0, 'name' => '123abc')
);
foreach($tarray as $key=>$val)
{
$c[]=$val['name'];
}
function aa($a,$b)
{
if(strlen($a)==strlen($b)) return 0;
return strlen($a)>strlen($b)?-1:1;
}
usort($c,'aa');
$len=count($c);
for($i=0;$i<$len;$i++)
{
$t[$i]['id']=$i+1;
$t[$i]['name']=$c[$i];
}
print_r($t);
8、表单数据提交方式POST和GET的区别，URL地址传递的数据最大长度是多少？
POST方式提交数据用户不可见，是数据更安全，最大长度不受限制，而GET方式传值在URL地址可以看到，相对不安全，对大长度是2048字节。
9、SESSION和COOKIE的作用和区别，SESSION信息的存储方式，如何进行遍历
SESSION和COOKIE都能够使值在页面之间进行传递，SESSION存储在服务器端，数据更安全，COOKIE保存在客户端，用户使用手段可以进行修改，SESSION依赖于COOKIE进行传递的。Session遍历使用$_SESSION[]取值，cookie遍历使用$_COOKIE[]取值。
10、什么是数据库索引，主键索引，唯一索引的区别，索引的缺点是什么
索引用来快速地寻找那些具有特定值的记录。
主键索引和唯一索引的区别：主键是一种唯一性索引，但它必须指定为“PRIMARY KEY”,每个表只能有一个主键。唯一索引索引列的所有值都只能出现一次，即必须唯一。
索引的缺点：
1、创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加。
2、索引需要占用物理空间，除了数据表占数据空间之外，每一个索引还要占一定的物理空间，如果要建立聚簇索引，需要的空间就会更大。
3、当对表中的数据进行增加、删除、修改的时候，索引也要动态的维护，这样就降低了数据的维护速度。
11、数据库设计时，常遇到的性能瓶颈有哪些，常有的解决方案
瓶颈主要有：
1、磁盘搜索 优化方法是：将数据分布在多个磁盘上
2、磁盘读/写 优化方法是：从多个磁盘并行读写。
3、CPU周期 优化方法：扩充内存
4、内存带宽
12、include和require区别
include引入文件的时候，如果碰到错误，会给出提示，并继续运行下边的代码。
require引入文件的时候，如果碰到错误，会给出提示，并停止运行下边的代码。
13、文件上传时设计到点
和文件上传有关的php.ini配置选项（File Uploads）：
file_uploads=On/Off:文件是否允许上传
upload_max_filesize上传文件时，单个文件的最大大小
post_max_size:提交表单时，整个post表单的最大大小
max_file_uploads =20上传文件的个数
内存占用，脚本最大执行时间也间接影响到文件的上传
14、header常见状态
//200 正常状态
header('HTTP/1.1 200 OK');
// 301 永久重定向，记得在后面要加重定向地址 Location:$url
header('HTTP/1.1 301 Moved Permanently');
// 重定向，其实就是302 暂时重定向
header('Location: http://www.maiyoule.com/');
// 设置页面304 没有修改
header('HTTP/1.1 304 Not Modified');
// 显示登录框，
header('HTTP/1.1 401 Unauthorized');
header('WWW-Authenticate: Basic realm="登录信息"');
echo '显示的信息！';
// 403 禁止访问
header('HTTP/1.1 403 Forbidden');
// 404 错误
header('HTTP/1.1 404 Not Found');
// 500 服务器错误
header('HTTP/1.1 500 Internal Server Error');
// 3秒后重定向指定地址(也就是刷新到新页面与 <meta http-equiv="refresh" content="10;http://www.maiyoule.com/ /> 相同)
header('Refresh: 3; url=http://www.maiyoule.com/');
echo '10后跳转到http://www.maiyoule.com';
// 重写 X-Powered-By 值
header('X-Powered-By: PHP/5.3.0');
header('X-Powered-By: Brain/0.6b');
//设置上下文语言
header('Content-language: en');
// 设置页面最后修改时间（多用于防缓存）
$time = time() - 60; //建议使用filetime函数来设置页面缓存时间
header('Last-Modified: '.gmdate('D, d M Y H:i:s', $time).' GMT');
// 设置内容长度
header('Content-Length: 39344');
// 设置头文件类型，可以用于流文件或者文件下载
header('Content-Type: application/octet-stream');
header('Content-Disposition: attachment; filename="example.zip"');
header('Content-Transfer-Encoding: binary');
readfile('example.zip');//读取文件到客户端
//禁用页面缓存
header('Cache-Control: no-cache, no-store, max-age=0, must-revalidate');
header('Expires: Mon, 26 Jul 1997 05:00:00 GMT');
header('Pragma: no-cache');
//设置页面头信息
header('Content-Type: text/html; charset=iso-8859-1');
header('Content-Type: text/html; charset=utf-8');
header('Content-Type: text/plain');
header('Content-Type: image/jpeg');
header('Content-Type: application/zip');
header('Content-Type: application/pdf');
header('Content-Type: audio/mpeg');
header('Content-Type: application/x-shockwave-flash');
//.... 至于Content-Type 的值 可以去查查 w3c 的文档库，那里很丰富
15、ORM和ActiveRecord
ORM:object relation mapping,即对象关系映射，简单的说就是对象模型和关系模型的一种映射。为什么要有这么一个映射？很简单，因为现在的开发语言基本都是oop的，但是传统的数据库却是关系型的。为了可以靠贴近面向对象开发，我们想要像操作对象一样操作数据库。还可以隔离底层数据库层，我们不需要关心我们使用的是mysql还是其他的关系型数据库
ActiveRecord也属于ORM层，由Rails最早提出，遵循标准的ORM模型：表映射到记录，记录映射到对象，字段映射到对象属性。配合遵循的命名和配置惯例，能够很大程度的快速实现模型的操作，而且简洁易懂。
ActiveRecord的主要思想是：
1. 每一个数据库表对应创建一个类，类的每一个对象实例对应于数据库中表的一行记录；通常表的每个字段在类中都有相应的Field；
2. ActiveRecord同时负责把自己持久化，在ActiveRecord中封装了对数据库的访问，即CURD;；
3. ActiveRecord是一种领域模型(Domain Model)，封装了部分业务逻辑；
ActiveRecord比较适用于：
1. 业务逻辑比较简单，当你的类基本上和数据库中的表一一对应时, ActiveRecord是非常方便的，即你的业务逻辑大多数是对单表操作；
2. 当发生跨表的操作时, 往往会配合使用事务脚本(Transaction Script)，把跨表事务提升到事务脚本中；
3. ActiveRecord最大优点是简单, 直观。 一个类就包括了数据访问和业务逻辑. 如果配合代码生成器使用就更方便了；
这些优点使ActiveRecord特别适合WEB快速开发。
16、斐波那契方法，也就是1 1 2 3 5 8 ……，这里给出两种方法，大家可以对比下，看看哪种快，以及为什么
function fibonacci($n){
if($n == 0){
return 0;
}
if($n == 1){
return 1;
}
return fibonacci($n-1)+fibonacci($n-2);
}
function fibonacci($n){
for($i=0; $i<$n; $i++){
$r[] = $i<2 ? 1 : $r[$i-1]+$r[$i-2];
}
return $r[--$i];
}
17、约瑟夫环，也就是常见的数猴子，n只猴子围成一圈，每只猴子下面标了编号，从1开始数起，数到m那么第m只猴子便退出，依次类推，每数到m，那么那个位置的猴子退出，那么最后剩下的猴子下的编号是啥。
function yuesefu($n,$m) {
$r=0;
for($i=2; $i<=$n; $i++) {
$r=($r+$m)%$i;
}
return $r+1;
}
18、冒泡排序，大致是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换,这样一趟过去后,最大或最小的数字被交换到了最后一位,然后再从头开始进行两两比较交换,直到倒数第二位时结束
function bubbleSort($arr){
for($i=0, $len=count($arr); $i<$len; $i++){
for($j=0; $j<$len; $j++){
if($arr[$i]<$arr[$j]){
$tmp = $arr[$j];
$arr[$j] = $arr[$i];
$arr[$i] = $tmp;
}
}
}
return $arr;
}
19、快速排序，也就是找出一个元素（理论上可以随便找一个）作为基准,然后对数组进行分区操作,使基准左边元素的值都不大于基准值,基准右边的元素值 都不小于基准值，如此作为基准的元素调整到排序后的正确位置。递归快速排序，将其他n-1个元素也调整到排序后的正确位置。最后每个元素都是在排序后的正 确位置，排序完成。所以快速排序算法的核心算法是分区操作，即如何调整基准的位置以及调整返回基准的最终位置以便分治递归。
function quickSort($arr){
$len = count($arr);
if($len <=1){
return $arr;
}
$key = $arr[0];
$leftArr = $rightArr= array();
for($i=1; $i<$len; $i++){
if($arr[$i] <= $key){
$leftArr[] = $arr[$i];
} else{
$rightArr[] = $arr[$i];
}
}
$leftArr = quickSort($leftArr);
$rightArr = quickSort($rightArr);
return array_merge($leftArr, array($key), $rightArr);
}
20、（递归的）列出目录下所有文件及目录，这里也有两种方法
function listDir($path){
$res = dir($path);
while($file = $res->read()){
if($file == '.' || $file == '..'){
continue;
}
if(is_dir($path . '/' .$file)){
echo $path . '/' .$file . "\r\n";
listDir($path . '/' .$file);
} else{
echo $path . '/' .$file . "\r\n";
}
}
$res->close();
}
function listDir($path){
if(is_dir($path)){
if(FALSE !== ($res = opendir($path))){
while(FALSE !== ($file = readdir($res))){
if($file == '.' || $file == '..'){
continue;
}
$subPath = $path . '/' . $file;
if(is_dir($subPath)){
echo $subPath . "\r\n";
listDir($subPath);
} else{
echo $subPath . "\r\n";
}
}
}
}
}
21、找出相对的目录，比如/a/b/c/d/e.php相对于/a/b/13/34/c.php是/c/d/
function ralativePath($a, $b){
$a = explode('/', dirname($a));
$b = explode('/', dirname($b));
$c = '/';
foreach ($a as $k=> $v){
if($v != $b[$k]){
$c .= $v . '/';
}
}
echo $c;
}
22、快速找出url中php后缀
function get_ext($url){
$data = parse_url($url);
return pathinfo($data['path'], PATHINFO_EXTENSION);
}
23、正则题，使用正则抓取网页，以网页meta为utf8为准，若是抓取的网页编码为big5之类的，需要转化为utf8再收录
function preg_meta($meta){
$replacement = "\\1utf8\\6\\7";
$pattern = '#(<meta\s+http-equiv=(\'|"|)Content-Type(\'|"|)\s+content=(\'|"|)text/html; charset=)(\w+)(\'|"|)(>)#i';
return preg_replace($pattern, $replacement, $meta);
}
echo preg_meta("<meta http-equiv=Content-Type content='text/html; charset=big5'><META http-equiv=\"Content-Type\" content='text/html; charset=big5'>");
24、不用php的反转函数倒序输出字符串，如abc，反序输出cba
function revstring($str){
for($i=strlen($str)-1; $i>=0; $i--){
echo $str{$i};
}
}
revstring('abc');
25、常见端口
TCP 21端口：FTP 文件传输服务
SSH 22端口：SSH连接linux服务器，通过SSH连接可以远程管理Linux等设备
TCP 23端口：TELNET 终端仿真服务
TCP 25端口：SMTP 简单邮件传输服务
UDP 53端口：DNS 域名解析服务
TCP 80端口：HTTP 超文本传输服务
TCP 110端口：POP3 “邮局协议版本3”使用的端口
TCP 443端口：HTTPS 加密的超文本传输服务
TCP 1521端口：Oracle数据库服务
TCP 1863端口：MSN Messenger的文件传输功能所使用的端口
TCP 3389端口：Microsoft RDP 微软远程桌面使用的端口
TCP 5631端口：Symantec pcAnywhere 远程控制数据传输时使用的端口
UDP 5632端口：Symantec pcAnywhere 主控端扫描被控端时使用的端口
TCP 5000端口：MS SQL Server使用的端口
UDP 8000端口：腾讯QQ
26、linux常用的命令
top linux进程实时监控
ps 在Linux中是查看进程的命令。ps查看正处于Running的进程
mv 为文件或目录改名或将文件由一个目录移入另一个目录中。
find 查找文件
df 可显示所有文件系统对i节点和磁盘块的使用情况。
cat 打印文件类容
chmod 变更文件或目录的权限
chgrp 文件或目录的权限的掌控以拥有者及所诉群组来管理。可以使用chgrp指令取变更文件与目录所属群组
grep 是一种强大的文本搜索工具,它能使用正则表达式搜索文本,并把匹 配的行打印出来。
wc 为统计指定文件中的字节数、字数、行数,并将统计结果显示输出
27、对于大流量的网站,您采用什么样的方法来解决访问量问题
首先，确认服务器硬件是否足够支持当前的流量
其次，优化数据库访问。
第三，禁止外部的盗链。
第四，控制大文件的下载。
第五，使用不同主机分流主要流量
第六，使用流量分析统计软件
28、$_SERVER常用的字段
$_SERVER['PHP_SELF'] #当前正在执行脚本的文件名
$_SERVER['SERVER_NAME'] #当前运行脚本所在服务器主机的名称
$_SERVER['REQUEST_METHOD'] #访问页面时的请求方法。例如：“GET”、“HEAD”，“POST”，“PUT”
$_SERVER['QUERY_STRING'] #查询(query)的字符串
$_SERVER['HTTP_HOST'] #当前请求的 Host: 头部的内容
$_SERVER['HTTP_REFERER'] #链接到当前页面的前一页面的 URL 地址
$_SERVER['REMOTE_ADDR'] #正在浏览当前页面用户的 IP 地址
$_SERVER['REMOTE_HOST'] #正在浏览当前页面用户的主机名
$_SERVER['SCRIPT_FILENAME'] #当前执行脚本的绝对路径名
$_SERVER['SCRIPT_NAME'] #包含当前脚本的路径。这在页面需要指向自己时非常有用
$_SERVER['REQUEST_URI'] #访问此页面所需的 URI。例如，“/index.html”
29、安装php扩展
进入扩展的目录
phpize命令得到configure文件
./configure --with-php-config=/usr/local/php/bin/php-config
make & make install
在php.ini中加入扩展名称.so
重启web服务器(nginx/apache)
30、php-fpm与nginx
PHP-FPM也是一个第三方的FastCGI进程管理器，它是作为PHP的一个补丁来开发的，在安装的时候也需要和PHP源码一起编译，也就是说PHP-FPM被编译到PHP内核中，因此在处理性能方面更加优秀；同时它在处理高并发方面也比spawn-fcgi引擎好很多，因此，推荐Nginx+PHP/PHP-FPM这个组合对PHP进行解析。
FastCGI 的主要优点是把动态语言和HTTP Server分离开来，所以Nginx与PHP/PHP-FPM经常被部署在不同的服务器上，以分担前端Nginx服务器的压力，使Nginx专一处理静态请求和转发动态请求，而PHP/PHP-FPM服务器专一解析PHP动态请求
#fastcgi
FastCGI是一个可伸缩地、高速地在HTTP server和动态脚本语言间通信的接口。多数流行的HTTP server都支持FastCGI，包括Apache、Nginx和lighttpd等，同时，FastCGI也被许多脚本语言所支持，其中就有PHP。
FastCGI是从CGI发展改进而来的。传统CGI接口方式的主要缺点是性能很差，因为每次HTTP服务器遇到动态程序时都需要重新启动脚本解析器来执行解析，然后结果被返回给HTTP服务器。这在处理高并发访问时，几乎是不可用的。另外传统的CGI接口方式安全性也很差，现在已经很少被使用了。
FastCGI接口方式采用C/S结构，可以将HTTP服务器和脚本解析服务器分开，同时在脚本解析服务器上启动一个或者多个脚本解析守护进程。当HTTP服务器每次遇到动态程序时，可以将其直接交付给FastCGI进程来执行，然后将得到的结果返回给浏览器。这种方式可以让HTTP服务器专一地处理静态请求或者将动态脚本服务器的结果返回给客户端，这在很大程度上提高了整个应用系统的性能。
Nginx+FastCGI运行原理
Nginx不支持对外部程序的直接调用或者解析，所有的外部程序（包括PHP）必须通过FastCGI接口来调用。FastCGI接口在Linux下是socket，（这个socket可以是文件socket，也可以是ip socket）。为了调用CGI程序，还需要一个FastCGI的wrapper（wrapper可以理解为用于启动另一个程序的程序），这个wrapper绑定在某个固定socket上，如端口或者文件socket。当Nginx将CGI请求发送给这个socket的时候，通过FastCGI接口，wrapper接纳到请求，然后派生出一个新的线程，这个线程调用解释器或者外部程序处理脚本并读取返回数据；接着，wrapper再将返回的数据通过FastCGI接口，沿着固定的socket传递给Nginx；最后，Nginx将返回的数据发送给客户端，这就是Nginx+FastCGI的整个运作过程。
31、ajax全称“Asynchronous Javascript And XML”（异步JavaScript和XML）
回答
关于二十四点游戏的编程思路与基本算法
漫长的假期对于我来说总是枯燥无味的，闲来无聊便和同学玩起童年时经常玩的二十四点牌游戏来。此游戏说来简单，就是利用加减乘除以及括号将给出的四张牌组成一个值为24的表达式。但是其中却不乏一些有趣的题目，这不，我们刚玩了一会儿，便遇到了一个难题——3、6、6、10（其实后来想想，这也不算是个太难的题，只是当时我们的脑筋都没有转弯而已，呵呵）。
问题既然出现了，我们当然要解决。冥思苦想之际，我的脑中掠过一丝念头——何不编个程序来解决这个问题呢。文曲星中不就有这样的程序吗。所以这个想法应该是可行。想到这里我立刻开始思索这个程序的算法，最先想到的自然是穷举法（后来发现我再也想不到更好的方法了，悲哀呀，呵呵），因为在这学期我曾经写过一个小程序——计算有括号的简单表达式。只要我能编程实现四个数加上运算符号所构成的表达式的穷举，不就可以利用这个计算程序来完成这个计算二十四点的程序吗。确定了这个思路之后，我开始想这个问题的细节。
首先穷举的可行性问题。我把表达式如下分成三类——
1、 无括号的简单表达式。
2、 有一个括号的简单表达式。
3、 有两个括号的较复4、 杂表达式。
穷举的开始我对给出的四个数进行排列，其可能的种数为4*3*2*1=24。我利用一个嵌套函数实现四个数的排列，算法如下:
/* ans[] 用来存放各种排列组合的数组 */
/* c[] 存放四张牌的数组 */
/* k[] c[]种四张牌的代号，其中k[I]=I+1。
用它来代替c[]做处理，考虑到c[]中有可能出现相同数的情况 */
/* kans[] 暂存生成的排列组合 */
/* j 嵌套循环的次数 */
int fans(c,k,ans,kans,j)
int j,k[],c[];char ans[],kans[];
{ int i,p,q,r,h,flag,s[4],t[4][4];
for(p=0,q=0;p<4;p++)
{ for(r=0,flag=0;r if(k[p]!=kans[r]) flag++;
if(flag==j) t[j][q++]=k[p];
}
for(s[j]=0;s[j]<4-j;s[j]++)
{ kans[j]=t[j][s[j>;
if(j==3) { for(h=0;h<4;h++)
ans[2*h]=c[kans[h]-1]; /* 调整生成的排列组合在最终的表
达式中的位置 */
for(h=0;h<3;h++)
symbol(ans,h); /* 在表达式中添加运算符号 */
}
else { j++;
fans(c,k,ans,kans,j);
j--;
}
}
}
正如上面函数中提到的，在完成四张牌的排列之后，在表达式中添加运算符号。由于只有四张牌，所以只要添加三个运算符号就可以了。由于每一个运算符号可重复，所以计算出其可能的种数为4*4*4=64种。仍然利用嵌套函数实现添加运算符号的穷举，算法如下:
/* ans[],j同上。sy[]存放四个运算符号。h为表达式形式。*/
int sans(ans,sy,j,h)
char ans[],sy[];int j,h;
{ int i,p,k[3],m,n; char ktans[20];
for(k[j]=0;k[j]<4;k[j]++)
{ ans[2*j+1]=sy[k[j>; /* 刚才的四个数分别存放在0、2、4、6位
这里的三个运算符号分别存放在1、3、5位*/
if(j==2)
{ ans[5]=sy[k[j>;
/* 此处根据不同的表达式形式再进行相应的处理 */
}
else
}
}
好了，接下来我再考虑不同表达式的处理。刚才我已经将表达式分为三类，是因为添加三个括号对于四张牌来说肯定是重复的。对于第一种，无括号自然不用另行处理；而第二种情况由以下代码可以得出其可能性有六种，其中还有一种是多余的。
for(m=0;m<=4;m+=2)
for(n=m+4;n<=8;n+=2)
这个for循环给出了添加一个括号的可能性的种数，其中m、n分别为添加在表达式中的左右括号的位置。我所说的多余的是指m=0，n=8，也就是放在表达式的两端。这真是多此一举，呵呵。最后一种情况是添加两个括号，我分析了一下，发现只可能是这种形式才不会是重复的——（a b）(c d)。为什么不会出现嵌套括号的情况呢。因为如果是嵌套括号，那么外面的括号肯定是包含三个数字的（四个没有必要），也就是说这个括号里面包含了两个运算符号，而这两个运算符号是被另外一个括号隔开的。那么如果这两个运算符号是同一优先级的，则肯定可以通过一些转换去掉括号（你不妨举一些例子来试试），也就是说这一个括号没有必要；如果这两个运算符号不是同一优先级，也必然是这种形式((a+-b)*/c)。而*和/在这几个运算符号中优先级最高，自然就没有必要在它的外面添加括号了。
综上所述，所有可能的表达式的种数为24*64*（1+6+1）=12288种。哈哈，只有一万多种可能性（这其中还有重复），这对于电脑来说可是小case哟。所以，对于穷举的可行性分析和实现也就完成了。
接下来的问题就是如何对有符号的简单表达式进行处理。这是栈的一个著名应用，那么什么是栈呢。栈的概念是从日常生活中货物在货栈种的存取过程抽象出来的，即最后存放入栈的货物（堆在靠出口处）先被提取出去，符合“先进后出，后进先出”的原则。这种结构犹如子弹夹。
在栈中，元素的插入称为压入（push）或入栈，元素的删除称为弹出（pop）或退栈。
栈的基本运算有三种，其中包括入栈运算、退栈运算以及读栈顶元素，这些请参考相关数据结构资料。根据这些基本运算就可以用数组模拟出栈来。
那么作为栈的著名应用，表达式的计算可以有两种方法。
第一种方法——
首先建立两个栈，操作数栈OVS和运算符栈OPS。其中，操作数栈用来记忆表达式中的操作数，其栈顶指针为topv，初始时为空，即topv=0；运算符栈用来记忆表达式中的运算符，其栈顶指针为topp，初始时，栈中只有一个表达式结束符，即topp=1，且OPS（1）=‘；’。此处的‘；’即表达式结束符。
然后自左至右的扫描待处理的表达式，并假设当前扫描到的符号为W，根据不同的符号W做如下不同的处理：
1、 若W为操作数
2、 则将W压入操作数栈OVS
3、 且继续扫描下一个字符
4、 若W为运算符
5、 则根据运算符的性质做相应的处理：
(1)、若运算符为左括号或者运算符的优先级大于运算符栈栈顶的运算符(即OPS(top)),则将运算符W压入运算符栈OPS，并继续扫描下一个字符。
(2)、若运算符W为表达式结束符‘；’且运算符栈栈顶的运算符也为表达式结束符（即OPS(topp)=’;’），则处理过程结束，此时，操作数栈栈顶元素（即OVS（topv））即为表达式的值。
(3)、若运算符W为右括号且运算符栈栈顶的运算符为左括号（即OPS（topp）=’(‘)，则将左括号从运算符栈谈出，且继续扫描下一个符号。
(4)、若运算符的右不大于运算符栈栈顶的运算符（即OPS(topp)），则从操作数栈OVS中弹出两个操作数，设先后弹出的操作数为a、b，再从运算符栈OPS中弹出一个运算符，设为+，然后作运算a+b,并将运算结果压入操作数栈OVS。本次的运算符下次将重新考虑。
第二种方法——
首先对表达式进行线性化，然后将线性表达式转换成机器指令序列以便进行求值。
那么什么是表达式的线性化呢。人们所习惯的表达式的表达方法称为中缀表示。中缀表示的特点是运算符位于运算对象的中间。但这种表示方式，有时必须借助括号才能将运算顺序表达清楚，而且处理也比较复杂。
1929年，波兰逻辑学家Lukasiewicz提出一种不用括号的逻辑符号体系，后来人们称之为波兰表示法（Polish notation）。波兰表达式的特点是运算符位于运算对象的后面，因此称为后缀表示。在对波兰表达式进行运算，严格按照自左至右的顺序进行。下面给出一些表达式及其相应的波兰表达式。
表达式 波兰表达式
A-B AB-
（A-B）*C+D AB-C*D+
A*（B+C/D）-E*F ABCD/+*EF*-
（B+C）/（A-D） BC+AD-/
OK，所谓表达式的线性化是指将中缀表达的表达式转化为波兰表达式。对于每一个表达式，利用栈可以把表达式变换成波兰表达式，也可以利用栈来计算波兰表达式的值。
至于转换和计算的过程和第一种方法大同小异，这里就不再赘述了。
下面给出转换和计算的具体实现程序——
/* first函数给出各个运算符的优先级，其中=为表达式结束符 */
int first(char c)
{ int p;
switch(c)
{ case '*': p=2; break;
case '/': p=2; break;
case '+': p=1; break;
case '-': p=1; break;
case '(': p=0; break;
case '=': p=-1; break;
}
return(p);
}
/* 此函数实现中缀到后缀的转换 */
/* M的值宏定义为20 */
/* sp[]为表达式数组 */
int mid_last()
{ int i=0,j=0; char c,sm[M];
c=s[0]; sm[0]='='; top=0;
while(c!='\0')
{ if(islower(c)) sp[j++]=c;
else switch(c)
{ case '+':
case '-':
case '*':
case '/': while(first(c)<=first(sm[top]))
sp[j++]=sm[top--];
sm[++top]=c; break;
case '(': sm[++top]=c; break;
case ')': while(sm[top]!='(')
sp[j++]=sm[top--];
top--; break;
default :return(1);
}
c=s[++i];
}
while(top>0) sp[j++]=sm[top--];
sp[j]='\0'; return(0);
}
/* 由后缀表达式来计算表达式的值 */
int calc()
{ int i=0,sm[M],tr; char c;
c=sp[0]; top=-1;
while(c!='\0')
{ if(islower(c)) sm[++top]=ver[c-'a'];/*在转换过程中用abcd等来代替数，
这样才可以更方便的处理非一位数，
ver数组中存放着这些字母所代替的数*/
else switch(c)
{ case '+': tr=sm[top--]; sm[top]+=tr; break;
case '-': tr=sm[top--]; sm[top]-=tr; break;
case '*': tr=sm[top--]; sm[top]*=tr; break;
case '/': tr=sm[top--];sm[top]/=tr;break;
default : return(1);
}
c=sp[++i];
}
if(top>0) return(1);
else
}
这样这个程序基本上就算解决了，回过头来拿这个程序来算一算文章开始的那个问题。哈哈，算出来了，原来如此简单——（6-3）*10-6=24。
最后我总结了一下这其中容易出错的地方——
1、 排列的时候由于一个数只能出现一次， 所以必然有一个判断语句。但是用什么来判断，用大小显然不行，因为有可能这四个数中有两个或者以上的数是相同的。我的方法是给每一个数设置一个代号，在排列结束时，通过这个代号找到这个数。
2、在应用嵌套函数时，需仔细分析程序的执行过程，并对个别变量进行适当的调整（如j的值）,程序才能正确的执行。
3、在分析括号问题的时候要认真仔细，不要错过任何一个可能的机会，也要尽量使程序变得简单一些。不过我的分析可能也有问题，还请高手指点。
4、在用函数对一个数组进行处理的时候，一定要注意如果这个数组还需要再应用，就必须将它先保存起来，否则会出错，而且是很严重的错误。
5、在处理用户输入的表达式时，由于一个十位数或者更高位数是被分解成各位数存放在数组中，所以需对它们进行处理，将它们转化成实际的整型变量。另外，在转化过程中，用一个字母来代替这个数，并将这个数存在一个数组中，且它在数组中的位置和代替它的这个字母有一定的联系，这样才能取回这个数。
6、由于在穷举过程难免会出现计算过程中有除以0的计算，所以我们必须对calc函数种对于除的运算加以处理，否则程序会因为出错而退出（Divide by 0）。
7、最后一个问题，本程序尚未解决。对于一些比较著名的题目，本程序无法解答。比如说5、5、5、1或者8、8、3、3。这是由于这些题目在计算的过程用到了小数，而本程序并没有考虑到小数。