区域数据出问题什么情况

算法是比较复杂又基础的学科，每个学编程的人都会学习大量的算法。而根据统计，以下这18个问题是面试中最容易遇到的，本文给出了一些基本答案，供算法方向工程师或对此感兴趣的程序员参考。 1)请简单解释算法是什么? 算法是一个定义良好的计算过程，它将一些值作为输入并产生相应的输出值。简单来说，它是将输入转换为输出的一系列计算步骤。 2)解释什么是快速排序算法? 快速排序算法能够快速排序列表或查询。它基于分割交换排序的原则，这种类型的算法占用空间较小，它将待排序列表分为三个主要部分： ·小于Pivot的元素 ·枢轴元素Pivot(选定的比较值) ·大于Pivot的元素 3)解释算法的时间复杂度? 算法的时间复杂度表示程序运行完成所需的总时间，它通常用大O表示法来表示。 4)请问用于时间复杂度的符号类型是什么? 用于时间复杂度的符号类型包括： ·Big Oh：它表示小于或等于目标多项式 ·Big Omega：它表示大于或等于目标多项式 ·Big Theta：它表示与目标多项式相等 ·Little Oh：它表示小于目标多项式 ·Little Omega：它表示大于目标多项式 5)解释二分法检索如何工作? 在二分法检索中，我们先确定数组的中间位置，然后将要查找的值与数组中间位置的值进行比较，若小于数组中间值，则要查找的值应位于该中间值之前，依此类推，不断缩小查找范围，直至得到最终结果。 6)解释是否可以使用二分法检索链表? 由于随机访问在链表中是不可接受的，所以不可能到达O(1)时间的中间元素。因此，对于链表来说，二分法检索是不可以的(对顺序链表或排序后的链表是可以用的)。 7)解释什么是堆排序? 堆排序可以看成是选择排序的改进，它可以定义为基于比较的排序算法。它将其输入划分为未排序和排序的区域，通过不断消除最小元素并将其移动到排序区域来收缩未排序区域。 8)说明什么是Skip list? Skip list数据结构化的方法，它允许算法在符号表或字典中搜索、删除和插入元素。在Skip list中，每个元素由一个节点表示。搜索函数返回与key相关的值的内容。插入操作将指定的键与新值相关联，删除操作可删除指定的键。 9)解释插入排序算法的空间复杂度是多少? 插入排序是一种就地排序算法，这意味着它不需要额外的或仅需要少量的存储空间。对于插入排序，它只需要将单个列表元素存储在初始数据的外侧，从而使空间复杂度为O(1)。 10)解释什么是“哈希算法”，它们用于什么? “哈希算法”是一个哈希函数，它使用任意长度的字符串，并将其减少为唯一的固定长度字符串。它用于密码有效性、消息和数据完整性以及许多其他加密系统。 11)解释如何查找链表是否有循环? 要知道链表是否有循环，我们将采用两个指针的方法。如果保留两个指针，并且在处理两个节点之后增加一个指针，并且在处理每个节点之后，遇到指针指向同一个节点的情况，这只有在链表有循环时才会发生。 12)解释加密算法的工作原理? 加密是将明文转换为称为“密文”的密码格式的过程。要转换文本，算法使用一系列被称为“键”的位来进行计算。密钥越大，创建密文的潜在模式数越多。大多数加密算法使用长度约为64到128位的固定输入块，而有些则使用流方法。 13)列出一些常用的加密算法? 一些常用的加密算法是： ·3-way ·Blowfish ·CAST ·CMEA ·GOST ·DES 和Triple DES ·IDEA ·LOKI等等 14)解释一个算法的最佳情况和最坏情况之间有什么区别? ·最佳情况：算法的最佳情况解释为算法执行最佳的数据排列。例如，我们进行二分法检索，如果目标值位于正在搜索的数据中心，则这就是最佳情况，最佳情况时间复杂度为0。 ·最差情况：给定算法的最差输入参考。例如快速排序，如果选择关键值的子列表的最大或最小元素，则会导致最差情况出现，这将导致时间复杂度快速退化到O(n2)。 15)解释什么是基数排序算法? 基数排序又称“桶子法”，是通过比较数字将其分配到不同的“桶里”来排序元素的。它是线性排序算法之一。 16)解释什么是递归算法? 递归算法是一个解决复杂问题的方法，将问题分解成较小的子问题，直到分解的足够小，可以轻松解决问题为止。通常，它涉及一个调用自身的函数。 17)提到递归算法的三个定律是什么? 所有递归算法必须遵循三个规律： ·递归算法必须有一个基点 ·递归算法必须有一个趋向基点的状态变化过程 ·递归算法必须自我调用 18)解释什么是冒泡排序算法? 冒泡排序算法也称为下沉排序。在这种类型的排序中，要排序的列表的相邻元素之间互相比较。如果它们按顺序排列错误，将交换值并以正确的顺序排列，直到最终结果“浮”出水面。 满意记得采纳哈

我们都知道虚拟机的内存划分了多个区域，并不是一张大饼。那么为什么要划分为多块区域呢，直接搞一块区域，所有用到内存的地方都往这块区域里扔不就行了，岂不痛快。是的，如果不进行区域划分，扔的时候确实痛快，可用的时候再去找怎么办呢，这就引入了第一个问题，分类管理，类似于衣柜，系统磁盘等等，为了方便查找，我们会进行分区分类。另外如果不进行分区，内存用尽了怎么办呢？这里就引入了内存划分的第二个原因，就是为了方便内存的回收。如果不分，回收内存需要全部内存扫描，那就慢死了，内存根据不同的使用功能分成不同的区域，那么内存回收也就可以根据每个区域的特定进行回收，比如像栈内存中的栈帧，随着方法的执行栈帧进栈，方法执行完毕就出栈了，而对于像堆内存的回收就需要使用经典的回收算法来进行回收了，所以看起来分类这么麻烦，其实是大有好处的。 提到虚拟机的内存结构，可能首先想起来的就是堆栈。对象分配到堆上，栈上用来分配对象的引用以及一些基本数据类型相关的值。但是·虚拟机的内存结构远比此要复杂的多。除了我们所认识的（还没有认识完全）的堆栈以外，还有程序计数器，本地方法栈和方法区。我们平时所说的栈内存，一般是指的栈内存中的局部变量表。 从图中可以看到有5大内存区域，按照是否被线程所共享可分为两部分，一部分是线程独占区域，包括Java栈，本地方法栈和程序计数器。还有一部分是被线程所共享的，包括方法区和堆。什么是线程共享和线程独占呢，非常好理解，我们知道每一个Java进行都会有多个线程同时运行，那么线程共享区的这片区域就是被所有线程一起使用的，不管有多少个线程，这片空间始终就这一个。而线程的独占区，是每个线程都有这么一份内存空间，每个线程的这片空间都是独有的，有多少个线程就有多少个这么个空间。上图的区域的大小并不代表实际内存区域的大小，实际运行过程中，内存区域的大小也是可以动态调整的。下面来具体说说每一个区域的主要功能。 程序计数器，我们在写代码的过程中，开发工具一般都会给我们标注行号方便查看和阅读代码。那么在程序在运行过程中也有一个类似的行号方便虚拟机的执行，就是程序计数器，在c语言中，我们知道会有一个goto语句，其实就是跳转到了指定的行，这个行号就是程序计数器。存储的就是程序下一条所执行的指令。这部分区域是线程所独享的区域，我们知道线程是一个顺序执行流，每个线程都有自己的执行顺序，如果所有线程共用一个程序计数器，那么程序执行肯定就会出乱子。为了保证每个线程的执行顺序，所以程序计数器是被单个线程所独显的。程序计数器这块内存区域是唯一一个在jvm规范中没有规定内存溢出的。 java虚拟机栈，java虚拟机栈是程序运行的动态区域，每个方法的执行都伴随着栈帧的入栈和出栈。 栈帧也叫过程活动记录，是编译器用来实现过程/函数调用的一种数据结构。栈帧中包括了局部变量表，操作数栈，方法返回地址以及额外的一些附加信息，在编译过程中，局部变量表的大小已经确定，操作数栈深度也已经确定，因此栈帧在运行的过程中需要分配多大的内存是固定的，不受运行时影响。对于没有逃逸的对象也会在栈上分配内存，对象的大小其实在运行时也是确定的，因此即使出现了栈上内存分配，也不会导致栈帧改变大小。 一个线程中，可能调用链会很长，很多方法都同时处于执行状态。对于执行引擎来讲，活动线程中，只有栈顶的栈帧是最有效的，称为当前栈帧，这个栈帧所关联的方法称为当前方法。执行引擎所运行的字节码指令仅对当前栈帧进行操作。Ft5rk58GfiJxcdcCzGeAt8fjkFPkMRdf 局部变量表：我们平时所说的栈内存一般就是指栈内存中的局部变量表。这里主要是存储变量所用。对于基本数据类型直接存储其值，对于引用数据类型则存储其地址。局部变量表的最小存储单位是Slot，每个Slot都能存放一个boolean、byte、char、short、int、float、reference或returnAddress类型的数据。 既然前面提到了数据类型，在此顺便说一下，一个Slot可以存放一个32位以内的数据类型，Java中占用32位以内的数据类型有boolean、byte、char、short、int、float、reference和returnAddress八种类型。前面六种不需要多解释，大家都认识，而后面的reference是对象的引用。虚拟机规范既没有说明它的长度，也没有明确指出这个引用应有怎样的结构，但是一般来说，虚拟机实现至少都应当能从此引用中直接或间接地查找到对象在Java堆中的起始地址索引和方法区中的对象类型数据。而returnAddress是为字节码指令jsr、jsr_w和ret服务的，它指向了一条字节码指令的地址。 对于64位的数据类型，虚拟机会以高位在前的方式为其分配两个连续的Slot空间。Java语言中明确规定的64位的数据类型只有long和double两种（reference类型则可能是32位也可能是64位）。值得一提的是，这里把long和double数据类型读写分割为两次32读写的做法类似。不过，由于局部变量表建立在线程的堆栈上，是线程私有的数据，无论读写两个连续的Slot是否是原子操作，都不会引起数据安全问题。 操作数栈是一个后入先出（Last In First Out, LIFO）栈。同局部变量表一样，操作数栈的最大深度也在编译的时候被写入到字节码文件中，关于字节码文件，后面我会具体的来描述。操作数栈的每一个元素可以是任意的Java数据类型，包括long和double。32位数据类型所占的栈容量为1，64位数据类型所占的栈容量为2。在方法执行的任何时候，操作数栈的深度都不会超过在max_stacks数据项中设定的最大值。 当一个方法刚刚开始执行的时候，这个方法的操作数栈是空的，在方法的执行过程中，会有各种字节码指令向操作数栈中写入和提取内容，也就是入栈出栈操作。例如，在做算术运算的时候是通过操作数栈来进行的，又或者在调用其他方法的时候是通过操作数栈来进行参数传递的。 举个例子，整数加法的字节码指令iadd在运行的时候要求操作数栈中最接近栈顶的两个元素已经存入了两个int型的数值，当执行这个指令时，会将这两个int值和并相加，然后将相加的结果入栈。 操作数栈中元素的数据类型必须与字节码指令的序列严格匹配，在编译程序代码的时候，编译器要严格保证这一点，在类校验阶段的数据流分析中还要再次验证这一点。再以上面的iadd指令为例，这个指令用于整型数加法，它在执行时，最接近栈顶的两个元素的数据类型必须为int型，不能出现一个long和一个float使用iadd命令相加的情况。 本地方法栈 与虚拟机栈所发挥的作用是非常相似的，其区别不过是虚拟机栈为虚拟机执行Java方法（也就是字节码）服务，而本地方法栈则是为虚拟机使用到的Native方法服务。虚拟机规范中对本地方法栈中的方法使用的语言、使用方式与数据结构并没有强制规定，因此具体的虚拟机可以自由实现它。甚至有的虚拟机（譬如Sun HotSpot虚拟机）直接就把本地方法栈和虚拟机栈合二为一。与虚拟机栈一样，本地方法栈区域也会抛出StackOverflowError和OutOfMemoryError异常。 方法区经常会被人称之为永久代，但这俩并不是一个概念。首先永久代的概念仅仅在HotSpot虚拟机中存在，不幸的是，在jdk8中，Hotspot去掉了永久代这一说法，使用了Native Memory，也就是Metaspace空间。那么方法区是干嘛的呢？我们可以这么理解，我们要运行Java代码，首先需要编译，然后才能运行。在运行的过程中，我们知道首先需要加载字节码文件。也就是说要把字节码文件加载到内存中。好了，问题就来了，字节码文件放到内存中的什么地方呢，就是方法区中。当然除了编译后的字节码之外，方法区中还会存放常量，静态变量以及及时编译器编译后的代码等数据。 堆，一般来讲堆内存是Java虚拟机中最大的一块内存区域，同方法区一样，是被所有线程所共享的区域。此区域所存在的唯一目的就存放对象的实例（对象实例并不一定全部在堆中创建）。堆内存是垃圾收集器主要光顾的区域，一般来讲根据使用的垃圾收集器的不同，堆中还会划分为一些区域，比如新生代和老年代。新生代还可以再划分为Eden，Survivor等区域。另外为了性能和安全性的角度，在堆中还会为线程划分单独的区域，称之为线程分配缓冲区。更细致的划分是为了让垃圾收集器能够更高效的工作，提高垃圾收集的效率。 如果想要了解更多的关于虚拟机的内容，可以观看录制的<深入理解Java虚拟机>这套视频教程。

首先，我们先来聊聊各类数据模型。下列相关信息参考自Emil Eifrem的博文及NoSQL数据库说明。文档类数据库传承:受Lotus Notes启发而来。数据模型:文档汇总，包括键-值汇总。实例: CouchDB, MongoDB优势: 数据建模自然、程序员易于上手、开发流程短、兼容网页模式、便于达成CRUD（即添加、查询、更新及删除的简称）。图形类数据库传承:来自 Euler 及图形理论。数据模型:节点及关系，二者结合能够保持键-值间的成对状态实例: AllegroGraph, InfoGrid, Neo4j优势:轻松玩转复杂的图形问题、处理速度快关系类数据库传承:源自 E. F. Codd在大型共享数据库中所提出的数据关系模型理论数据模型:以关系组为基础实例: VoltDB, Clustrix, MySQL优势:性能强大、联机事务处理系统扩展性好、支持SQL访问、视图直观、擅长处理交易关系、与程序员间的交互效果优异面向对象类数据库传承:源自图形数据库方面的研究成果数据模型: 对象实例: Objectivity, Gemstone优势:擅长处理复杂的对象模型、快速的键-值访问及键-功能访问并且兼具图形数据库的各类功能键-值存储传承: Amazon Dynamo中的paper概念及分布式hash表数据模型:对成对键-值的全局化汇总实例: Membase, Riak优势:尺寸掌控得当、擅长处理持续的小规模读写需求、速度快、程序员易于上手BigTable Clones传承自:谷歌BigTable中的paper概念数据模型:纵列群，即在某个表格模型中，每行在理论上至少可以有一套单独的纵列配置实例: HBase, Hypertable, Cassandra优势:尺寸掌控得当、擅长应对大规模写入负载、可用性高、支持多数据中心、支持映射简化数据结构类服务传承: 不明实例: Redis数据模型: 执行过程基于索引、列表、集合及字符串值优势:为数据库应用引入前所未有的新鲜血液网格类数据库传承:源自数据网格及元组空间研究数据模型:基于空间的构架实例: GigaSpaces, Coherence优势:优良的性能表现及上佳的交易处理扩展性我们该为自己的应用程序选择哪套方案？选择的关键在于重新思考我们的应用程序如何依据不同数据模型及不同产品进行有针对性的协同工作。即用正确的数据模型处理对应的现实任务、用正确的产品解决对应的现实问题。要探究哪类数据模型能够切实为我们的应用程序提供帮助，可以参考“到底NoSQL能在我们的工作中发挥什么作用？”一文。在这篇文章中，我试着将各种不同特性、不同功能的常用创建系统中的那些非常规的应用实例综合起来。将应用实例中的客观需求与我们的选择联系起来。这样大家就能够逆向分析出我们的基础架构中适合引入哪些产品。至于具体结论是NoSQL还是SQL，这已经不重要了。关注数据模型、产品特性以及自身需要。产品总是将各种不同的功能集中起来，因此我们很难单纯从某一类数据模型构成方式的角度直接找到最合用的那款。对功能及特性的需求存在优先级，只要对这种优先级具备较为清晰的了解，我们就能够做出最佳选择。如果我们的应用程序需要…复杂的交易：因为没人愿意承受数据丢失，或者大家更倾向于一套简单易用的交易编程模式，那么请考虑使用关系类或网格类数据库。例如:一套库存系统可能需要完整的ACID（即数据库事务执行四要素：原子性、一致性、隔离性及持久性）。顾客选中了一件产品却被告知没有库存了，这类情况显然容易引起麻烦。因为大多数时候，我们想要的并不是额外补偿、而只是选中的那件货品。若是以扩展性为优先，那么NoSQL或SQL都能应对自如。这种情况下我们需要关注那些支持向外扩展、分类处理、实时添加及移除设备、负载平衡、自动分类及整理并且容错率较高的系统。要求持续保有数据库写入功能，则需要较高的可用性。在这种情况下不妨关注BigTable类产品，其在一致性方面表现出众。如有大量的小规模持续读写要求，也就是说工作负载处于波动状态，可以关注文档类、键-值类或是那些提供快速内存访问功能的数据库。引入固态硬盘作为存储媒介也是不错的选择。以社交网络为实施重点的话，我们首先想到的就是图形类数据库；其次则是Riak这种关系类数据库。具备简单SQL功能的常驻内存式关系数据库基本上就可以满足小型数据集合的需求。Redis的集合及列表操作也能发挥作用。如果我们的应用程序需要…在访问模式及数据类型多种多样的情况下，文档类数据库比较值得考虑。这类数据库不仅灵活性好，性能表现也可圈可点。需要完备的脱机报告与大型数据集的话，首选产品是Hadoop，其次则是支持映射简化的其它产品。不过仅仅支持映射简化还不足以提供如Hadoop一样上佳的处理能力。如果业务跨越数个数据中心，Bigtable Clone及其它提供分布式选项的产品能够应对由地域距离引起的延迟现象，并具备较好的分区兼容性。要建立CRUD应用程序，首选文档类数据库。这类产品简化了从外部访问复杂数据的过程。需要内置搜索功能的话，推荐Riak。要对数据结构中的诸如列表、集合、队列及发布/订阅信息进行操作，Redis是不二之选。其具备的分布式锁定、覆盖式日志及其它各种功能都会在这类应用状态下大放异彩。将数据以便于处理的形式反馈给程序员（例如以JSON、HTTP、REST、Javascript这类形式），文档类数据库能够满足这类诉求，键-值类数据库效果次之。如果我们的应用程序需要…以直观视图的形式进行同步交易，并且具备实时数据反馈功能，VoltDB算得上一把好手。其数据汇总以及时间窗口化的表现都非常抢眼。若是需要企业级的支持及服务水平协议，我们需要着眼于特殊市场。Membase就是这样一个例子。要记录持续的数据流，却找不到必要的一致性保障？BigTable Clone交出了令人满意的答卷，因为其工作基于分布式文件系统，所以可以应对大量的写入操作。要让操作过程变得尽可能简单，答案一定在托管或平台即服务类方案之中。它们存在的目的正是处理这类要求。要向企业级客户做出推荐？不妨考虑关系类数据库，因为它们的长项就是具备解决繁杂关系问题的技术。如果需要利用动态方式建立对象之间的关系以使其具有动态特性，图形类数据库能帮上大忙。这类产品往往不需要特定的模式及模型，因此可以通过编程逐步建立。S3这类存储服务则是为支持大型媒体信息而生。相比之下NoSQL系统则往往无法处理大型二进制数据块，尽管MongoDB本身具备文件服务功能。如果我们的应用程序需要…有高效批量上传大量数据的需求？我们还是得找点有对应功能的产品。大多数产品都无法胜任，因为它们不支持批量操作。文档类数据库或是键－值类数据库能够利用流畅的模式化系统提供便捷的上传途径，因为这两类产品不仅支持可选区域、添加区域及删除区域，而且无需建立完整的模式迁移框架。要实现完整性限制，就得选择一款支持SQL DLL的产品，并在存储过程或是应用程序代码中加以运行。对于协同工作极为依赖的时候就要选择图形类数据库，因为这类产品支持在不同实体间的迅速切换。数据的移动距离较短且不必经过网络时，可以在预存程序中做出选择。预存程序在关系类、网格类、文档类甚至是键-值类数据库中都能找到。如果我们的应用程序需要…键-值存储体系擅长处理BLOB类数据的缓存及存储问题。缓存可以用于应对网页或复杂对象的存储，这种方案能够降低延迟、并且比起使用关系类数据库来说成本也较低。对于数据安全及工作状态要求较高的话可以尝试使用定制产品，并且在普遍的工作范畴（例如向上扩展、调整、分布式缓存、分区及反规范化等等）之外一定要为扩展性（或其它方面）准备解决方案。多样化的数据类型意味着我们的数据不能简单用表格来管理或是用纵列来划分，其复杂的结构及用户组成（也可能还有其它各种因素）只有文档类、键-值类以及Bigtable Clone这些数据库才能应付。上述各类数据库都具备极为灵活的数据类型处理能力。有时其它业务部门会需要进行快速关系查询，引入这种查询方式可以使我们不必为了偶尔的查看而重建一切信息。任何支持SQL的数据库都能实现这类查询。至于在云平台上运行并自动充分利用云平台的功能——这种美好的愿望目前还只能是愿望。如果我们的应用程序需要…支持辅助索引，以便通过不同的关键词查找数据，这要由关系类数据库及Cassandra推出的新辅助索引系统共同支持才能实现。创建一套处于不断增长中的数据集合（真正天文数量级的数据）然而访问量却并不大，那么Bigtable Clone是最佳选择，因为它会将数据妥善安排在分布式文件系统当中。需要整合其它类型的服务并确保数据库提供延后写入同步功能？那最好的实现方式是捕捉数据库的各种变化并将其反馈到其它系统中以保障运作的一致性。通过容错性检查了解系统对供电中断、隔离及其它故障情况的适应程度。若是当前的某项技术尚无人问津、自己却感觉大有潜力可挖，不妨在这条路上坚持走下去。这种情况有时会带来意料之外的美好前景。尝试在移动平台上工作并关注CouchDB及移动版couchbase。哪种方案更好？25%的状态改善尚不足以让我们下决心选择NoSQL。选择标准是否恰当取决于实际情况。这类标准对你的方案有指导意义吗？如果你的公司尚处于起步阶段，并且需要尽快推出自己的产品，这时不要再犹豫不决了。无论是SQL还是NoSQL都可以作为参考。

一、基础篇 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、软实力 说说你的优缺点、亮点 说说你最近在看什么书、什么博客、在研究什么新技术、再看那些开源项目的源代码 说说你觉得最有意义的技术书籍 工作之余做什么事情、平时是如何学习的，怎样提升自己的能力 说说个人发展方向方面的思考 说说你认为的服务端开发工程师应该具备哪些能力 说说你认为的架构师是什么样的，架构师主要做什么 如何看待加班的问题

final 　　在java中，final可以用来修饰类，方法和变量（成员变量或局部变量）。下面将对其详细介绍。 1.1 修饰类 　　当用final修饰类的时，表明该类不能被其他类所继承。当我们需要让一个类永远不被继承，此时就可以用final修饰，但要注意： final类中所有的成员方法都会隐式的定义为final方法。 1.2 修饰方法 使用final方法的原因主要有两个： 　　(1) 把方法锁定，以防止继承类对其进行更改。 　　(2) 效率，在早期的java版本中，会将final方法转为内嵌调用。但若方法过于庞大，可能在性能上不会有多大提升。因此在最近版本中，不需要final方法进行这些优化了。 final方法意味着“最后的、最终的”含义，即此方法不能被重写。 注意：若父类中final方法的访问权限为private，将导致子类中不能直接继承该方法，因此，此时可以在子类中定义相同方法名的函数，此时不会与重写final的矛盾，而是在子类中重新地定义了新方法。复制代码 class A{ private final void getName(){ } } public class B extends A{ public void getName(){ } public static void main(String[]args){ System.out.println("OK"); } } 复制代码 　　 1.3 修饰变量 　　final成员变量表示常量，只能被赋值一次，赋值后其值不再改变。类似于C++中的const。 　　当final修饰一个基本数据类型时，表示该基本数据类型的值一旦在初始化后便不能发生变化；如果final修饰一个引用类型时，则在对其初始化之后便不能再让其指向其他对象了，但该引用所指向的对象的内容是可以发生变化的。本质上是一回事，因为引用的值是一个地址，final要求值，即地址的值不发生变化。　 　　final修饰一个成员变量（属性），必须要显示初始化。这里有两种初始化方式，一种是在变量声明的时候初始化；第二种方法是在声明变量的时候不赋初值，但是要在这个变量所在的类的所有的构造函数中对这个变量赋初值。 　　当函数的参数类型声明为final时，说明该参数是只读型的。即你可以读取使用该参数，但是无法改变该参数的值。 　　　 　　在java中，String被设计成final类，那为什么平时使用时，String的值可以被改变呢？ 　　字符串常量池是java堆内存中一个特殊的存储区域，当我们建立一个String对象时，假设常量池不存在该字符串，则创建一个，若存在则直接引用已经存在的字符串。当我们对String对象值改变的时候，例如 String a="A"; a="B" 。a是String对象的一个引用（我们这里所说的String对象其实是指字符串常量），当a=“B”执行时，并不是原本String对象("A")发生改变，而是创建一个新的对象("B")，令a引用它。 finally 　　finally作为异常处理的一部分，它只能用在try/catch语句中，并且附带一个语句块，表示这段语句最终一定会被执行（不管有没有抛出异常），经常被用在需要释放资源的情况下。（×）（这句话其实存在一定的问题） 　　很多人都认为finally语句块一定会执行，但真的是这样么？答案是否定的，例如下面这个例子： 　　 　　当我们去掉注释的三行语句，执行结果为： 　　 　　为什么在以上两种情况下都没有执行finally语句呢，说明什么问题？ 　　只有与finally对应的try语句块得到执行的情况下，finally语句块才会执行。以上两种情况在执行try语句块之前已经返回或抛出异常，所以try对应的finally语句并没有执行。 　　但是，在某些情况下，即使try语句执行了，finally语句也不一定执行。例如以下情况： 　　 　　finally 语句块还是没有执行，为什么呢？因为我们在 try 语句块中执行了 System.exit (0) 语句，终止了 Java 虚拟机的运行。那有人说了，在一般的 Java 应用中基本上是不会调用这个 System.exit(0) 方法的。OK ！没有问题，我们不调用 System.exit(0) 这个方法，那么 finally 语句块就一定会执行吗？ 　　再一次让大家失望了，答案还是否定的。当一个线程在执行 try 语句块或者 catch 语句块时被打断（interrupted）或者被终止（killed），与其相对应的 finally 语句块可能不会执行。还有更极端的情况，就是在线程运行 try 语句块或者 catch 语句块时，突然死机或者断电，finally 语句块肯定不会执行了。可能有人认为死机、断电这些理由有些强词夺理，没有关系，我们只是为了说明这个问题。 易错点 　　在try-catch-finally语句中执行return语句。我们看如下代码： 　　 　　答案：4,4,4 。 为什么呢？ 　　首先finally语句在改代码中一定会执行，从运行结果来看，每次return的结果都是4（即finally语句），仿佛其他return语句被屏蔽掉了。 　　事实也确实如此，因为finally用法特殊，所以会撤销之前的return语句，继续执行最后的finally块中的代码。 　　 finalize　　 　　finalize()是在java.lang.Object里定义的，也就是说每一个对象都有这么个方法。这个方法在gc启动，该对象被回收的时候被调用。其实gc可以回收大部分的对象（凡是new出来的对象，gc都能搞定，一般情况下我们又不会用new以外的方式去创建对象），所以一般是不需要程序员去实现finalize的。 特殊情况下，需要程序员实现finalize，当对象被回收的时候释放一些资源，比如：一个socket链接，在对象初始化时创建，整个生命周期内有效，那么就需要实现finalize，关闭这个链接。 　　使用finalize还需要注意一个事，调用super.finalize(); 　　一个对象的finalize()方法只会被调用一次，而且finalize()被调用不意味着gc会立即回收该对象，所以有可能调用finalize()后，该对象又不需要被回收了，然后到了真正要被回收的时候，因为前面调用过一次，所以不会调用finalize()，产生问题。 所以，推荐不要使用finalize()方法，它跟析构函数不一样。

第一种OutOfMemoryError： PermGen space发生这种问题的原意是程序中使用了大量的jar或class，使java虚拟机装载类的空间不够，与Permanent Generation space有关。解决这类问题有以下两种办法：增加java虚拟机中的XX:PermSize和XX:MaxPermSize参数的大小，其中XX:PermSize是初始永久保存区域大小，XX:MaxPermSize是最大永久保存区域大小。如针对tomcat6.0，在catalina.sh 或catalina.bat文件中一系列环境变量名说明结束处（大约在70行左右） 增加一行： JAVA_OPTS=" -XX:PermSize=64M -XX:MaxPermSize=128m" 如果是windows服务器还可以在系统环境变量中设置。感觉用tomcat发布sprint+struts+hibernate架构的程序时很容易发生这种内存溢出错误。使用上述方法，我成功解决了部署ssh项目的tomcat服务器经常宕机的问题。清理应用程序中web-inf/lib下的jar，如果tomcat部署了多个应用，很多应用都使用了相同的jar，可以将共同的jar移到tomcat共同的lib下，减少类的重复加载。这种方法是网上部分人推荐的，我没试过，但感觉减少不了太大的空间，最靠谱的还是第一种方法。第二种OutOfMemoryError： Java heap space发生这种问题的原因是java虚拟机创建的对象太多，在进行垃圾回收之间，虚拟机分配的到堆内存空间已经用满了，与Heap space有关。解决这类问题有两种思路：检查程序，看是否有死循环或不必要地重复创建大量对象。找到原因后，修改程序和算法。 我以前写一个使用K-Means文本聚类算法对几万条文本记录（每条记录的特征向量大约10来个）进行文本聚类时，由于程序细节上有问题，就导致了Java heap space的内存溢出问题，后来通过修改程序得到了解决。增加Java虚拟机中Xms（初始堆大小）和Xmx（最大堆大小）参数的大小。如：set JAVA_OPTS= -Xms256m -Xmx1024m第三种OutOfMemoryError：unable to create new native thread在java应用中，有时候会出现这样的错误：OutOfMemoryError: unable to create new native thread.这种怪事是因为JVM已经被系统分配了大量的内存(比如1.5G)，并且它至少要占用可用内存的一半。有人发现，在线程个数很多的情况下，你分配给JVM的内存越多，那么，上述错误发生的可能性就越大。那么是什么原因造成这种问题呢？每一个32位的进程最多可以使用2G的可用内存，因为另外2G被操作系统保留。这里假设使用1.5G给JVM，那么还余下500M可用内存。这500M内存中的一部分必须用于系统dll的加载，那么真正剩下的也许只有400M，现在关键的地方出现了：当你使用Java创建一个线程，在JVM的内存里也会创建一个Thread对象，但是同时也会在操作系统里创建一个真正的物理线程(参考JVM规范)，操作系统会在余下的400兆内存里创建这个物理线程，而不是在JVM的1500M的内存堆里创建。在jdk1.4里头，默认的栈大小是256KB，但是在jdk1.5里头，默认的栈大小为1M每线程，因此，在余下400M的可用内存里边我们最多也只能创建400个可用线程。这样结论就出来了，要想创建更多的线程，你必须减少分配给JVM的最大内存。还有一种做法是让JVM宿主在你的JNI代码里边。给出一个有关能够创建线程的最大个数的估算公式：(MaxProcessMemory - JVMMemory - ReservedOsMemory) / (ThreadStackSize) = Number of threads对于jdk1.5而言，假设操作系统保留120M内存：1.5GB JVM: (2GB-1.5Gb-120MB)/(1MB) = ~380 threads1.0GB JVM: (2GB-1.0Gb-120MB)/(1MB) = ~880 threads对于栈大小为256KB的jdk1.4而言，1.5GB allocated to JVM: ~1520 threads1.0GB allocated to JVM: ~3520 threads 对于这个异常我们首先需要判断下，发生内存溢出时进程中到底都有什么样的线程，这些线程是否是应该存在的，是否可以通过优化来降低线程数； 另外一方面默认情况下java为每个线程分配的栈内存大小是1M，通常情况下，这1M的栈内存空间是足足够用了，因为在通常在栈上存放的只是基础类型的数据或者对象的引用，这些东西都不会占据太大的内存， 我们可以通过调整jvm参数，降低为每个线程分配的栈内存大小来解决问题，例如在jvm参数中添加-Xss128k将线程栈内存大小设置为128k。

在这个信息时代高速发展的情况下，很多人会对自己该往哪个方向发展感到迷茫，下面我就浅显的给大家介绍一下五大流行区域的发展前景。大数据的发展前景：当前大数据行业真的是人才稀缺吗?学了几年后，大数据行业会不会产能过剩?大数据行业最终需要什么样的人才?接下来就带你们看看分析结果：当前大数据行业真的是人才稀缺吗?对!未来人才缺口150万，数据分析人才最稀缺。先看大数据人才缺口有多大?根据LinkedIn(领英)发布的《2016年中国互联网最热职位人才报告》显示，研发工程师、产品经理、人力资源、市场营销、运营和数据分析是当下中国互联网行业需求最旺盛的六类人才职位。其中数据分析人才最为稀缺、供给指数最低。同时，数据分析人才跳槽速度也最快，平均跳槽速度为19.8个月。而清华大学计算机系教授武永卫去年透露了一组数据：未来3-5年，中国需要180万数据人才，但目前只有约30万人。大数据行业未来会产能过剩吗?提供大数据技术与应用服务的第三方公司面临调整，未来发展会趋集中关于“大数据概念是否被过度炒作”的讨论，其实2013年的夏季达沃斯就有过。彼时支持“炒作”观点的现场观众达54.5%。对此，持反对意见的北京大学光华管理学院副教授苏萌提出了三个理由：不同机构间的数据还未真正流动起来，目前还只是数据“孤岛”;完整的生态产业链还未形成，尽管通过行为数据分析已能够分辨出一个消费者的喜好，但从供应到购买的链条还没建成;数据分析人才仍然极度匮乏。4年之后，舆论热点已经逐渐从大数据转向人工智能，大数据行业也历经整合。近一年间，一些大数据公司相继出现裁员、业务大调整等情况，部分公司出现亏损。那都是什么公司面临危机呢?基于数据归属，涉及大数据业务的公司其实有两类：一类是自身拥有数据的甲方公司，如亚马逊、阿里巴巴等;另一类是整合数据资源，提供大数据技术与应用服务的第三方公司。目前行业整合出现盈利问题的公司多集中在第三方服务商。对此，LinkedIn(领英)中国技术副总裁王迪表示，第三方服务商提供的更多的是技术或平台，大数据更多还是让甲方公司获益。在王迪看来，大数据业务要产生规模效益，至少要具备三点：算法、计算平台以及数据本身。“第三方大数据创业公司在算法上有一技之长，而计算能力实际上已经匀化了，传统企业如果用好了，和大数据创业公司没有区别，甚至计算能力更强，而数据获取方面，很多数据在传统行业内部并没有共享出来，第三方大数据公司获取这些数据是比较困难的，最后可能谁有数据，谁产生的价值更高。”说白了，数据为王。在2013年，拿到千万级A轮融资的大数据企业不足10家，到2015年，拿到千万级以上A轮融资的企业已经超过30家。直到2016年互联网资本寒冬，大数据行业投资热度有所减退，大数据行业是否也存在产能过剩?王迪认为，目前的行业整合属于正常现象，“经过市场的优胜劣汰，第三方服务领域会出现一些做得比较好的公司，其他公司可能被淘汰或转型做一些垂直行业应用。从社会来看，总的需求量一定是增加的，而对于供给侧，经过行业自然的洗牌，最终会集中在几家优秀的行业公司。”需要什么样的大数据人才?今年3月份，教育部公布了第二批获准开设“数据科学与大数据技术”的高校名单，加上第一批获批的北京大学、对外经济贸易大学、中南大学，一共35所高校获批该专业。今年开始，部分院校将招收第一届大数据专业本科生。大数据人才培养涉及到两方面问题：交叉性学科的人才培养方案是否与市场需求相匹配;学科建设的周期与行业快速更新之间的差距怎样弥合。对于第一个问题，“电商热”时期开设的电子商务专业是一个可吸取经验的样本。2000年，教育部高教司批准了第一批高校开设电子商务本科专业。作为一个复合型专业，电子商务的本科教学涵盖了管理、技术、营销三方面的课程。电子商务领域人才需求量大，但企业却无法从电子商务专业中找到合适的人才，原因何在?职业规划专家姜萌认为，并不是某一个专业对应一个行业热点，而是一个专业集群对应一个行业热点。“比如电子商务专业，我们到电子商务公司里会发现，不是学电子商务的人在做这些工作，而是每个专业各司其职，比如计算机、设计、物流管理、营销、广告、金融等等。现在行业的复合型工作都是由一个专业集群来完成的，而不是一个人来复合一堆专业特点。”大数据专业的人才培养也同样走复合型路线，复旦大学大数据学院的招生简章显示，学院本科人才培养以统计学、计算机科学和数学为三大基础支撑性学科，以生物学、医学、环境科学、经济学、社会学、管理学等为应用拓展性学科，具备典型的交叉学科特征。LinkedIn(领英)中国技术副总裁王迪指出，“从企业应用的角度来看，大数据行业里从事相关职能的同学背景是各异的，大数据作为一个人才培养方向还在探索中，在这个阶段，高校尝试开设硕士课程是很好的实践，但开设一类的本科专业还为时过早。”另一方面，专业人才培养的周期较长，而行业热点不断更新轮替，中间产生的时间差使得新兴专业的志愿填报具备了一定风险。王迪认为，“从今天的产业实践上看，大数据领域依然是从现有专业中挑选人才，教育和市场发展总是有一定差距的，学生本科四年，加上硕士阶段已经是七年之后的事情了，产业已经演进了很多，而教学大纲并不会跟进得那么快。”因此，尽管大数据的应用前景毋庸置疑，但在人才培养层面，复合型人才培养方案会不会重走电子商务专业的老路?学校教育如何赶上行业发展速度?这些都是值得进一步商榷的问题。面对热门专业，志愿填报需要注意啥?了解了大数据行业、公司和大数据专业后，姜萌对于考生填报像大数据相关的热门专业，提出了几条建议：报考热的专业和就业热的专业并不一定是重合的，比如软件、计算机、金融，这些专业的就业率实际并没有那么高，地质勘探、石油、遥感等专业，虽然报考上是冷门，但行业需求大，就业率更高。选择热门专业，更需要考虑就业质量。专业就业好，是统计学意义，指的是平均收入水平高，比如金融专业的收入，比其他纯文科专业的平均收入较高，但落实到个体层面，就业情况就不一样了，尤其像金融专业是典型的名校高学历好就业，但对于考试成绩较低的同学来说，如果去一些普通院校、专科院校学习金融，最后就业情况可能还不如会计专业。志愿填报，除了专业，城市因素也很重要：如果想从事金融、互联网的工作，更适合去一线城市，如果是去三、四线城市的学生可以考虑应用面比较广的专业，就是各行各业都能用到的专业，比如会计专业，专科层次的会计和985层次的会计都有就业渠道。如果先选择报考城市，也可以针对所在城市的行业特点选择专业，比如沿海城市外贸相对发达，选择国际贸易、外语类专业就业情况更好，比如武汉有光谷，选择光电类专业更好就业。最终家长和考生更需要考虑个人与专业匹配的问题，金融、计算机等热门专业不是所有人都适合学，好专业不见得对所有个体都是好的。java的发展前景：由于Java的诸多优点，Java的发展前景十分广泛。比如，在我们中国的市场，Java无论在企业级应用，还是在面向大众的服务方面都取得了不少进展，在中国的电信、金融等关键性业务中发挥着举足轻重的作用。由于SUN、TBM、Oracle等国际厂商相继推出各种基于Java技术的应用服务器以及各种应用软件，推动了Java在金融、电信、制造等领域日益广泛的应用，如清华大学计算机系利用Java、XML和Web技术研制开发了多个软件平台，东方科技的TongWeb、中创的Inforweb等J2EE应用服务器。由此可见，在巨大市场需求下，企业对于Java人才的渴求已经是不争的事实。你问我火了这么多年的Java语言的发展前景怎么样？那来看看吧Java在WEB、移动设备以及云计算方面前景广阔，随着云计算以及移动领域的扩张，更多的企业在考虑将其应用部署在Java平台上。无论是本地主机，公共云，Java都是目前最适合的选择。;另外在Oracle的技术投资担保下，Java也是企业在云应用方面回避微软平台、在移动应用方面回避苹果公司的一个最佳选择。Java可以参与制作大部分网络应用程序系统，而且与如今流行的WWW浏览器结合很好，这一优点将促进Java的更大范围的推广。因为在未来的社会，信息将会传送的更加快速，这将推动程序向WEB程序方向发展，由于Java具有编写WEB程序的能力，并且Java与浏览器结合良好，这将使得Java前景充满光明的发展。Python的发展前景：Python程序员的发展前景是怎样的？随着Python的技术的流行， Python在为人们带来工作与生活上的便捷后，关注者们开始慢慢关心Python的发展前景与方向。从自身特性看Python发展Python自身强大的优势决定其不可限量的发展前景。Python作为一种通用语言，几乎可以用在任何领域和场合，角色几乎是无限的。Python具有简单、易学、免费、开源、可移植、可扩展、可嵌入、面向对象等优点，它的面向对象甚至比java和C#、.net更彻底。它是一种很灵活的语言，能帮你轻松完成编程工作。强大的类库支持，使编写文件处理、正则表达式，网络连接等程序变得相当容易。能运行在多种计算机平台和操作系统中，如各位unix，windows，MacOS,OS/2等等，并可作为一种原型开发语言，加快大型程序的开发速度。从企业应用来看Python发展Python被广泛的用在Web开发、运维自动化、测试自动化、数据挖掘等多个行业和领域。一项专业调查显示，75%的受访者将Python视为他们的主要开发语言，反之，其他25%受访者则将其视为辅助开发语言。将Python作为主要开发语言的开发者数量逐年递增，这表明Python正在成为越来越多开发者的开发语言选择。目前，国内不少大企业都已经使用Python如豆瓣、搜狐、金山、腾讯、盛大、网易、百度、阿里、淘宝、热酷、土豆、新浪、果壳等;国外的谷歌、NASA、YouTube、Facebook、工业光魔、红帽等都在应用Python完成各种各样的任务。从市场需求与薪资看Python发展Python得到越来越多公司的青睐，使得Python人才需求逐年增加，从市场整体需求来看，Python在招聘市场上的流行程度也是在逐步上升的，工资水平也是水涨船高。据统计Python平均薪资水平在12K，随着经验的提升，薪资也是逐年增长。学习Python的程序员，除去Python开发工程师、Python高级工程师、Python自动化测试外，也能够朝着Python游戏开发工程师、SEO工程师、Linux运维工程师等方向发展，发展方向较为多元化。随着Python的流行，带动的是它的普及以及市场需求量，所以现在学习Python是个不错的时机。区块链的发展前景：区块链开发 ? 155---0116---2665 ?可是区块链技术到底是什么，大多数人都是模糊没有概念。通俗来讲，如果我们把数据库假设成一本账本，读写数据库就可以看做一种记账的行为，区块链技术的原理就是在一段时间内找出记账最快最好的人，由这个人来记账，然后将账本的这一页信息发给整个系统里的其他所有人。区块链技术也称分布式账本（或账簿）技术，属于互联网数据库技术，由参与者共同完成数据库记录，特点是去中心化和公开透明。此外，在每个区块的信息写入并获得认可后，整个区块链数据库完整保存在互联网的节点中，难以被修改，因此数据库的安全性极高。人们普遍认为，区块链技术是实现数字产品（如货币和知识产权）快速、安全和透明地对等（P2P）转账或转让的重要手段。在以色列Zen Protocol公司，区块链应用软件开发专家阿希尔·曼宁介绍说，他们公司正在开发Zen区块链平台，其将用于支持金融产品在无中介的环境下自动和自由交易。通常，人们将钱存放在银行，依靠银行管理自己的资金。但是，在支配资金时往往会受到银行规定的限制，或在汇款时存在耗时长、费用高等问题。区块链技术平台将让人们首次拥有自己管理和支配钱财的能力，他相信去中心化金融管理体系具有广阔的市场，有望极大地改变传统的金融市场。2018年伊始这一轮区块链的热潮，主要起源于虚拟货币的炒作热情。站在风口，区块链技术被认为是继蒸汽机、电力、互联网之后，下一代颠覆性的核心技术。很多人不禁要问“区块链又和比特币又是什么关系？”记者查询了大量资料发现，比特币2009年被一位名叫中本聪的人提出，之后比特币这套去中心化的机制一直稳定运行，这引起很多人对这套历史上并不存在的运行机制强烈关注。于是人们把从比特币技术抽象提取出来的技术运用于其他领域，称之为区块链。这过程就好像人们先发明了面条，然后人们发现其背后面粉不仅可以做面条还可以做馒头、面包。比特币是面条，区块链是面粉。也就是说，区块链和比特币的关系即比特币算是区块链技术的一种应用，或者说一种使用了区块链技术的产品形态。而说到区块链不得不说的就是ICO，它是一种公开发行的初始数字货币。对于投资人来说，出于对市场信号的敏感和长期关注价值投资项目，目前炙手可热的区块链也成为诸多投资人关注的新兴项目之一。“区块链对于我们来说就是省去了中间环节，节约了交易成本，节省了交易时间，但是目前来看各方面环境还不够成熟，有待观望。”一位投资人这样说道。记者发现，在春节期间，不少互金圈的朋友熬夜到凌晨进入某个探讨区块链的微信群热聊，此群还吸引了不少知名人士，诸如明星加入，同时还有大咖在群里解读区块链的投资方式和未来发展等等。一时间，关于区块链的讨论群接二连三出现，也引发了各个行业对区块链的关注。出于对于区块链技术懵懂的状态，记者追问了身边的一些互金圈的朋友，为何如此痴迷区块链？多数朋友认为“区块链能赚钱，抱着试试看的心态，或许能像之前比特币一样从中获取收益。”显然，区块链技术具有广阔的应用潜力，但是在其逐步进入社会改善民众生活的过程中，也面临许多的问题，需要积极去寻求相应的对策，最终让其发挥出潜力。只有这样，10年或20年后人们才能真正享受区块链技术创造的美好环境。人工智能的发展前景：人工智能产业是智能产业发展的核心，是其他智能科技产品发展的基础，国内外的高科技公司以及风险投资机构纷纷布局人工智能产业链。科技部部长万钢3月10日表示，加快实施新一代人工智能科学基础的关键技术系统集成研发，使那些研发成果尽快能够进入到开放平台，在开放使用中再一次把它增强完善。万钢称，马上就要发布人工智能项目指南和细则，来突破基础前沿理论关键部分的技术。人工智能发展趋势据前瞻产业研究院《人工智能行业市场前瞻与投资战略规划分析报告》指出，2017年中国人工智能核心产业规模超过700亿元，随着国家规划的出台，各地人工智能相关建设将逐步启动，预计到2020年，中国人工智能核心产业规模将超过1600亿元，增长率达到26.2%。报告认为，从产业投资回报率分析，智能安防、智能驾驶等领域的快速发展都将刺激计算机视觉分析类产品的需求，使得计算机视觉领域具备投资价值；而随着中国软件集成水平和人们生活水平的提高，提供教育、医疗、娱乐等专业化服务的服务机器人和智能无人设备具备投资价值。人工智能现状当前，人工智能受到的关注度持续提升，大量的社会资本和智力、数据资源的汇集驱动人工智能技术研究不断向前推进。从发展层次来看，人工智能技术可分为计算智能、感知智能和认知智能。当前，计算智能和感知智能的关键技术已经取得较大突破，弱人工智能应用条件基本成熟。但是，认知智能的算法尚未突破，前景仍不明朗。今年，随着智力资源的不断汇集，人工智能核心技术的研究重点可能将从深度学习转为认知计算，即推动弱人工智能向强人工智能不断迈进。一方面，在人工智能核心技术方面，在百度等大型科技公司和北京大学、清华大学等重点院校的共同推动下，以实现强人工智能为目标的类脑智能有望率先突破。另一方面，在人工智能支撑技术方面，量子计算、类脑芯片等核心技术正处在从科学实验向产业化应用的转变期，以数据资源汇集为主要方向的物联网技术将更加成熟，这些技术的突破都将有力推动人工智能核心技术的不断演进。工业大数据2022 年我国工业大数据有望突破 1200 亿元， 复合增速 42%。 工业大数据是提升制造智能化水平，推动中国制造业转型升级的关键动力，具体包括企业信息化数据、工业物联网数据，以及外部跨界数据。其中，企业信息化和工业物联网中机器产生的海量时序数据是工业数据的主要来源。工业大数据不仅可以优化现有业务，实现提质增效，而且还有望推动企业业务定位和盈利模式发生重大改变，向个性化定制、智能化生产、网络化协同、服务化延伸等智能化场景转型。预计到 2022 年，中国工业大数据市场规模有望突破 1200亿元，年复合增速 42%。IT的未来是人工智能这是一个指数级增长的时代。过去几十年，信息技术的进步相当程度上归功于芯片上晶体管数目的指数级增加，及由此带来的计算力的极大提升。这就是所谓的摩尔定律。在互联网时代，互联的终端数也是超线性的增长，而网络的效力大致与联网终端数的平方成正比。今天，大数据时代产生的数据正在呈指数级增加。在指数级增长的时代，我们可能会高估技术的短期效应，而低估技术的长期效应。历史的经验告诉我们，技术的影响力可能会远远的超过我们的想象。未来的计算能力人工智能需要强大的计算能力。计算机的性能过去30年提高了一百万倍。随着摩尔定律逐渐趋于物理极限，未来几年，我们期待一些新的技术突破。先谈一下类脑计算。传统计算机系统，长于逻辑运算，不擅长模式识别与形象思维。构建模仿人脑的类脑计算机芯片，我们今天可以以极低的功耗，模拟100万个神经元，2亿5千万个神经突触。未来几年，我们会看到类脑计算机的进一步的发展与应用随着互联网的普及、传感器的泛在、大数据的涌现、电子商务的发展、信息社区的兴起，数据和知识在人类社会、物理空间和信息空间之间交叉融合、相互作用，人工智能发展所处信息环境和数据基础发展了巨大的变化。伴随着科学基础和实现载体取得新的突破，类脑计算、深度学习、强化学习等一系列的技术萌芽预示着内在动力的成长，人工智能的发展已进入一个新的阶段。发展发展前景好，代表你现在学习会比后来者起步快，占有更大的优势，当然，你也要明白兴趣是最好的老师，选择自己感兴趣的相信你学的会更加而牢固。记住，最重要的一点：方向最重要！！！希望大家多多关注. ，加微信zhanglindashuju 可以获取更多资料哦作者：失色的瞳孔链接：https://juejin.im/post/5b1a6531e51d45067e6fc24a来源：掘金著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

大数据是指无法在一定时间内用常规软件工具对其内容进行抓取、管理和处理的数据集合。大数据技术，是指从各种各样类型的数据中，快速获得有价值信息的能力。适用于大数据的技术，包括大规模并行处理（MPP）数据库，数据挖掘电网，分布式文件系统，分布式数据库，云计算平台，互联网，和可扩展的存储系统。 　　大数据有四个基本特征：一、数据体量巨大（Vomule），二、数据类型多样（Variety），三、处理速度快（Velocity），四、价值密度低（Value）。 　　在大数据的领域现在已经出现了非常多的新技术，这些新技术将会是大数据收集、存储、处理和呈现最强有力的工具。大数据处理一般有以下几种关键性技术：大数据采集、大数据预处理、大数据存储及管理、大数据分析及挖掘、大数据展现和应用（大数据检索、大数据可视化、大数据应用、大数据安全等）。 　　大数据处理之一：采集。大数据的采集是指利用多个数据库来接收发自客户端（Web、App或者传感器形式等）的数据，并且用户可以通过这些数据库来进行简单的查询和处理工作。比如，电商会使用传统的关系型数据库MySQL和Oracle等来存储每一笔事务数据，除此之外，Redis和MongoDB这样的NoSQL数据库也常用于数据的采集。 　　在大数据的采集过程中，其主要特点和挑战是并发数高，因为同时有可能会有成千上万的用户来进行访问和操作，比如火车票售票网站和淘宝，它们并发的访问量在峰值时达到上百万，所以需要在采集端部署大量数据库才能支撑。并且如何在这些数据库之间进行负载均衡和分片的确是需要深入的思考和设计。 　　大数据处理之二：导入和预处理。虽然采集端本身会有很多数据库，但是如果要对这些海量数据进行有效的分析，还是应该将这些来自前端的数据导入到一个集中的大型分布式数据库，或者分布式存储集群，并且可以在导入基础上做一些简单的清洗和预处理工作。也有一些用户会在导入时使用来自Twitter的Storm来对数据进行流式计算，来满足部分业务的实时计算需求。 　　导入与预处理过程的特点和挑战主要是导入的数据量大，每秒钟的导入量经常会达到百兆，甚至千兆级别。 　　大数据处理之三：统计和分析。统计与分析主要利用分布式数据库，或者分布式计算集群来对存储于其内的海量数据进行普通的分析和分类汇总等，以满足大多数常见的分析需求，在这方面，一些实时性需求会用到EMC的GreenPlum、Oracle的Exadata，以及基于MySQL的列式存储Infobright等，而一些批处理，或者基于半结构化数据的需求可以使用Hadoop。 　　统计与分析这部分的主要特点和挑战是分析涉及的数据量大，其对系统资源，特别是I/O会有极大的占用。 　　大数据处理之四：挖掘。与前面统计和分析过程不同的是，数据挖掘一般没有什么预先设定好的主题，主要是在现有数据上面进行基于各种算法的计算，从而起到预测（Predict）的效果，从而实现一些高级别数据分析的需求。比较典型算法有用于聚类的Kmeans、用于统计学习的SVM和用于分类的NaiveBayes，主要使用的工具有Hadoop的Mahout等。该过程的特点和挑战主要是用于挖掘的算法很复杂，并且计算涉及的数据量和计算量都很大，常用数据挖掘算法都以单线程为主。 　　整个大数据处理的普遍流程至少应该满足这四个方面的步骤，才能算得上是一个比较完整的大数据处理。 　　大数据的处理方式大致分为数据流处理方式和批量数据处理方式两种。数据流处理的方式适合用于对实时性要求比较高的场合中。并不需要等待所有的数据都有了之后再进行处理，而是有一点数据就处理一点，更多地要求机器的处理器有较快速的性能以及拥有比较大的主存储器容量，对辅助存储器的要求反而不高。批量数据处理方式是对整个要处理的数据进行切割划分成小的数据块，之后对其进行处理。重点在于把大化小——把划分的小块数据形成小任务，分别单独进行处理，并且形成小任务的过程中不是进行数据传输之后计算，而是将计算方法（通常是计算函数——映射并简化）作用到这些数据块最终得到结果。 　　当前，对大数据的处理分析正成为新一代信息技术融合应用的节点。移动互联网、物联网、社交网络、数字家庭、电子商务等是新一代信息技术的应用形态，这些应用不断产生大数据。通过对不同来源数据的管理、处理、分析与优化，将结果反馈到上述应用中，将创造出巨大的经济和社会价值。大数据也是信息产业持续高速增长的新引擎。面对大数据市场的新技术、新产品、新业态会不断涌现。在硬件与集成设备领域，大数据将对芯片、存储产业产生重要影响，还将催生一体化数据存储处理服务器、内存计算等市场。在软件与服务领域，大数据将引发数据快速处理分析、数据挖掘技术和软件产品的发展。大数据利用将成为提高核心竞争力的关键因素。各行各业的决策正在从“业务驱动”转变为“数据驱动”。对大数据的分析可以使零售商实时掌握市场动态并迅速做出应对；可以为商家制定更加精准有效的营销策略提供决策支持；可以帮助企业为消费者提供更加及时和个性化的服务；在医疗领域，可提高诊断准确性和药物有效性；在公共事业领域，大数据也开始发挥促进经济发展、维护社会稳定等方面的重要作用。大数据时代科学研究的方法手段将发生重大改变。例如，抽样调查是社会科学的基本研究方法。在大数据时代，可通过实时监测，跟踪研究对象在互联网上产生的海量行为数据，进行挖掘分析，揭示出规律性的东西，提出研究结论和对策。 　　目前大数据在医疗卫生领域有广为所知的应用，公共卫生部门可以通过覆盖全国的患者电子病历数据库进行全面疫情监测。5千万条美国人最频繁检索的词条被用来对冬季流感进行更及时准确的预测。学术界整合出2003年H5N1禽流感感染风险地图，研究发行此次H7N9人类病例区域。社交网络为许多慢性病患者提供了临床症状交流和诊治经验分享平台，医生借此可获得院外临床效果统计数据。基于对人体基因的大数据分析，可以实现对症下药的个性化治疗。 　　在医药研发方面，大数据的战略意义在于对各方面医疗卫生数据进行专业化处理，对患者甚至大众的行为和情绪的细节化测量成为可能，挖掘其症状特点、行为习惯和喜好等，找到更符合其特点或症状的药品和服务，并针对性的调整和优化。在医药研究开发部门或公司的新药研发阶段，能够通过大数据技术分析来自互联网上的公众疾病药品需求趋势，确定更为有效率的投入产品比，合理配置有限研发资源。除研发成本外，医药公司能够优化物流信息平台及管理，更快地获取回报，一般新药从研发到推向市场的时间大约为13年，使用数据分析预测则能帮助医药研发部门或企业提早将新药推向市场。 　　在疾病诊治方面，可通过健康云平台对每个居民进行智能采集健康数据，居民可以随时查阅，了解自身健康程度。同时，提供专业的在线专家咨询系统，由专家对居民健康程度做出诊断，提醒可能发生的健康问题，避免高危病人转为慢性病患者，避免慢性病患者病情恶化，减轻个人和医保负担，实现疾病科学管理。对于医疗卫生机构，通过对远程监控系统产生数据的分析，医院可以减少病人住院时间，减少急诊量，实现提高家庭护理比例和门诊医生预约量的目标。武汉协和医院目前也已经与市区八家社区卫生服务中心建立远程遥控联系，并将在未来提供“从医院到家”的服务。在医疗卫生机构，通过实时处理管理系统产生的数据，连同历史数据，利用大数据技术分析就诊资源的使用情况，实现机构科学管理，提高医疗卫生服务水平和效率，引导医疗卫生资源科学规划和配置。大数据还能提升医疗价值，形成个性化医疗，比如基于基因科学的医疗模式。 　　在公共卫生管理方面，大数据可以连续整合和分析公共卫生数据，提高疾病预报和预警能力，防止疫情爆发。公共卫生部门则可以通过覆盖区域的卫生综合管理信息平台和居民信息数据库，快速监测传染病，进行全面疫情监测，并通过集成疾病监测和响应程序，进行快速响应，这些都将减少医疗索赔支出、降低传染病感染率。通过提供准确和及时的公众健康咨询，将会大幅提高公众健康风险意识，同时也将降低传染病感染风险。 　　在居民健康管理方面，居民电子健康档案是大数据在居民健康管理方面的重要数据基础，大数据技术可以促进个体化健康事务管理服务，改变现代营养学和信息化管理技术的模式，更全面深入地从社会、心理、环境、营养、运动的角度来对每个人进行全面的健康保障服务，帮助、指导人们成功有效地维护自身健康。另外，大数据可以对患者健康信息集成整合，在线远程为诊断和治疗提供更好的数据证据，通过挖掘数据对居民健康进行智能化监测，通过移动设备定位数据对居民健康影响因素进行分析等等，进一步提升居民健康管理水平。 　　在健康危险因素分析方面，互联网、物联网、医疗卫生信息系统及相关信息系统等普遍使用，可以系统全面地收集健康危险因素数据，包括环境因素（利用GIS系统采集大气、土壤、水文等数据），生物因素（包括致病性微生物、细菌、病毒、真菌等的监测数据），经济社会因素（分析经济收入、营养条件、人口迁徙、城镇化、教育就业等因素数据），个人行为和心理因素，医疗卫生服务因素，以及人类生物遗传因素等，利用大数据技术对健康危险因素进行比对关联分析，针对不同区域、人群进行评估和遴选健康相关危险因素及制作健康监测评估图谱和知识库也成为可能，提出居民健康干预的有限领域和有针对性的干预计划，促进居民健康水平的提高。 答案来源于网络

1.内存泄漏：基础 对于初学者来说，将内存泄漏视为一种疾病，将Java的OutOfMemoryError（简称OOM）视为一种症状。但与任何疾病一样，并非所有OOM都意味着内存泄漏：由于生成大量局部变量或其他此类事件，OOM可能会发生。另一方面，并非所有内存泄漏都必然表现为OOM，特别是在桌面应用程序或客户端应用程序（没有重新启动时运行很长时间）的情况下。 将内存泄漏视为疾病，将OutOfMemoryError视为症状。但并非所有OutOfMemoryErrors都意味着内存泄漏，并非所有内存泄漏都表现为OutOfMemoryErrors。 为什么这些泄漏如此糟糕？除此之外，程序执行期间泄漏的内存块通常会降低系统性能，因为分配但未使用的内存块必须在系统耗尽空闲物理内存时进行换出。最终，程序甚至可能耗尽其可用的虚拟地址空间，从而导致OOM。 2.解密OutOfMemoryError 如上所述，OOM是内存泄漏的常见指示。实质上，当没有足够的空间来分配新对象时，会抛出错误。当垃圾收集器找不到必要的空间，并且堆不能进一步扩展，会多次尝试。因此，会出现错误以及堆栈跟踪。 诊断OOM的第一步是确定错误的实际含义。这听起来很清除，但答案并不总是那么清晰。例如：OOM是否是因为Java堆已满而出现，还是因为本机堆已满？为了帮助您回答这个问题，让我们分析一些可能的错误消息： java.lang.OutOfMemoryError: Java heap space java.lang.OutOfMemoryError: PermGen space java.lang.OutOfMemoryError: Requested array size exceeds VM limit java.lang.OutOfMemoryError: request bytes for . Out of swap space? java.lang.OutOfMemoryError: (Native method) 2.1.“Java heap space” 此错误消息不一定意味着内存泄漏。实际上，问题可能与配置问题一样简单。 例如，我负责分析一直产生这种类型的OutOfMemoryError的应用程序。经过一番调查后，我发现罪魁祸首是阵列实例化，因为需要太多的内存;在这种情况下，并不是应用程序的错，而是应用程序服务器依赖于默认的堆太小了。我通过调整JVM的内存参数解决了这个问题。 在其他情况下，特别是对于长期存在的应用程序，该消息可能表明我们无意中持有对象的引用，从而阻止垃圾收集器清理它们。这时Java语言等同于内存泄漏。 （注意：应用程序调用的API也可能无意中持有对象引用。） 这些“Java堆空间”OOM的另一个潜在来源是使用finalizers。如果类具有finalize方法，则在垃圾收集时该类型的对象不会被回收。而是在垃圾收集之后，稍后对象将排队等待最终确定。在Sun实现中，finalizers由守护线程执行。如果finalizers线程无法跟上finalization队列，那么Java堆可能会填满并且可能抛出OOM。 2.2.“PermGen space” 此错误消息表明永久代已满。永久代是存储类和方法对象的堆的区域。如果应用程序加载了大量类，则可能需要使用-XX：MaxPermSize选项增加永久代的大小。 Interned java.lang.String对象也存储在永久代中。 java.lang.String类维护一个字符串池。调用实习方法时，该方法检查池以查看是否存在等效字符串。如果是这样，它由实习方法返回;如果没有，则将字符串添加到池中。更准确地说，java.lang.String.intern方法返回一个字符串的规范表示;结果是对该字符串显示为文字时将返回的同一个类实例的引用。如果应用程序实例化大量字符串，则可能需要增加永久代的大小。 注意：您可以使用jmap -permgen命令打印与永久生成相关的统计信息，包括有关内部化String实例的信息。 2.3.“Requested array size exceeds VM limit” 此错误表示应用程序（或该应用程序使用的API）尝试分配大于堆大小的数组。例如，如果应用程序尝试分配512MB的数组但最大堆大小为256MB，则将抛出此错误消息的OOM。在大多数情况下，问题是配置问题或应用程序尝试分配海量数组时导致的错误。 2.4.“Request bytes for . Out of swap space?” 此消息似乎是一个OOM。但是，当本机堆的分配失败并且本机堆可能将被耗尽时，HotSpot VM会抛出此异常。消息中包括失败请求的大小（以字节为单位）以及内存请求的原因。在大多数情况下，是报告分配失败的源模块的名称。 如果抛出此类型的OOM，则可能需要在操作系统上使用故障排除实用程序来进一步诊断问题。在某些情况下，问题甚至可能与应用程序无关。例如，您可能会在以下情况下看到此错误： 操作系统配置的交换空间不足。 系统上的另一个进程是消耗所有可用的内存资源。 由于本机泄漏，应用程序也可能失败（例如，如果某些应用程序或库代码不断分配内存但无法将其释放到操作系统）。 2.5. (Native method) 如果您看到此错误消息并且堆栈跟踪的顶部框架是本机方法，则该本机方法遇到分配失败。此消息与上一个消息之间的区别在于，在JNI或本机方法中检测到Java内存分配失败，而不是在Java VM代码中检测到。 如果抛出此类型的OOM，您可能需要在操作系统上使用实用程序来进一步诊断问题。 2.6.Application Crash Without OOM 有时，应用程序可能会在从本机堆分配失败后很快崩溃。如果您运行的本机代码不检查内存分配函数返回的错误，则会发生这种情况。 例如，如果没有可用内存，malloc系统调用将返回NULL。如果未检查malloc的返回，则应用程序在尝试访问无效的内存位置时可能会崩溃。根据具体情况，可能很难定位此类问题。 在某些情况下，致命错误日志或崩溃转储的信息就足以诊断问题。如果确定崩溃的原因是某些内存分配中缺少错误处理，那么您必须找到所述分配失败的原因。与任何其他本机堆问题一样，系统可能配置了但交换空间不足，另一个进程可能正在消耗所有可用内存资源等。 3.泄漏诊断 在大多数情况下，诊断内存泄漏需要非常详细地了解相关应用程序。警告：该过程可能很长并且是迭代的。 我们寻找内存泄漏的策略将相对简单： 识别症状 启用详细垃圾回收 启用分析 分析踪迹 3.1 识别症状 正如所讨论的，在许多情况下，Java进程最终会抛出一个OOM运行时异常，这是一个明确的指示，表明您的内存资源已经耗尽。在这种情况下，您需要区分正常的内存耗尽和泄漏。分析OOM的消息并尝试根据上面提供的讨论找到罪魁祸首。 通常，如果Java应用程序请求的存储空间超过运行时堆提供的存储空间，则可能是由于设计不佳导致的。例如，如果应用程序创建映像的多个副本或将文件加载到数组中，则当映像或文件非常大时，它将耗尽存储空间。这是正常的资源耗尽。该应用程序按设计工作（虽然这种设计显然是愚蠢的）。 但是，如果应用程序在处理相同类型的数据时稳定地增加其内存利用率，则可能会发生内存泄漏。 3.2 启用详细垃圾收集 断言确实存在内存泄漏的最快方法之一是启用详细垃圾回收。通常可以通过检查verbosegc输出中的模式来识别内存约束问题。 具体来说，-verbosegc参数允许您在每次垃圾收集（GC）过程开始时生成跟踪。也就是说，当内存被垃圾收集时，摘要报告会打印到标准错误，让您了解内存的管理方式。 这是使用-verbosegc选项生成的一些典型输出： image 此GC跟踪文件中的每个块（或节）按递增顺序编号。要理解这种跟踪，您应该查看连续的分配失败节，并查找随着时间的推移而减少的释放内存（字节和百分比），同时总内存（此处，19725304）正在增加。这些是内存耗尽的典型迹象。 3.3 启用分析 不同的JVM提供了生成跟踪文件以反映堆活动的不同方法，这些方法通常包括有关对象类型和大小的详细信息。这称为分析堆。 3.4 分析路径 本文重点介绍Java VisualVM生成的跟踪。跟踪可以有不同的格式，因为它们可以由不同的Java内存泄漏检测工具生成，但它们背后的想法总是相同的：在堆中找到不应该存在的对象块，并确定这些对象是否累积而不是释放。特别感兴趣的是每次在Java应用程序中触发某个事件时已知的临时对象。应该仅存少量，但存在许多对象实例，通常表示应用程序出现错误。 最后，解决内存泄漏需要您彻底检查代码。了解对象泄漏的类型可能对此非常有用，并且可以大大加快调试速度。 4.垃圾收集如何在JVM中运行？ 在我们开始分析具有内存泄漏问题的应用程序之前，让我们首先看看垃圾收集在JVM中的工作原理。 JVM使用一种称为跟踪收集器的垃圾收集器，它基本上通过暂停它周围的世界来操作，标记所有根对象（由运行线程直接引用的对象），并遵循它们的引用，标记它沿途看到的每个对象。 Java基于分代假设-实现了一种称为分代垃圾收集器的东西，该假设表明创建的大多数对象被快速丢弃，而未快速收集的对象可能会存在一段时间。 基于此假设，[Java将对象分为多代](www.oracle.com/technetwork…. Generations|outline)。这是一个视觉解释： image Young Generation -这是对象的开始。它有两个子代 Eden Space -对象从这里开始。大多数物体都是在Eden Space中创造和销毁的。在这里，GC执行Minor GCs，这是优化的垃圾收集。执行Minor GC时，对仍然需要的对象的任何引用都将迁移到其中一个survivors空间（S0或S1）。 Survivor Space (S0 and S1)-幸存Eden Space的对象最终来到这里。其中有两个，在任何给定时间只有一个正在使用（除非我们有严重的内存泄漏）。一个被指定为空，另一个被指定为活动，与每个GC循环交替。 Tenured Generation -也被称为老年代（图2中的旧空间），这个空间容纳存活较长的对象，使用寿命更长（如果它们活得足够长，则从Survivor空间移过来）。填充此空间时，GC会执行完整GC，这会在性能方面降低成本。如果此空间无限制地增长，则JVM将抛出OutOfMemoryError - Java堆空间。 Permanent Generation -作为与终身代密切相关的第三代，永久代是特殊的，因为它保存虚拟机所需的数据，以描述在Java语言级别上没有等价的对象。例如，描述类和方法的对象存储在永久代中。 Java足够聪明，可以为每一代应用不同的垃圾收集方法。使用名为Parallel New Collector的跟踪复制收集器处理年轻代。这个收集器阻止了这个世界，但由于年轻一代通常很小，所以暂停很短暂。 有关JVM代及其工作原理的更多信息，请查阅Memory Management in the Java HotSpot™ Virtual Machine 。 5 检测内存泄漏 要查找内存泄漏并消除它们，您需要合适的内存泄漏工具。是时候使用Java VisualVM检测并删除此类泄漏。 5.1 使用Java VisualVM远程分析堆 VisualVM是一种工具，它提供了一个可视化界面，用于查看有关基于Java技术的应用程序运行时的详细信息。 使用VisualVM，您可以查看与本地应用程序和远程主机上运行的应用程序相关的数据。您还可以捕获有关JVM软件实例的数据，并将数据保存到本地系统。 为了从Java VisualVM的所有功能中受益，您应该运行Java平台标准版（Java SE）版本6或更高版本。 Related: Why You Need to Upgrade to Java 8 Already 5.2. 为JVM启用远程连接 在生产环境中，通常很难访问运行代码的实际机器。幸运的是，我们可以远程分析我们的Java应用程序。 首先，我们需要在目标机器上授予自己JVM访问权限。为此，请使用以下内容创建名为jstatd.all.policy的文件： grant codebase "file:${java.home}/../lib/tools.jar" { permission java.security.AllPermission;

请参考个人博客：https://blog.csdn.net/u010870518/article/details/79450295 在进一步分析为什么MySQL数据库索引选择使用B+树之前，我相信很多小伙伴对数据结构中的树还是有些许模糊的，因此我们由浅入深一步步探讨树的演进过程，在一步步引出B树以及为什么MySQL数据库索引选择使用B+树！ 学过数据结构的一般对最基础的树都有所认识，因此我们就从与我们主题更为相近的二叉查找树开始。 一、二叉查找树 （1）二叉树简介： 二叉查找树也称为有序二叉查找树，满足二叉查找树的一般性质，是指一棵空树具有如下性质： 1、任意节点左子树不为空,则左子树的值均小于根节点的值； 2、任意节点右子树不为空,则右子树的值均大于于根节点的值； 3、任意节点的左右子树也分别是二叉查找树； 4、没有键值相等的节点； 上图为一个普通的二叉查找树，按照中序遍历的方式可以从小到大的顺序排序输出：2、3、5、6、7、8。 对上述二叉树进行查找，如查键值为5的记录，先找到根，其键值是6，6大于5，因此查找6的左子树，找到3；而5大于3，再找其右子树；一共找了3次。如果按2、3、5、6、7、8的顺序来找同样需求3次。用同样的方法在查找键值为8的这个记录，这次用了3次查找，而顺序查找需要6次。计算平均查找次数得：顺序查找的平均查找次数为（1+2+3+4+5+6）/ 6 = 3.3次，二叉查找树的平均查找次数为（3+3+3+2+2+1）/6=2.3次。二叉查找树的平均查找速度比顺序查找来得更快。 （2）局限性及应用 一个二叉查找树是由n个节点随机构成，所以，对于某些情况，二叉查找树会退化成一个有n个节点的线性链。如下图： 大家看上图，如果我们的根节点选择是最小或者最大的数，那么二叉查找树就完全退化成了线性结构。上图中的平均查找次数为（1+2+3+4+5+5）/6=3.16次，和顺序查找差不多。显然这个二叉树的查询效率就很低，因此若想最大性能的构造一个二叉查找树，需要这个二叉树是平衡的（这里的平衡从一个显著的特点可以看出这一棵树的高度比上一个输的高度要大，在相同节点的情况下也就是不平衡），从而引出了一个新的定义-平衡二叉树AVL。 二、AVL树 （1）简介 AVL树是带有平衡条件的二叉查找树，一般是用平衡因子差值判断是否平衡并通过旋转来实现平衡，左右子树树高不超过1，和红黑树相比，它是严格的平衡二叉树，平衡条件必须满足（所有节点的左右子树高度差不超过1）。不管我们是执行插入还是删除操作，只要不满足上面的条件，就要通过旋转来保持平衡，而旋转是非常耗时的，由此我们可以知道AVL树适合用于插入删除次数比较少，但查找多的情况。 从上面是一个普通的平衡二叉树，这张图我们可以看出，任意节点的左右子树的平衡因子差值都不会大于1。 （2）局限性 由于维护这种高度平衡所付出的代价比从中获得的效率收益还大，故而实际的应用不多，更多的地方是用追求局部而不是非常严格整体平衡的红黑树。当然，如果应用场景中对插入删除不频繁，只是对查找要求较高，那么AVL还是较优于红黑树。 （3）应用 1、Windows NT内核中广泛存在； 三、红黑树 （1）简介 一种二叉查找树，但在每个节点增加一个存储位表示节点的颜色，可以是red或black。通过对任何一条从根到叶子的路径上各个节点着色的方式的限制，红黑树确保没有一条路径会比其它路径长出两倍。它是一种弱平衡二叉树(由于是若平衡，可以推出，相同的节点情况下，AVL树的高度低于红黑树)，相对于要求严格的AVL树来说，它的旋转次数变少，所以对于搜索、插入、删除操作多的情况下，我们就用红黑树。 （2）性质 1、每个节点非红即黑； 2、根节点是黑的； 3、每个叶节点(叶节点即树尾端NULL指针或NULL节点)都是黑的； 4、如果一个节点是红的,那么它的两儿子都是黑的； 5、对于任意节点而言，其到叶子点树NULL指针的每条路径都包含相同数目的黑节点； 6、每条路径都包含相同的黑节点； （3）应用 1、广泛用于C++的STL中，Map和Set都是用红黑树实现的； 2、著名的Linux进程调度Completely Fair Scheduler，用红黑树管理进程控制块，进程的虚拟内存区域都存储在一颗红黑树上，每个虚拟地址区域都对应红黑树的一个节点，左指针指向相邻的地址虚拟存储区域，右指针指向相邻的高地址虚拟地址空间； 3、IO多路复用epoll的实现采用红黑树组织管理sockfd，以支持快速的增删改查； 4、Nginx中用红黑树管理timer，因为红黑树是有序的，可以很快的得到距离当前最小的定时器； 5、Java中TreeMap的实现； 四、B/B+树 说了上述的三种树：二叉查找树、AVL和红黑树，似乎我们还没有摸到MySQL为什么要使用B+树作为索引的实现，不要急，接下来我们就先探讨一下什么是B树。 （1）简介 我们在MySQL中的数据一般是放在磁盘中的，读取数据的时候肯定会有访问磁盘的操作，磁盘中有两个机械运动的部分，分别是盘片旋转和磁臂移动。盘片旋转就是我们市面上所提到的多少转每分钟，而磁盘移动则是在盘片旋转到指定位置以后，移动磁臂后开始进行数据的读写。那么这就存在一个定位到磁盘中的块的过程，而定位是磁盘的存取中花费时间比较大的一块，毕竟机械运动花费的时候要远远大于电子运动的时间。当大规模数据存储到磁盘中的时候，显然定位是一个非常花费时间的过程，但是我们可以通过B树进行优化，提高磁盘读取时定位的效率。 为什么B类树可以进行优化呢？我们可以根据B类树的特点，构造一个多阶的B类树，然后在尽量多的在结点上存储相关的信息，保证层数尽量的少，以便后面我们可以更快的找到信息，磁盘的I/O操作也少一些，而且B类树是平衡树，每个结点到叶子结点的高度都是相同，这也保证了每个查询是稳定的。 总的来说，B/B+树是为了磁盘或其它存储设备而设计的一种平衡多路查找树(相对于二叉，B树每个内节点有多个分支)，与红黑树相比，在相同的的节点的情况下，一颗B/B+树的高度远远小于红黑树的高度(在下面B/B+树的性能分析中会提到)。B/B+树上操作的时间通常由存取磁盘的时间和CPU计算时间这两部分构成，而CPU的速度非常快，所以B树的操作效率取决于访问磁盘的次数，关键字总数相同的情况下B树的高度越小，磁盘I/O所花的时间越少。 注意B-树就是B树，-只是一个符号。 （2）B树的性质 1、定义任意非叶子结点最多只有M个儿子，且M>2； 2、根结点的儿子数为[2, M]； 3、除根结点以外的非叶子结点的儿子数为[M/2, M]； 4、每个结点存放至少M/2-1（取上整）和至多M-1个关键字；（至少2个关键字） 5、非叶子结点的关键字个数=指向儿子的指针个数-1； 6、非叶子结点的关键字：K[1], K[2], …, K[M-1]；且K[i] < K[i+1]； 7、非叶子结点的指针：P[1], P[2], …, P[M]；其中P[1]指向关键字小于K[1]的子树，P[M]指向关键字大于K[M-1]的子树，其它P[i]指向关键字属于(K[i-1], K[i])的子树； 8、所有叶子结点位于同一层； 这里只是一个简单的B树，在实际中B树节点中关键字很多的，上面的图中比如35节点，35代表一个key(索引)，而小黑块代表的是这个key所指向的内容在内存中实际的存储位置，是一个指针。 五、B+树 （1）简介 B+树是应文件系统所需而产生的一种B树的变形树（文件的目录一级一级索引，只有最底层的叶子节点（文件）保存数据）非叶子节点只保存索引，不保存实际的数据，数据都保存在叶子节点中，这不就是文件系统文件的查找吗? 我们就举个文件查找的例子：有3个文件夹a、b、c， a包含b，b包含c，一个文件yang.c，a、b、c就是索引（存储在非叶子节点）， a、b、c只是要找到的yang.c的key，而实际的数据yang.c存储在叶子节点上。 所有的非叶子节点都可以看成索引部分！ （2）B+树的性质(下面提到的都是和B树不相同的性质) 1、非叶子节点的子树指针与关键字个数相同； 2、非叶子节点的子树指针p[i],指向关键字值属于[k[i],k[i+1]]的子树.(B树是开区间,也就是说B树不允许关键字重复,B+树允许重复)； 3、为所有叶子节点增加一个链指针； 4、所有关键字都在叶子节点出现(稠密索引). (且链表中的关键字恰好是有序的)； 5、非叶子节点相当于是叶子节点的索引(稀疏索引),叶子节点相当于是存储(关键字)数据的数据层； 6、更适合于文件系统； 非叶子节点（比如5，28，65）只是一个key（索引），实际的数据存在叶子节点上（5，8，9）才是真正的数据或指向真实数据的指针。 （3）应用 1、B和B+树主要用在文件系统以及数据库做索引，比如MySQL； 六、B/B+树性能分析 n个节点的平衡二叉树的高度为H(即logn)，而n个节点的B/B+树的高度为logt((n+1)/2)+1； 　 若要作为内存中的查找表，B树却不一定比平衡二叉树好，尤其当m较大时更是如此。因为查找操作CPU的时间在B-树上是O(mlogtn)=O(lgn(m/lgt))，而m/lgt>1；所以m较大时O(mlogtn)比平衡二叉树的操作时间大得多。因此在内存中使用B树必须取较小的m。（通常取最小值m=3，此时B-树中每个内部结点可以有2或3个孩子，这种3阶的B-树称为2-3树）。 七、为什么说B+树比B树更适合数据库索引？ 1、 B+树的磁盘读写代价更低：B+树的内部节点并没有指向关键字具体信息的指针，因此其内部节点相对B树更小，如果把所有同一内部节点的关键字存放在同一盘块中，那么盘块所能容纳的关键字数量也越多，一次性读入内存的需要查找的关键字也就越多，相对IO读写次数就降低了。 2、B+树的查询效率更加稳定：由于非终结点并不是最终指向文件内容的结点，而只是叶子结点中关键字的索引。所以任何关键字的查找必须走一条从根结点到叶子结点的路。所有关键字查询的路径长度相同，导致每一个数据的查询效率相当。 3、由于B+树的数据都存储在叶子结点中，分支结点均为索引，方便扫库，只需要扫一遍叶子结点即可，但是B树因为其分支结点同样存储着数据，我们要找到具体的数据，需要进行一次中序遍历按序来扫，所以B+树更加适合在区间查询的情况，所以通常B+树用于数据库索引。 PS：我在知乎上看到有人是这样说的,我感觉说的也挺有道理的： 他们认为数据库索引采用B+树的主要原因是：B树在提高了IO性能的同时并没有解决元素遍历的我效率低下的问题，正是为了解决这个问题，B+树应用而生。B+树只需要去遍历叶子节点就可以实现整棵树的遍历。而且在数据库中基于范围的查询是非常频繁的，而B树不支持这样的操作或者说效率太低。 ———————————————— 版权声明：本文为CSDN博主「徐刘根」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/u010870518/java/article/details/79450295

怎么 没人来呀 @中山野鬼###### 1、如果想去掉while（true），可以考虑通知实现； 2、关于自动重连的问题，可以考虑重发送逻辑中抽离出来，采用心跳检测完成； 3、另外发送速率统计部分也应该抽离出来。 4、上多通道要考虑资源使用可控。 5、实在不行按照业务拆分成多模块，用redis 或mq类的扩展一下架构设计； ######回复 @OS小小小 : map =(Map)JSONObject.parse(SendMsgCMPP2ThredPoolByDB.ZhangYi.take()); 换成take，阻塞线程，试试。######回复 @OS小小小 : 1、通知只是告知队列里有新的数据需要处理了； 5、内存队列换成redis队列 实现成本增加，但是可扩展性增加；######1、通知实现的话 ，岂不是 无法保证 最少发送么，又会陷入另一个问题中 是吗？ 或者是我的想法不对么？ 2、嗯，这一块可以这样做。谢谢你 3、速率统计这里 我目前想不到怎么抽离、既可以控制到位，又可以保证不影响。。。 5、redis 是有的 但是 redis的队列的话 跟我这个 没啥区别吧，可能速度更快一点。######while(true) 里面 没数据最起码要休眠啊，不停死循环操作，又没有休眠cpu不高才怪######回复 @OS小小小 : 休眠是必须的，只是前面有数据进来，可以用wait notify 的思路通知，思路就是这样，CountDownLatch 之类多线程通讯也可以实现有数据来就能立即处理的功能######嗯，目前在测试 排除没有数据的情况，所以这一块没有去让他休眠，后面会加进去。 就针对于目前这种情况，有啥好办法吗###### 我的思路是：一个主线程，多个任务子线程。 主线程有一层while(true)，这个循环是不断的扫描LinkedBlockingQueue是否有数据，有则交个任务子线程（也就是你这里定义的线程池）处理，而不是像你这样每个子任务线程都有一个while(true) ######这才是对的做法######嗯，这思路可以。谢谢哈###### 引用来自“K袁”的评论 我的思路是：一个主线程，多个任务子线程。 主线程有一层while(true)，这个循环是不断的扫描LinkedBlockingQueue是否有数据，有则交个任务子线程（也就是你这里定义的线程池）处理，而不是像你这样每个子任务线程都有一个while(true) 正确做法. 还有就是 LinkedBlockingQueue 本身阻塞的，while(true)没问题，主要在于不需要每个发送线程都去block######while（true）不加休眠就会这样###### java 的线程数量大致要和cpu数量一致，并不是越多越快，线程调度是很消耗时间的。要用好多线程，就需要设计出好的多线程业务模型，不恰当的sleep和block是性能的噩梦。利用好LinkedBlockingQueue，队列空闲时读队列的线程会释放cpu。利用消息触发后续线程工作，就没必要使用while(true)来不停的扫描。 ######@蓝水晶飞机 看到你要比牛逼，我就没有兴趣跟你说话了######回复 @不日小鸡 : 我就是装逼怎么啦，特么的装逼装出样子来的，起码也比你牛逼啊。######回复 @蓝水晶飞机 : 你说这话不能掩盖你没有回复我的问题又来回复我导致装逼失败的事实。 那你不是楼主你回复我干什么，还不是回答我的问题。 不要装逼了好么，装多就成傻逼了######回复 @不日小鸡 : 此贴楼主不是你，装什么逼。######回复 @王斌_ : 这些我都知道，我的意思是你这样回复可能会误导其他看帖子的人或者新手，让他们以为线程数就等于CPU数###### 引用来自“OS小小小”的评论 怎么 没人来呀 @中山野鬼 抬举我了。c++ 我还敢对不知深浅的人说，“权当我不懂”，java真心只是学过，没有实际工程上的经验。哈。而且我是c的思维，面对c适合的应用开发，是反对使用线程的。基本思维是，执行模块的生命周期不以任务为决定，同类的执行模块，可根据物理硬核数量，形成对应独立多个进程，但绝对不会同类的任务独立对应多个线程。哈。所以java这类面向线程的设计，没办法参与讨论。设计应用目标不同，系统组织策略自然有异。 唯一的建议是：永远不要依赖工具，特别是所谓的垃圾资源处理回收机制，无论它做的再好，一旦你依赖，必然你的代码，在不久的将来会因为系统设计规模的变大，而变的垃圾。哈。 听不懂的随便喷，希望听懂的，能记得这个观点，这不是我一个人的观点。 ######给100万像素做插值运算进行染色特效，请问单线程怎么做比多线程快？###### @乌龟壳 : 几种方法都可以，第一是按照计算步骤，每个进程处理一个步骤，然后切换共享空间（这没有数据传递逻辑上的额外开销），就是流水思维。第二个是block的思维，同样的几个进程负责相同计算，但负责不同片区。同时存在另一类的进程是对前期并发处理完的工作进行边界处理。 你这个例子体现不出进程和线程的差异的。 如果非要考虑进程和线程在片内cache的差异，如果没记错（错了大家纠正哈），进程之间的共享是在二级缓存之间吧。即便线程能做到一级缓存之间的共享，但对于这种大批量像素的计算，用进程仍然是使用 dma，将数据成块载入一级缓存区域进行处理，而这个载入工作和计算工作是同步的。不会有额外太多的延迟。 你举的这个例子，还真好是我以前的老本行。再说了。像素计算，如今都用专用计算处理器了吧。还用x86或arm来处理，不累死啊。哈。 而且这种东西java不适合，同样的处理器，用c写，基本可以比java快1到2倍。因为c可以直接根据硬件特性和计算逻辑特点有效调度底层硬件驱动方式。而java即便你用了底层优化的官方库，仍然不能保证硬件与计算目标特性的高度整合。 ######回复 @中山野鬼 : 简单来说，你的多个进程处理结果进行汇总的时候，是不是要做内存复制操作？如果是多线程天然就不用，多进程用系统的共享内存机制也不用，问题是既然用了共享内存，和多线程就没区别了。######回复 @乌龟壳 : 两回事哦。共享空间是独立的，而线程如果我没记错，全局变量，包括文件内的（静态变量）是共享的。不同线程共享同一个进程内的变量嘛。这些和业务逻辑相关的东西，每个线程又是独立一套业务逻辑，针对c语言，这样去设计，不是没事找事嘛。面向对象语言，这块都帮你处理好了，自然没有关系。######既然有共享空间了，那你所说的进程和线程实际就是一回事了。###### @乌龟壳   ，数据分两种，一种和算法或处理相关的。一种是待处理的数据。 前者，不应该共享，后者属于数据加工流程，必然存在数据传递或流动，最低成本的传递／流动方式就是共享内存，交替使用权限的思路。 但这仅仅针对待加工的数据和辅助信息，而不针对程序本身。 进程不会搞混乱这些东西特别是（待加工数据的辅助信息），而线程，就各种乱吧。哈。 进程之间，虽然用共享空间，但它本质是数据传递／流动，当你采用多机（物理机器）并发处理时，进程移动到另外一个物理主机，则共享空间就是不能选择的传递／流动方式了。但线程就没有这些概念。 ######回复 @中山野鬼 : 是啊，java天然就不是像C一样对汇编的包装。######@乌龟壳 面向企业级的各种业务，java这些没问题的。而且更有优势，面向计算设备特性的设计开发，就不行了。哈。######回复 @中山野鬼 : 也算各有场景吧，java同样可以多进程可以分布式来降低多线程的风险。java也可以静态编译成目标机器码。总之事在人为。######回复 @乌龟壳 : 高手，啥都可以，低手，依赖这些，就是各种想当然。哈哈。######回复 @中山野鬼 : 那针对java的垃圾回收，这个东西是可以调节它算法的，不算依赖工具吧，哈。不然依赖C语言语法也算依赖工具咯。哈。;-p

tl; dr：您可能应该使用一维方法。 注意：在不填充书本的情况下比较动态1d或动态2d存储模式时，无法深入研究影响性能的细节，因为代码的性能取决于很多参数。如有可能，进行配置文件。 1.什么更快？ 对于密集矩阵，一维方法可能更快，因为它提供了更好的内存局部性以及更少的分配和释放开销。 2.较小的是？ 与2D方法相比，Dynamic-1D消耗的内存更少。后者还需要更多分配。 备注 我出于以下几个原因给出了一个很长的答案，但我想首先对您的假设做一些评论。 我可以想象，重新计算1D数组（y + x * n）的索引可能比使用2D数组（x，y）慢 让我们比较这两个函数： int get_2d (int **p, int r, int c) { return p[r][c]; } int get_1d (int *p, int r, int c) { return p[c + C*r]; } Visual Studio 2015 RC为这些功能（启用了优化功能）生成的（非内联）程序集是： ?get_1d@@YAHPAHII@Z PROC push ebp mov ebp, esp mov eax, DWORD PTR _c$[ebp] lea eax, DWORD PTR [eax+edx*4] mov eax, DWORD PTR [ecx+eax*4] pop ebp ret 0 ?get_2d@@YAHPAPAHII@Z PROC push ebp mov ebp, esp mov ecx, DWORD PTR [ecx+edx*4] mov eax, DWORD PTR _c$[ebp] mov eax, DWORD PTR [ecx+eax*4] pop ebp ret 0 区别是mov（2d）与lea（1d）。前者的延迟为3个周期，最大吞吐量为每个周期2个，而后者的延迟为2个周期，最大吞吐量为每个周期3个。（根据指令表-Agner Fog， 由于差异很小，我认为索引重新计算不会产生很大的性能差异。我希望几乎不可能将这种差异本身确定为任何程序的瓶颈。 这将我们带到下一个（也是更有趣的）点： ...但是我可以想象一维可能在CPU缓存中... 是的，但是2d也可能在CPU缓存中。有关为什么1d仍然更好的说明，请参见缺点：内存局部性。 长答案，或者为什么对于简单 /小的矩阵，动态二维数据存储（指针到指针或向量矢量）是“不好的” 。 注意：这是关于动态数组/分配方案[malloc / new / vector等]。静态2D数组是一个连续的内存块，因此不受我将在此处介绍的不利影响。 问题 为了能够理解为什么动态数组的动态数组或向量的矢量最有可能不是选择的数据存储模式，您需要了解此类结构的内存布局。 使用指针语法的示例案例 int main (void) { // allocate memory for 4x4 integers; quick & dirty int ** p = new int*[4]; for (size_t i=0; i<4; ++i) p[i] = new int[4]; // do some stuff here, using p[x][y] // deallocate memory for (size_t i=0; i<4; ++i) delete[] p[i]; delete[] p; } 缺点 内存位置 对于此“矩阵”，您分配一个包含四个指针的块和四个包含四个整数的块。所有分配都不相关，因此可以导致任意存储位置。 下图将使您了解内存的外观。 对于真正的二维情况： 紫色正方形是其p自身占据的存储位置。 绿色方块将存储区域p点组装为（4 x int*）。 4个连续的蓝色方块的4个区域是每个int*绿色区域所指向的区域 对于在1d情况下映射的2d： 绿色方块是唯一需要的指针 int * 蓝色方块组合了所有矩阵元素的存储区域（16 x int）。 实际2D与映射2D内存布局 这意味着（例如，使用左侧布局时）（例如，使用缓存），与连续存储模式（如右侧所示）相比，您可能会发现性能较差。 假设高速缓存行是“一次传输到高速缓存中的数据量”，并想象一个程序一个接一个地访问整个矩阵。 如果您具有正确对齐的32位值的4 4矩阵，则具有64字节高速缓存行（典型值）的处理器能够“一次性”读取数据（4 * 4 * 4 = 64字节）。如果您开始处理而缓存中还没有数据，则将面临缓存未命中，并且将从主内存中获取数据。由于且仅当连续存储（并正确对齐）时，此负载才能装入整个缓存行，因此可以立即读取整个矩阵。处理该数据时可能不会再有任何遗漏。 在动态的“真实二维”系统中，每行/列的位置都不相关，处理器需要分别加载每个内存位置。即使只需要64个字节，在最坏的情况下，为4个不相关的内存位置加载4条高速缓存行实际上会传输256个字节并浪费75％的吞吐量带宽。如果使用2d方案处理数据，您将再次在第一个元素上遇到缓存未命中（如果尚未缓存）。但是现在，从主内存中第一次加载后，只有第一行/列会在缓存中，因为所有其他行都位于内存中的其他位置，并且不与第一行/列相邻。一旦到达新的行/列，就会再次出现高速缓存未命中，并从主内存执行下一次加载。 长话短说：2d模式具有较高的缓存未命中率，而1d方案由于数据的局部性而具有更好的性能潜力。 频繁分配/取消分配 N + 1创建所需的NxM（4×4）矩阵需要多达（4 + 1 = 5）个分配（使用new，malloc，allocator :: allocate或其他方法）。 也必须应用相同数量的适当的各自的重新分配操作。 因此，与单个分配方案相比，创建/复制此类矩阵的成本更高。 随着行数的增加，情况变得更加糟糕。 内存消耗开销 我假设int的大小为32位，指针的大小为32位。（注意：系统依赖性。） 让我们记住：我们要存储一个4×4 int矩阵，表示64个字节。 对于NxM矩阵，使用提出的指针对指针方案存储，我们消耗了 NMsizeof(int) [实际的蓝色数据] + Nsizeof(int) [绿色指针] + sizeof(int**) [紫罗兰色变量p]字节。 444 + 44 + 4 = 84在本示例的情况下，这会使字节变多，使用时甚至会变得更糟std::vector<std::vector >。对于4 x 4 int ，它将需要N * M * sizeof(int)+ N * sizeof(vector )+ sizeof(vector<vector >)字节，即4 44 + 416 + 16 = 144总共字节，共64个字节。 另外-根据所使用的分配器-每个单独的分配可能（并且很可能会）还有16个字节的内存开销。（一些“信息字节”用于存储已分配的字节数，以进行适当的重新分配。） 这意味着最坏的情况是： N*(16+Msizeof(int)) + 16+Nsizeof(int*) + sizeof(int**) = 4*(16+44) + 16+44 + 4 = 164 bytes ! Overhead: 156% 开销的份额将随着矩阵大小的增加而减少，但仍然存在。 内存泄漏的风险 一堆分配需要适当的异常处理，以避免在其中一个分配失败的情况下发生内存泄漏！您需要跟踪分配的内存块，并且在释放内存时一定不要忘记它们。 如果new无法运行内存并且无法分配下一行（特别是在矩阵很大时），std::bad_alloc则抛出a new。 例： 在上面提到的new / delete示例中，如果要避免发生bad_alloc异常时的泄漏，我们将面临更多代码。 // allocate memory for 4x4 integers; quick & dirty size_t const N = 4; // we don't need try for this allocation // if it fails there is no leak int ** p = new int*[N]; size_t allocs(0U); try { // try block doing further allocations for (size_t i=0; i<N; ++i) { p[i] = new int[4]; // allocate ++allocs; // advance counter if no exception occured } } catch (std::bad_alloc & be) { // if an exception occurs we need to free out memory for (size_t i=0; i<allocs; ++i) delete[] p[i]; // free all alloced p[i]s delete[] p; // free p throw; // rethrow bad_alloc } /* do some stuff here, using p[x][y] */ // deallocate memory accoding to the number of allocations for (size_t i=0; i<allocs; ++i) delete[] p[i]; delete[] p; 摘要 在某些情况下，“真实的2d”内存布局适合并且有意义（即，如果每行的列数不是恒定的），但是在最简单和常见的2D数据存储情况下，它们只会使代码的复杂性膨胀，并降低性能和程序的内存效率。 另类 您应该使用连续的内存块，并将行映射到该内存块。 做到这一点的“ C ++方式”可能是编写一个类来管理您的内存，同时考虑诸如 什么是三法则？ 资源获取是什么意思初始化（RAII）？ C ++概念：容器（在cppreference.com上） 例 为了提供这样一个类的外观的想法，下面是一个具有一些基本功能的简单示例： 二维尺寸可构造 2d可调整大小 operator(size_t, size_t) 用于2行主要元素访问 at(size_t, size_t) 用于检查的第二行主要元素访问 满足容器的概念要求 资源： #include #include #include #include namespace matrices { template class simple { public: // misc types using data_type = std::vector ; using value_type = typename std::vector ::value_type; using size_type = typename std::vector ::size_type; // ref using reference = typename std::vector ::reference; using const_reference = typename std::vector ::const_reference; // iter using iterator = typename std::vector ::iterator; using const_iterator = typename std::vector ::const_iterator; // reverse iter using reverse_iterator = typename std::vector ::reverse_iterator; using const_reverse_iterator = typename std::vector ::const_reverse_iterator; // empty construction simple() = default; // default-insert rows*cols values simple(size_type rows, size_type cols) : m_rows(rows), m_cols(cols), m_data(rows*cols) {} // copy initialized matrix rows*cols simple(size_type rows, size_type cols, const_reference val) : m_rows(rows), m_cols(cols), m_data(rows*cols, val) {} // 1d-iterators iterator begin() { return m_data.begin(); } iterator end() { return m_data.end(); } const_iterator begin() const { return m_data.begin(); } const_iterator end() const { return m_data.end(); } const_iterator cbegin() const { return m_data.cbegin(); } const_iterator cend() const { return m_data.cend(); } reverse_iterator rbegin() { return m_data.rbegin(); } reverse_iterator rend() { return m_data.rend(); } const_reverse_iterator rbegin() const { return m_data.rbegin(); } const_reverse_iterator rend() const { return m_data.rend(); } const_reverse_iterator crbegin() const { return m_data.crbegin(); } const_reverse_iterator crend() const { return m_data.crend(); } // element access (row major indexation) reference operator() (size_type const row, size_type const column) { return m_data[m_cols*row + column]; } const_reference operator() (size_type const row, size_type const column) const { return m_data[m_cols*row + column]; } reference at() (size_type const row, size_type const column) { return m_data.at(m_cols*row + column); } const_reference at() (size_type const row, size_type const column) const { return m_data.at(m_cols*row + column); } // resizing void resize(size_type new_rows, size_type new_cols) { // new matrix new_rows times new_cols simple tmp(new_rows, new_cols); // select smaller row and col size auto mc = std::min(m_cols, new_cols); auto mr = std::min(m_rows, new_rows); for (size_type i(0U); i < mr; ++i) { // iterators to begin of rows auto row = begin() + i*m_cols; auto tmp_row = tmp.begin() + i*new_cols; // move mc elements to tmp std::move(row, row + mc, tmp_row); } // move assignment to this *this = std::move(tmp); } // size and capacity size_type size() const { return m_data.size(); } size_type max_size() const { return m_data.max_size(); } bool empty() const { return m_data.empty(); } // dimensionality size_type rows() const { return m_rows; } size_type cols() const { return m_cols; } // data swapping void swap(simple &rhs) { using std::swap; m_data.swap(rhs.m_data); swap(m_rows, rhs.m_rows); swap(m_cols, rhs.m_cols); } private: // content size_type m_rows{ 0u }; size_type m_cols{ 0u }; data_type m_data{}; }; template void swap(simple & lhs, simple & rhs) { lhs.swap(rhs); } template bool operator== (simple const &a, simple const &b) { if (a.rows() != b.rows() || a.cols() != b.cols()) { return false; } return std::equal(a.begin(), a.end(), b.begin(), b.end()); } template bool operator!= (simple const &a, simple const &b) { return !(a == b); } } 请注意以下几点： T需要满足使用的std::vector成员函数的要求 operator() 不执行任何“范围”检查 无需自己管理数据 不需要析构函数，复制构造函数或赋值运算符 因此，您不必费心为每个应用程序进行适当的内存处理，而只需为编写的类一次即可。 限制条件 在某些情况下，动态“真实”二维结构是有利的。例如，如果 矩阵非常大且稀疏（如果甚至不需要分配任何行，但可以使用nullptr对其进行处理），或者 这些行没有相同数量的列（也就是说，如果您根本没有矩阵，而只有另一个二维结构）。

阿里云服务器、阿里云邮箱、阿里云域名一般都在哪里进行续费操作? 阿里云基本上所有的操作都是登陆阿里云以后在阿里云的控制台管理那里进行操作的，常见项目的续费或充值，都可以正常进行。如果您的页面显示异常，可以过段时间刷新或提交工单咨询。比如：可能存在您在续费域名时，付款后依然看到域名未续费，点击续费出现该业务存在未完成操作，在未处理前无法进行当前操作。那么，看看订单付费付款还有没有别的订单没付款，如果实在找不出原因，提交工单咨询。 2、阿里云服务器、阿里云邮箱、阿里云域名不续费会怎样？ 简单来说，您的网站不能访问，app不能打开。尤其是如果续费阿里云企业邮箱，也要查看一下所绑定的域名是否在有效期内。域名忘记续费，有28-30天的过渡期，过期了域名可能就需要再次申请，也有可能被其他人抢注了。（小编曾有个域名后来没有续费，再后来想用这个域名时，已被抢注） 3、阿里云的自动续费和人工续费怎么选择和处理？ 小编建议是开通自动续费的，毕竟大家创业是希望自己的项目能长长久久，如果忘记了续费导致访问问题再导致别的问题，平白多出些让人不开心的事情。如果您是个计划性很强的人，那么不开通自动续费，进行人工续费。 有的时候因为工作交接的问题，可能会导致，在自动续费扣款日前就已经进行了人工手动续费，也不要紧，系统将会按照手动续费后的到期日期，重新计算下一次续费时间。 4、为什么续费总是辣么贵？续费为什么要涨价？ 相比我们首购的时候享受的1元域名、服务器5折、学生9.9、新用户免费套餐等等来说，续费，往往是按原价的（促销活动也有折扣），所以显得一下贵得特别多。而且有的产品，我们第一次购买的时候是旧价打折，过两年续费是已经是新价格了。小编觉得，按需选择，提高效率，组合优化，降低项目实际支出也是值得考虑的。 我们知道阿里云对于新用户的福利和优惠是很多的，而对于我们老用户来说，有没有什么办法享受些优惠或降低我们在网站运营方面的成本支出呢？天天快乐知识网小编整理几个建议，供您参考： 1、将网站运营计划和阿里云促销结合： 阿里云一年内好些个不错的促销，比如新老用户服务器打折、满减等，你可能会说经常登录阿里云，也经常收到阿里云的促销通知，所以不用关注都行。 这里天天快乐知识网小编要说的并不是说阿里云有活动就去看看，而是要有计划，一个方面，是你自己的要有计划，网站到了什么阶段需要升级还是要加配置还是要续费， 另外一个方面，根据自己的计划看是不是趁阿里云做促销的时候提前购买相应的服务和产品。 做站的往往觉得阿里云经常给自己发促销短信似乎打扰了自己，很烦，而当自己真正需要购买的时候，又没有促销了，总有种完美错过的遗憾。 所以小编希望您是将阿里云的促销和您的网站运营计划结合起来，长期来看绝对是降低您的运营成本的。 2、领取阿里云代金券！那么哪些途径可以领取代金券呢？通常代金券会有什么限制？ （1）一个来源是平常发放的代金券，平常发放阿里云代金券是新老用户都可以领的，新用户领到的券多些，老用户领到的券少些。但平常领取的代金券一般都只用于您还没有用过的产品购买，续费是不能使用的。 （点此快速领取阿里云代金券，新老用户均可） （2）大促活动，代金券一键领取，这样领取到的代金券注意一下，有的是指定产品的。 （3）买返代金券，注意一下返券的日期，和券本身的使用日期，以免过期浪费。 3、组合优化，根据网站运维情况，尝试使用新产品：（是不是只要想提升网站就要升级服务器呢？是不是花大价钱升级了服务器就一定能解决呢？未必。） 天天快乐知识网小编认为，根据网站的运维情况，尝试做些组合优化降低实际成本！降低成本本身也是种优惠方式！在此天天快乐知识网小编根据我们自己和朋友的经验，简单分享几个值得组合优化的情况： （1）阿里云CDN服务：有些网友网站访问慢，以为是服务器配置不够，不断加钱升级，希望提升访问速度，效果却不理想。怎么处理呢？答案是：不要着急升级服务器，而是尝试cdn服务提升速度。 CDN 内容分发网络服务对于访问加速效果非常明显，能最大程度提升网页加载速度，改善用户访问体验。同时，因为对服务器的直接访问请求大幅度减少，你的服务器的负荷得到很大程度减轻。同样配置的服务器可以支持更大量级的并发访问请求用户数，或者在用户数量比较稳定的情况下，可以相应降低服务器的硬件配置。 （2）阿里云数据库：如果您当前网站和数据库配置在同一台服务器上，并且感觉性能开始出现某些瓶颈，怎么处理？答案是，不要着急升级服务器，而是尝试一下阿里云数据库，实现网站服务器和数据库服务器的分离。 （3）如何预防网站直接停止访问并提示访问风险？对于访问量比较大的网站来说，任何时候网站被停止访问都是很大的损失，如果您的网站属于电子商务类型或者包括了在线支付环节，就非常有必要尽快购买部署SSL证书。阿里云盾SSL证书，云上签发，部署简单，防监听、防劫持。通过部署SSL证书提高网站的可信度，防范攻击，可有效保护用户和网站自身的合法权益。 （4）网站图片文件多访问缓慢怎么办？答案是：不要着急升级服务器，尝试对象存储OSS服务。如果你的网站或者应用涉及大量的文件存贮，涉及海量图片或者文件，文件的读写是消耗服务器CPU资源最大的IO操作，对于服务器的性能影响极大。建议尝试一下通过OSS服务，把文件的上传、下载、存贮过程部署到云端，减轻WEB服务器的IO读写负荷，可以有效提升服务器的性能。 （5）您可以会遇到的更多的情况，新手往往先怀疑是不是服务器配置不够，着急做升级，钱花了问题不一定解决了，阿里云的各种产品很多，阿里云市场也有一些解决方案，总之，不要急于花钱升级。 4、关注阿里云产品的购买规则，做最利于自己的费用支出： 阿里云产品，以阿里云ecs为例（1）一般都是买的年份越多，分摊到每年的年费越低。当然这也要结合您的实际情况，每个人都希望自己的网站是能天长地久的。购买的时候注意看清楚退款说明，毕竟，可能图优惠可能买到无法退货的产品，到时候用不了或用不完就会觉得非常可惜了。（2）不同区域的费用也不尽相同。 建站好机会来了，阿里云企业级云服务器特惠5折，首次购买ECS的用户可享受ECS实例首台5折优惠！阿里云企业级服务器特惠助力企业上云，高性能实例100%覆盖！5折超值优惠幅度挺大的，我们来看看有什么活动规则吧： 1、ECS实例首台5折可以叠加其他优惠吗？ 活动优惠不与其他优惠叠加，不能使用代金券； 购物车满1000减50的活动仅限官网日常价格产品参加，首台5折云服务器不参与； 2、阿里云企业级云服务器有什么优势或特点？ 通用场景：各类通用企业应用场景，可满足如视频弹幕、电信业务转发等高网络收发包需求。 计算场景：各类计算增强场景，如多人在线游戏（MMO）前端，金融分析等。 异构计算：可应用于AI深度学习、基因计算、渲染、多媒体编解码等。 高性能应用：专属硬件资源和物理隔离，满足高性能计算场景，如高性能数据库等企业级应用。 高主频应用：如高性能Web前端服务器，科学计算和工程应用。 大数据场景：数据库或者大数据场景，满足大容量存储和计算需求。 3、首次购买ECS的用户可享受ECS实例首台5折活动规则 参与门槛： 1）限ECS云服务器首购用户参与，即从未购买过ECS云服务器产品的用户； 2）每个用户限购1单，首台1年付可享实例5折优惠，限当前活动页指定云服务器； 3）金融云用户暂不能参与活动； 同人规则： 同一用户是指根据不同阿里云账号在注册、登录、使用中的关联信息，阿里云判断其实际为同一用户； 关联信息举例：同一证件、同一手机号、同一支付账号、同一设备、同一地址等； 配置说明： 活动实例均为1年付配置，首台年付5折优惠仅限实例，磁盘和带宽需要按官网日常价格付费； 优惠排他说明： 1）参与活动后退款再购则不能享受折扣； 2）活动优惠不与其他优惠叠加，不能使用代金券； 3）购物车满1000减50的活动仅限官网日常价格产品参加，首台5折云服务器不参与； 4、阿里云企业级云服务器配置和价格是怎样的？ 通用型 g5，2核8G，最大内网带宽 20 Gbps，最大网络收发包能力 400万PPS，5折后优惠价 1884 / 年，省1884元。 计算型 c5，2核4G，最大内网带宽 20 Gbps，最大网络收发包能力 400万PPS，5折后优惠价 1451 / 年，省1451元。 GPU计算型 gn5，4核30G，最大内网带宽 25 Gbps，最大网络收发包能力 400万PPS，5折后优惠价 22463 / 年，省22463元。 裸金属 ebmg5，96核384G，最大内网带宽 10 Gbps，最大网络收发包能力 450万PPS，5折后优惠价 73817 / 年，省73817元。 高主频计算型 hfc5，2核4G，最大内网带宽 6 Gbps，最大网络收发包能力 250万PPS，5折后优惠价 2369 / 年，省2369元。 内存型 r5，2核16G，最大内网带宽 20 Gbps，最大网络收发包能力 400万PPS，5折后优惠价 2333 / 年，省2333元。

我们都知道JVM的内存管理是自动化的，Java语言的程序指针也不需要开发人员手工释放，JVM的GC会自动的进行回收，但是，如果编程不当，JVM仍然会发生内存泄露，导致Java程序产生了OutOfMemoryError（OOM）错误。 产生OutOfMemoryError错误的原因包括： java.lang.OutOfMemoryError: Java heap spacejava.lang.OutOfMemoryError: PermGen space及其解决方法java.lang.OutOfMemoryError: unable to create new native threadjava.lang.OutOfMemoryError：GC overhead limit exceeded对于第1种异常，表示Java堆空间不够，当应用程序申请更多的内存，而Java堆内存已经无法满足应用程序对内存的需要，将抛出这种异常。 对于第2种异常，表示Java永久带（方法区）空间不够，永久带用于存放类的字节码和长常量池，类的字节码加载后存放在这个区域，这和存放对象实例的堆区是不同的，大多数JVM的实现都不会对永久带进行垃圾回收，因此，只要类加载的过多就会出现这个问题。一般的应用程序都不会产生这个错误，然而，对于Web服务器来讲，会产生有大量的JSP，JSP在运行时被动态的编译成Java Servlet类，然后加载到方法区，因此，太多的JSP的Web工程可能产生这个异常。 对于第3种异常，本质原因是创建了太多的线程，而能创建的线程数是有限制的，导致了这种异常的发生。 对于第4种异常，是在并行或者并发回收器在GC回收时间过长、超过98%的时间用来做GC并且回收了不到2%的堆内存，然后抛出这种异常进行提前预警，用来避免内存过小造成应用不能正常工作。 下面两个异常与OOM有关系，但是，又没有绝对关系。 java.lang.StackOverflowError ...java.net.SocketException: Too many open files对于第1种异常，是JVM的线程由于递归或者方法调用层次太多，占满了线程堆栈而导致的，线程堆栈默认大小为1M。 对于第2种异常，是由于系统对文件句柄的使用是有限制的，而某个应用程序使用的文件句柄超过了这个限制，就会导致这个问题。 上面介绍了OOM相关的基础知识，接下来我们开始讲述笔者经历的一次OOM问题的定位和解决的过程。 产生问题的现象 在某一段时间内，我们发现不同的业务服务开始偶发的报OOM的异常，有的时候是白天发生，有的时候是晚上发生，有的时候是基础服务A发生，有的时候是上层服务B发生，有的时候是上层服务C发生，有的时候是下层服务D发生，丝毫看不到一点规律。 产生问题的异常如下： Caused by: java.lang.OutOfMemoryError: unable to create new native thread at java.lang.Thread.start0(Native Method)at java.lang.Thread.start(Thread.java:597)at java.util.Timer.(Timer.java:154) 解决问题的思路和过程 经过细心观察发现，产生问题虽然在不同的时间发生在不同的服务池，但是，晚上0点发生的时候概率较大，也有其他时间偶发，但是都在整点。 这个规律很重要，虽然不是一个时间，但是基本都在整点左右发生，并且晚上0点居多。从这个角度思考，整点或者0点系统是否有定时，与出问题的每个业务系统技术负责人核实，0点没有定时任务，其他时间的整点有定时任务，但是与发生问题的时间不吻合，这个思路行不通。 到现在为止，从现象的规律上我们已经没法继续分析下去了，那我们回顾一下错误本身： java.lang.OutOfMemoryError: unable to create new native thread 顾名思义，错误产生的原因就是应用不能创建线程了，但是，应用还需要创建线程。为什么程序不能创建线程呢？ 有两个具体原因造成这个异常: 由于线程使用的资源过多，操作系统已经不能再提供给应用资源了。操作系统设置了应用创建线程的最大数量，并且已经达到了最大允许数量。上面第1条资源指的是内存，而第2条中，在Linux下线程使用轻量级进程实现的，因此线程的最大数量也是操作系统允许的进程的最大数量。 内存计算 操作系统中的最大可用内存除去操作系统本身使用的部分，剩下的都可以为某一个进程服务，在JVM进程中，内存又被分为堆、本地内存和栈等三大块，Java堆是JVM自动管理的内存，应用的对象的创建和销毁、类的装载等都发生在这里，本地内存是Java应用使用的一种特殊内存，JVM并不直接管理其生命周期，每个线程也会有一个栈，是用来存储线程工作过程中产生的方法局部变量、方法参数和返回值的，每个线程对应的栈的默认大小为1M。 Linux和JVM的内存管理示意图如下： 内存结构模型因此，从内存角度来看创建线程需要内存空间，如果JVM进程正当一个应用创建线程，而操作系统没有剩余的内存分配给此JVM进程，则会抛出问题中的OOM异常：unable to create new native thread。 如下公式可以用来从内存角度计算允许创建的最大线程数： 最大线程数 = （操作系统最大可用内存 - JVM内存 - 操作系统预留内存）/ 线程栈大小 根据这个公式，我们可以通过剩余内存计算可以创建线程的数量。 下面是问题出现的时候，从生产机器上执行前面小节介绍的Linux命令free的输出： free -m >> /tmp/free.log total used free shared buffers cached Mem: 7872 7163 709 0 31 3807-/+ buffers/cache: 3324 4547Swap: 4095 173 3922Tue Jul 5 00:27:51 CST 2016从上面输出可以得出，生产机器8G内存，使用了7G，剩余700M可用，其中操作系统cache使用3.8G。操作系统cache使用的3.8G是用来缓存IO数据的，如果进程内存不够用，这些内存是可以释放出来优先分配给进程使用。然而，我们暂时并不需要考虑这块内存，剩余的700M空间完全可以继续用来创建线程数： 700M / 1M = 700个线程 因此，根据内存可用计算，当OOM异常：unable to create new native thread问题发生的时候，还有700M可用内存，可以创建700个线程。 到现在为止可以证明此次OOM异常不是因为线程吃光所有的内存而导致的。 线程数对比 上面提到，有两个具体原因造成这个异常，我们上面已经排除了第1个原因，那我们现在从第2个原因入手，评估是否操作系统设置了应用创建线程的最大数量，并且已经达到了最大允许数量。 在问题出现的生产机器上使用ulimit -a来显示当前的各种系统对用户使用资源的限制： robert@robert-ubuntu1410：~$ ulimit -acore file size (blocks, -c) 0data seg size (kbytes, -d) unlimitedscheduling priority (-e) 0file size (blocks, -f) unlimitedpending signals (-i) 62819max locked memory (kbytes, -l) 64max memory size (kbytes, -m) unlimitedopen files (-n) 65535pipe size (512 bytes, -p) 8POSIX message queues (bytes, -q) 819200real-time priority (-r) 0stack size (kbytes, -s) 10240cpu time (seconds, -t) unlimitedmax user processes (-u) 1024virtual memory (kbytes, -v) unlimitedfile locks (-x) unlimited这里面我们看到生产机器设置的允许使用的最大用户进程数为1024： max user processes (-u) 1024现在，我们必须获得问题出现的时候，用户下创建的线程情况。 在问题产生的时候，我们使用前面小结介绍的JVM监控命令jstack命令打印出了Java线程情况,jstack命令的示例输出如下： robert@robert-ubuntu1410:~$ jstack 27432017-04-09 12:06:51Full thread dump Java HotSpot(TM) Server VM (25.20-b23 mixed mode): "Attach Listener" #23 daemon prio=9 os_prio=0 tid=0xc09adc00 nid=0xb4c waiting on condition [0x00000000] java.lang.Thread.State: RUNNABLE "http-nio-8080-Acceptor-0" #22 daemon prio=5 os_prio=0 tid=0xc3341000 nid=0xb02 runnable [0xbf1bd000] java.lang.Thread.State: RUNNABLE at sun.nio.ch.ServerSocketChannelImpl.accept0(Native Method) at sun.nio.ch.ServerSocketChannelImpl.accept(ServerSocketChannelImpl.java:241) - locked <0xcf8938d8> (a java.lang.Object) at org.apache.tomcat.util.net.NioEndpoint$Acceptor.run(NioEndpoint.java:688) at java.lang.Thread.run(Thread.java:745) "http-nio-8080-ClientPoller-1" #21 daemon prio=5 os_prio=0 tid=0xc35bc400 nid=0xb01 runnable [0xbf1fe000] java.lang.Thread.State: RUNNABLE at sun.nio.ch.EPollArrayWrapper.epollWait(Native Method) at sun.nio.ch.EPollArrayWrapper.poll(EPollArrayWrapper.java:269) at sun.nio.ch.EPollSelectorImpl.doSelect(EPollSelectorImpl.java:79) at sun.nio.ch.SelectorImpl.lockAndDoSelect(SelectorImpl.java:86) - locked <0xcf99b100> (a sun.nio.ch.Util$2) - locked <0xcf99b0f0> (a java.util.Collections$UnmodifiableSet) - locked <0xcf99aff8> (a sun.nio.ch.EPollSelectorImpl) at sun.nio.ch.SelectorImpl.select(SelectorImpl.java:97) at org.apache.tomcat.util.net.NioEndpoint$Poller.run(NioEndpoint.java:1052) at java.lang.Thread.run(Thread.java:745) ......从jstack命令的输出并统计后，我们得知，JVM一共创建了904个线程，但是，这还没有到最大的进程限制1024。 robert@robert-ubuntu1410:~$ grep "Thread " js.log | wc -l 904 这是我们思考，除了JVM创建的应用层线程，JVM本身可能会有一些管理线程存在，而且操作系统内用户下可能也会有守护线程在运行。 我们继续从操作系统的角度来统计线程数，我们使用上面小结介绍的Linux操作系统命令pstack，并得到如下的输出： PID LWP USER %CPU %MEM CMD 1 1 root 0.0 0.0 /sbin/init 2 2 root 0.0 0.0 [kthreadd] 3 3 root 0.0 0.0 [migration/0] 4 4 root 0.0 0.0 [ksoftirqd/0] 5 5 root 0.0 0.0 [migration/0] 6 6 root 0.0 0.0 [watchdog/0] 7 7 root 0.0 0.0 [migration/1] 8 8 root 0.0 0.0 [migration/1] 9 9 root 0.0 0.0 [ksoftirqd/1] 10 10 root 0.0 0.0 [watchdog/1] 11 11 root 0.0 0.0 [migration/2] 12 12 root 0.0 0.0 [migration/2] 13 13 root 0.0 0.0 [ksoftirqd/2] 14 14 root 0.0 0.0 [watchdog/2] 15 15 root 0.0 0.0 [migration/3] 16 16 root 0.0 0.0 [migration/3] 17 17 root 0.0 0.0 [ksoftirqd/3] 18 18 root 0.0 0.0 [watchdog/3] 19 19 root 0.0 0.0 [events/0] 20 20 root 0.0 0.0 [events/1] 21 21 root 0.0 0.0 [events/2] 22 22 root 0.0 0.0 [events/3] 23 23 root 0.0 0.0 [cgroup] 24 24 root 0.0 0.0 [khelper] ...... 7257 7257 zabbix 0.0 0.0 /usr/local/zabbix/sbin/zabbix_agentd: active checks #2 [idle 1 sec] 7258 7258 zabbix 0.0 0.0 /usr/local/zabbix/sbin/zabbix_agentd: active checks #3 [idle 1 sec] 7259 7259 zabbix 0.0 0.0 /usr/local/zabbix/sbin/zabbix_agentd: active checks #4 [idle 1 sec] ...... 9040 9040 app 0.0 30.5 /apps/prod/jdk1.6.0_24/bin/java -Dnop -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Ddbconfigpath=/apps/dbconfig/ -Djava.io.tmpdir=/apps/data/java-tmpdir -server -Xms2048m -Xmx2048m -XX:PermSize=128m -XX:MaxPermSize=512m -Dcom.sun.management.jmxremote -Djava.rmi.server.hostname=192.168.10.194 -Dcom.sun.management.jmxremote.port=6969 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/tmp -Xshare:off -Dhostname=sjsa-trade04 -Djute.maxbuffer=41943040 -Djava.net.preferIPv4Stack=true -Dfile.encoding=UTF-8 -Dworkdir=/apps/data/tomcat-work -Djava.endorsed.dirs=/apps/product/tomcat-trade/endorsed -classpath commonlib:/apps/product/tomcat-trade/bin/bootstrap.jar:/apps/product/tomcat-trade/bin/tomcat-juli.jar -Dcatalina.base=/apps/product/tomcat-trade -Dcatalina.home=/apps/product/tomcat-trade -Djava.io.tmpdir=/apps/data/tomcat-temp/ org.apache.catalina.startup.Bootstrap start 9040 9041 app 0.0 30.5 /apps/prod/jdk1.6.0_24/bin/java -Dnop -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Ddbconfigpath=/apps/dbconfig/ -Djava.io.tmpdir=/apps/data/java-tmpdir -server -Xms2048m -Xmx2048m -XX:PermSize=128m -XX:MaxPermSize=512m -Dcom.sun.management.jmxremote -Djava.rmi.server.hostname=192.168.10.194 -Dcom.sun.management.jmxremote.port=6969 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/tmp -Xshare:off -Dhostname=sjsa-trade04 -Djute.maxbuffer=41943040 -Djava.net.preferIPv4Stack=true -Dfile.encoding=UTF-8 -Dworkdir=/apps/data/tomcat-work -Djava.endorsed.dirs=/apps/product/tomcat-trade/endorsed -classpath commonlib:/apps/product/tomcat-trade/bin/bootstrap.jar:/apps/product/tomcat-trade/bin/tomcat-juli.jar -Dcatalina.base=/apps/product/tomcat-trade -Dcatalina.home=/apps/product/tomcat-trade -Djava.io.tmpdir=/apps/data/tomcat-temp/ org.apache.catalina.startup.Bootstrap start ......通过命令统计用户下已经创建的线程数为1021。 $ grep app pthreads.log | wc -l 1021 现在我们确定，1021的数字已经相当的接近1021的最大进程数了，正如前面我们提到，在Linux操作系统里，线程是通过轻量级的进程实现的，因此，限制用户的最大进程数，就是限制用户的最大线程数，至于为什么没有精确达到1024这个最大值就已经报出异常，应该是系统的自我保护功能，在还剩下3个线程的前提下，就开始报错。 到此为止，我们已经通过分析来找到问题的原因，但是，我们还是不知道为什么会创建这么多的线程，从第一个输出得知，JVM已经创建的应用线程有907个，那么他们都在做什么事情呢？ 于是，在问题发生的时候，我们又使用JVM的jstack命令，查看输出得知，每个线程都阻塞在打印日志的语句上，log4j中打印日志的代码实现如下： public void callAppenders(LoggingEvent event) { int writes = 0; for(Category c = this; c != null; c=c.parent) { // Protected against simultaneous call to addAppender, removeAppender,... synchronized(c) { if(c.aai != null) { writes += c.aai.appendLoopOnAppenders(event); } if(!c.additive) { break; } } } if(writes == 0) { repository.emitNoAppenderWarning(this); } }在log4j中，打印日志有一个锁，锁的作用是让打印日志可以串行，保证日志在日志文件中的正确性和顺序性。 那么，新的问题又来了，为什么只有凌晨0点会出现打印日志阻塞，其他时间会偶尔发生呢？这时，我们带着新的线索又回到问题开始的思路，凌晨12点应用没有定时任务，系统会不会有其他的IO密集型的任务，比如说归档日志、磁盘备份等？ 经过与运维部门碰头，基本确定是每天凌晨0点日志切割导致磁盘IO被占用，于是堵塞打印日志，日志是每个工作任务都必须的，日志阻塞，线程池就阻塞，线程池阻塞就导致线程池被撑大，线程池里面的线程数超过1024就会报错。 到这里，我们基本确定了问题的原因，但是还需要对日志切割导致IO增大进行分析和论证。 首先我们使用前面小结介绍的vmstat查看问题发生时IO等待数据： vmstat 2 1 >> /tmp/vm.logprocs -----------memory---------- ---swap-- -----io---- --system-- -----cpu----- r b swpd free buff cache si so bi bo in cs us sy id wa st 3 0 177608 725636 31856 3899144 0 0 2 10 0 0 39 1 1 59 0 Tue Jul 5 00:27:51 CST 2016可见，问题发生的时候，CPU的IO等待为59%，同时又与运维部门同事复盘，运维同事确认，脚本切割通过cat命令方法，先把日志文件cat后，通过管道打印到另外一个文件，再清空原文件，因此，一定会导致IO的上升。 其实，问题的过程中，还有一个疑惑，我们认为线程被IO阻塞，线程池被撑开，导致线程增多，于是，我们查看了一下Tomcat线程池的设置，我们发现Tomcat线程池设置了800，按理说，永远不会超过1024。 maxThreads="800" minSpareThreads="25" maxSpareThreads="75" enableLookups="false" redirectPort="8443" acceptCount="100" debug="0" connectionTimeout="20000" disableUploadTimeout="true" /> 关键在于，笔者所在的支付平台服务化架构中，使用了两套服务化框架，一个是基于dubbo的框架，一个是点对点的RPC，用来紧急情况下dubbo服务出现问题，服务降级使用。 每个服务都配置了点对点的RPC服务，并且独享一个线程池： maxThreads="800" minSpareThreads="25" maxSpareThreads="75" enableLookups="false" redirectPort="8443" acceptCount="100" debug="0" connectionTimeout="20000" disableUploadTimeout="true" /> 由于我们在对dubbo服务框架进行定制化的时候，设计了自动降级原则，如果dubbo服务负载变高，会自动切换到点对点的RPC框架，这也符合微服务的失效转移原则，但是设计中没有进行全面的考虑，一旦一部分服务切换到了点对点的RPC，而一部分的服务没有切换，就导致两个现场池都被撑满，于是超过了1024的限制，就出了问题。 到这里，我们基本可以验证，问题的根源是日志切割导致IO负载增加，然后阻塞线程池，最后发生OOM：unable to create new native thread。 剩下的任务就是最小化重现的问题，通过实践来验证问题的原因。我们与性能压测部门沟通，提出压测需求： Tomcat线程池最大设置为1500.操作系统允许的最大用户进程数1024.在给服务加压的过程中，需要人工制造繁忙的IO操作，IO等待不得低于50%。经过压测压测部门的一下午努力，环境搞定，结果证明完全可以重现此问题。 最后，与所有相关部门讨论和复盘，应用解决方案，解决方案包括： 全部应用改成按照小时切割，或者直接使用log4j的日志滚动功能。Tomcat线程池的线程数设置与操作系统的线程数设置不合理，适当的减少Tomcat线程池线程数量的大小。升级log4j日志，使用logback或者log4j2。这次OOM问题的可以归结为“多个因、多个果、多台机器、多个服务池、不同时间”，针对这个问题，与运维部、监控部和性能压测部门的同事奋斗了几天几夜，终于通过在线上抓取信息、分析问题、在性能压测部门同事的帮助下，最小化重现问题并找到问题的根源原因，最后，针对问题产生的根源提供了有效的方案。 与监控同事现场编写的脚本 本节提供一个笔者在实践过程中解决OOM问题的一个简单脚本，这个脚本是为了解决OOM（unable to create native thread)的问题而在问题机器上临时编写，并临时使用的，脚本并没有写的很专业，笔者也没有进行优化，保持原汁原味的风格，这样能让读者有种身临其境的感觉，只是为了抓取需要的信息并解决问题，但是在线上问题十分火急的情况下，这个脚本会有大用处。 !/bin/bash ps -Leo pid,lwp,user,pcpu,pmem,cmd >> /tmp/pthreads.logecho "ps -Leo pid,lwp,user,pcpu,pmem,cmd >> /tmp/pthreads.log" >> /tmp/pthreads.logecho date >> /tmp/pthreads.logecho 1 pid=ps aux|grep tomcat|grep cwh|awk -F ' ' '{print $2}'echo 2 echo "pstack $pid >> /tmp/pstack.log" >> /tmp/pstack.logpstack $pid >> /tmp/pstack.logecho date >> /tmp/pstack.logecho 3 echo "lsof >> /tmp/sys-o-files.log" >> /tmp/sys-o-files.loglsof >> /tmp/sys-o-files.logecho date >> /tmp/sys-o-files.logecho 4 echo "lsof -p $pid >> /tmp/service-o-files.log" >> /tmp/service-o-files.loglsof -p $pid >> /tmp/service-o-files.logecho date >> /tmp/service-o-files.logecho 5 echo "jstack -l $pid >> /tmp/js.log" >> /tmp/js.logjstack -l -F $pid >> /tmp/js.logecho date >> /tmp/js.logecho 6 echo "free -m >> /tmp/free.log" >> /tmp/free.logfree -m >> /tmp/free.logecho date >> /tmp/free.logecho 7 echo "vmstat 2 1 >> /tmp/vm.log" >> /tmp/vm.logvmstat 2 1 >> /tmp/vm.logecho date >> /tmp/vm.logecho 8 echo "jmap -dump:format=b,file=/tmp/heap.hprof 2743" >> /tmp/jmap.logjmap -dump:format=b,file=/tmp/heap.hprof >> /tmp/jmap.logecho date >> /tmp/jmap.logecho 9 echo end