多线程 on 庞玉栋个人博客

Java面试基础知识--重点

Fri, 17 Nov 2017 21:31:24 +0800

1.面向对象的三大特性

继承、封装、多态

什么是继承?

①继承是面向对象程序设计能够提高软件开发效率的重要原因之一。

②继承是具有传递性的，就像现实中孙子不仅长得像爸爸而且还像他爷爷。

③继承来的属性和方法是隐式的，也就是在本类里面是看不见的。

④一个类只能有一个父类，也就是类只能是单继承。

⑤一个接口可以有多个父类，也就是接口可以是多继承。

实际项目开发中，一个类继承于另一个类，那么前者就是后者的子类，反则反之。

什么是封装?

对象数据和操作该对象的指令都是对象自身的一部分，能够实现尽可能对外部隐藏数据。

实际项目开发中，使用封装最多的就是实体类，常常和 JavaBean (类必须是具体的和公共的，并且具有无参数的构造器)一起使用。

那么，实体类有那些东西呢

答：私有的成员变量、无参数的构造器、有参数的构造器、setter和getters方法、重写tostring方法、重写hashCode和equals方法。

什么是多态?

①多态就是对象拥有多种形态：引用多态和方法多态。

②引用多态：父类的引用可以指向本类对象、父类的引用可以指向子类的对象。

③方法多态：创建本类对象时，调用的方法为本类的方法；创建子类对象时，调用的方法为子类重写的方法或者继承的方法。

④存在多态的必要条件：继承、重写。

⑤多态的作用是消除类型之间的耦合关系。

在实际项目开发中，A 类继承 B 类，如果在 A 类中不重写 B 类的方法的时候，输出的仍旧是 B 类方法里面的信息(B b=new A());如果在A类中重写 B 类的方法的时候，输出的是 A 类方法里面的信息(B b=new A())。

2.Java集合框架树

Collection 接口：它是 Java 集合框架的一个根接口，也是List、Set和 Queue 接口的父接口。同时它定义了可用于操作 List、Set 和 Queue 的方法—增删改查。

Java后端程序员1年工作经验总结

Wed, 15 Nov 2017 19:26:07 +0800

1.引言

　毕业已经一年有余，这一年里特别感谢技术管理人员的器重，以及同事的帮忙，学到了不少东西。这一年里走过一些弯路，也碰到一些难题，也受到过做为一名开发却经常为系统维护和发布当救火队员的苦恼。遂决定梳理一下自己所学的东西，为大家分享一下。
　　经过一年意识到以前也有很多认识误区，比如：
　　偏爱收集，经常收集各种资料视频塞满一个个硬盘，然后心满意足的看着容量不行动。
　　不重基础，总觉得很多基础东西不需要再看了，其实不懂的地方很多，计算机程序方面任何一个结果都必有原因，不要只会用不知道原理，那是加工厂出来的。现在ide查看代码那么方便，ctrl+点击就进入了JDK查看实现细节。
　　好高骛远，在计算机基础不牢固的情况下，总想着要做架构，弄分布式，搞大数据之类。
　　不重视性能，只求能实现功能，sql查询是不是可以优化，是否有算法妙用，大对象是否要清除。
　　不重视扩展性，模块之间紧密耦合，常用方法不提取成工具类，调用关系混乱等问题。
　　……
　　本文重点不在这些，故只列举了一小部分，下面进入正题。

2.语法基础

　2.1 Java类初始化顺序
　　这是所有情况的类初始化顺序，如果实际类中没有定义则跳过：父类静态变量——父类静态代码块——子类静态代码块——父类非静态变量——父类非静态代码块——父类构造函数——子类非静态变量——子类非静态代码块——子类构造函数
　2.2 值传递和引用传递
　　可能很多人对此不屑一顾，心想老子都工作一年了，对这些还不熟悉吗？但实际情况并非这样，JDK中东西全部熟悉了吗？以一个最简单的例子开始，你觉得下图中代码执行完之后fatherList中的元素是什么？

　　这是一个最基础的值传递和引用传递的例子，你觉得好简单，已经想跃跃欲试的挑战了，那么请看下面的，StringBuffer很好理解，但是当你执行一遍之后发现是不是和预想中的输出不一样呢？String不是引用类型吗，怎么会这样呢？如果你无法理解，那么请看下String的实现源码，了解下其在内存中分配的实现原理。

　2.3 集合的使用
　　这部分几乎每个人都会用到，而且大家还都不陌生。下图来源于互联网，供大家复习一下。但是利用集合的特性进行巧妙的组合运用能解决优化很多复杂问题。Set不可重复性，List的顺序性，Map的键值对，SortSet/SortMap的有序性，我在工作中有很多复杂的业务都巧妙的使用了这些，涉及到公司保密信息，我就不贴出代码了。工作越久越发现这些和越巧妙。
　

　2.3 异常处理
　　1.看着try、catch、finally非常容易，如果和事务传播结合在一起，就会变得极其复杂。
　　2.finally不一定必须执行，return在catch/finally中处理情况（建议亲自操刀试一下）。
　　3.catch中可以继续抛自定义异常（并把异常一步步传递到控制层，利用切面抓取封装异常，返回给调用者）。
　2.4 面向对象思想
　　一提起面向对象，大家都知道抽象、封装、继承、和多态。但是实际工作经验中又知道多少呢，对于项目中如何巧用估计更不要提了。
　　共性的机会每个都需要用的建立基类，如每个控制层方法可能要通过security获取一个登录用户id，用于根据不同的用户操作不同的数据，可以抽象出一个应用层基类，实现获取id的protect方法。同理DAO层可以利用泛型提取出一个包含增删改查的基类。
　　多态的Override：基类的引用变量不仅可以指向基类的实例对象，也可以指向其子类的实例对象，如果指向子类的实例对象，其调用的方法应该是正在运行的那个对象的方法。在策略模式中使用很普遍。
　　提到面向对象，就不可避免的要说设计模式，在工作中，一个技术大牛写的一个类似策略模式（更复杂一点），十分巧妙的解决了各种业务同一个方法，并且实现了订单、工单、业务的解耦，看得我是非常佩服。我想很多面试中都会问道单例模式吧，还没有理解的建议去看一看。

3.多线程

　3.1 线程安全
　　这个是老生常谈的问题了，但是确实是问题和bug高发区。线程同步问题不需要单独写了，想必大家都清楚，不太熟悉的建议百度一下。
　3.1.1 线程安全问题
　　1.代码中如果有同步操作，共享变量要特别注意（这个一般都能意识到）
　　2多个操作能修改数据表中同一条数据的。（这个容易被忽略，业务A可能操作表a，业务B也可以操作表a，业务A、B即使在不同的模块和方法中，也会引起线程安全问题。例如如果一个人访问业务A接口，另一个人访问业务B接口，在web中每个业务请求都是会有单独的一个线程进行处理的，就会出现线程安全问题）。
　　3.不安全的类型使用，例如StringBuffer、StringBuild，HashTable、HashMap等。在工作中我就遇到过有人在for循环进行list的remove，虽然编译器不报错，程序可以运行，但是结果却可想而知。
　　4.Spring的bean默认是单例的，如果有类变量就要特别小心了（一般情况下是没人在控制层、业务层、DAO层等用类变量的，用的话建议是final类型，例如日志log，gson等）。
　　5.多个系统共享数据库情况，这个其实和分布式系统类似
　　用户重复提交问题（即使代码中从数据库读取是否存在进行限制不能解决问题）
　3.1.2 线程安全解决
　　在需要同步的地方采用安全的类型。
　　JDK锁机制，lock、tryLock，synchronized，wait、notify、notifyAll等
　　Concurrent并发工具包，在处理一些问题上，谁用谁知道。强烈建议查看源码！
　　数据表加锁。（除非某个表的访问频率极低，否则不建议使用）
　　涉及分布式的，采用中间件技术例如zookeeper等解决。
　3.2 异步
　　异步使用场景不影响主线程，且响应较慢的业务。例如IO操作，第三方服务（短信验证码、app推送、云存储上传等）。
　　如果异步任务很多，就需要使用任务队列了，任务队列可以在代码级别实现，也可以利用redis（优势太明显了）。
　3.3 多线程通信
　　这方面文章非常多，这里不在详述。
　　1.共享变量方式（共享文件、全局变量，信号量机制等）
　　2.消息队列方式
　　3. 忙等，锁机制
　3.4多线程实现
　　1.集成Thread类，重写（这里的重写指的是override）run方法，调用start方法执行。
　　2.实现Runable接口，实现run方法，以Runable实例创建thread对象。
　　3.实现Callable接口，实现call方法，FutureTask包装callable接口，FutureTask对象创建thread对象，常用语异步操作，建议使用匿名内部类，方便阅读和使用。
　　额外需要说明的是：
　　1.理解thread的join方法；
　　2.不要认为volitate是线程安全的（不明白原因的建议去看jvm运行时刻内存分配策略）；
　　3.sleep时间片结束后并不保证立马获取cpu。
　　4.ThreadLocal能够为每一个线程维护变量副本，常用于在多线程中用空间换时间。

Java精选笔试题

Sat, 11 Nov 2017 20:50:26 +0800

合抱之木，生于毫末；九层之台，起于垒土；千里之行；始于足下。赶快测测你的Java基础知识掌握的如何？

1，volatile关键字是否能保证线程安全？（）

>>>>

答案：否

volatile关键字用在多线程同步中，可保证读取的可见性，JVM只是保证从主内存加载到线程工作内存的值是最新的读取值，而非cache中。但多个线程对volatile的写操作，无法保证线程安全。

假如线程1，线程2 在进行read,load 操作中，发现主内存中count的值都是5，那么都会加载这个最新的值，在线程1对count进行修改之后，会write到主内存中，主内存中的count变量就会变为6；线程2由于已经进行read,load操作，在进行运算之后，也会更新主内存count的变量值为6；导致两个线程及时volatile关键字修改之后，还是会存在并发的情况。

2，下面哪个流类属于面向字符的输入流( )

A、BufferedWriter

B、FileInputStream

C、ObjectInputStream

D、InputStreamReader

>>>>

答案：D

Java小技巧，从运行、控制到框架

Wed, 08 Nov 2017 19:17:52 +0800

1. JVM相关

JVM作为java运行的基础，很难相信对于JVM一点都不了解的人可以把java语言吃得很透。我在面试有超过3年Java经验的开发者的时候， JVM几乎就是一个必问的问题了。当然JVM不是唯一决定技术能力好坏的面试问题，但是可以佐证java开发能力的高低。

在JVM这个大类中，我认为需要掌握的知识有：

JVM内存模型和结构

GC原理，性能调优

调优：Thread Dump，分析内存结构

class 二进制字节码结构， class loader 体系， class加载过程，实例创建过程

方法执行过程

Java各个大版本更新提供的新特性(需要简单了解)

2. Java的运行（基础必备）

这个知识点是最最基本的java开发者需要掌握的，初学java，第一个肯定是教你如何在命令行中执行java程序，但是很多人一旦把java学完了，IDE用上了，就把这个都忘了。为什么强调要知道这个呢，知道了java最纯粹的启动方式之后，你才能在启动出问题的时候，去分析当时启动的目录多少，执行命名如何，参数如何，是否有缺失等。这样有利于你真正开发中去解决那些奇奇怪怪的可能和环境相关的问题。

在这里需要掌握的知识有：

javac 编译java文件为 class 文件

java 命令的使用，带package的java类如何在命令行中启动

java程序涉及到的各个路径(classpath， java。library。path， java运行的主目录等)

3. 数据类型

这条没有什么好多说的，无非就是Java中的基本类型和对象类型的掌握。可以再了解一些JDK如何自动转换方面的知识，包括装箱拆箱等，还要注意避免装箱之后的类型相等的判断

主要知识点：

基本类型： int， long， float， double， boolean ，。。。

Java小技巧，从运行、控制到框架

Mon, 06 Nov 2017 18:19:27 +0800

1. JVM相关

在JVM这个大类中，我认为需要掌握的知识有：

JVM内存模型和结构

GC原理，性能调优

调优：Thread Dump，分析内存结构

class 二进制字节码结构， class loader 体系， class加载过程，实例创建过程

方法执行过程

Java各个大版本更新提供的新特性(需要简单了解)

2. Java的运行（基础必备）

在这里需要掌握的知识有：

javac 编译java文件为 class 文件

java 命令的使用，带package的java类如何在命令行中启动

java程序涉及到的各个路径(classpath， java。library。path， java运行的主目录等)

3. 数据类型

主要知识点：

基本类型： int， long， float， double， boolean ，。。。

对应的对象类型： Integer 等类型到基本类型的转换，装箱和拆箱

Object类型： equals， hashcode

String 类型的特点

4. 对象和实例，对象的创建

在这方面，开发者需要了解class和instance的概念以及之间的差别，这是java面向对象特性的一个基础。主要知识点有：

Class和 Instance 的概念

Instance 创建的过程：

java多线程高级教程，这些你都懂了吗？

Thu, 02 Nov 2017 23:21:04 +0800

一、countdownLatch和cyclicbarrier（这两个做多线程控制很好用，工作中会经常用到）

countdownLatch：主线程阻塞，当多个线程countdown到0，主线程执行；

cyclicbarrier：多个线程等待，当都处于等待状态了一起执行（类似于赛跑机制）

countdownLatch

cyclicbarrier

二、volatile和threadlocal

这两个也要很好掌握，不仅常用，而且面试时候也经常问到！

volatile:使属性可见性。有个属性是共享属性，这个关键字会在每个线程内开一块内存，每次子线程都会从主线程拿最新的属性放到内存中。但是有个问题，他只是拿最新的，比如：计数器，每个线程都执行+1操作。一个线程+1，另外两个同时读取这个属性，那么不会加2次，而是只加一次，这就是valatile不能保证原子性的原因。

threadlocal：用于做方法外的全局属性。这个跟volatile刚好相反，使全局变量独立，每个线程里都有一份独立副本。

这是hibernate的源码，如果当前线程没有session就openSession放到ThreadLocalMap中，每个线程的session都是独立的不会相互受影响。

三、AtomicInteger：支持原子性计数器。

之前说volatile不能作为计数器，那么多线程计数器要用atomic类的AtomicInteger

四、并发类容器

ConCurrentHashMap、CopyAndWriteArrayList、CopyAndWriteArraySet。

ConCurrentHashMap（底层分成16个hashtable来保证并发）读支持高并发读，写和删除时候只支持16个线程，所以一般也要上锁； copyandwrite支持高并发读，写的话要加锁（原理是，写的时候赋值一个容器，写好了把指针指向新容器并且删除原容器）

map、list、set都有并发类容器。面试时候经常会问hashmap和ConCurrentHashMap区别。这个demo我就不写了，用法和我们平时用的集合都一样，只是他们不会造成线程不安全。

五、并发类队列

阻塞的意思是，当达到队列最大容量或者为空，线程还往里加东西或取东西会被阻塞；有界意思，可以设置队列大小。

（非阻塞队列）ConcurrentLinkedQueue无阻塞无界限队列（高并发性能最好，peek取出不删除，poll取出删除），

（阻塞队列）ArrayBlockingQueue阻塞有界队列，LinkBlockingQueue阻塞无界队列（生产者消费者首选，take方法会阻塞，poll方法没有就返回null）。

这里我们以最经典的生产者消费者模式作为例子

这里我们顺便做一个延伸，我们用的所有线程池，包括面试时候经常问的要你自定义一个线程池怎么做？我们先看一下线程池的源码。

也就是说线程池也是用并发队列作为线程的容器。我们自定义时候也只需要重现实例化ThreadPoolExcutor，设置我们自己需要的参数即可。

六、分布式锁

这个其实已经不属于java代码范畴，但是我上一篇讲基础的时候，一些兄弟说我说的太简单，另一些又说太难，所以我加了一个分布式锁，希望能满足更多人需求。

分布式锁，主要用在分布式集群上，既然是分布式，那就有多个jvm，即使你代码写出花来也不能控制。所以只有一个办法就是借助第三方工具。比如memcache、redis、zk

1. 首先明确一点，有人可能会问是否可以考虑采用ReentrantLock来实现，但是实际上去实现的时候是有问题的，ReentrantLock的lock和unlock要求必须是在同一线程进行，而分布式应用中，lock和unlock是两次不相关的请求，因此肯定不是同一线程，因此导致无法使用ReentrantLock。

2. 基于数据库表做乐观锁，用于分布式锁。

3. 使用memcached的add()方法，用于分布式锁。

Java入门学习进阶知识点汇总

Wed, 01 Nov 2017 20:04:15 +0800

入门阶段，主要是培养Java语言的编程思想。了解Java语言的语法，书写规范等，掌握Eclipse、MyEclipse等开发工具，编写Java代码的能力。学完这个阶段你应该可进行小型应用程序开发并且可以对数据库进行基本的增删改查管理。

注意：此阶段知识点的学习，需要真实的项目进行驱动学习，让你轻松理解各知识点。

1 计算机基础知识

针对零基础学习的人，从对计算机操作等知识的了解，延伸到Java语言的发展与开发工具的使用上。主要是了解怎样执行计算机命令，认识Java这门语言，感受编程语言Java怎么开发程序。

(1) 计算机基础

零基础学习的人先了解计算机相关知识，进而再去了解Java语言。

(2) DOS常用命令

了解什么是DOS，并掌握DOS控制台的打开方式，同时熟悉常用的DOS命令，例如：盘符切换、进入指定目录、删除文件等，完成使用DOS命令对计算机进行操作和控制。

(3) Java概述

了解Java语言的发展史、Java语言平台版本、Java语言的特点，以及JRE与JDK。JRE是Java的运行环境，JDK是Java开发工具包，它包含了Java的开发工具以及JRE。所以安装了JDK就不用再单独安装JRE了。

(4) JDK环境安装配置

了解了什么是JDK，以及JDK的重要性，下一步我们就来学习如何安装和配置JDK环境。在安装JDK之前，我们首先需要下载JDK，针对不同的系统，我们需要下载不用版本的JDK。

(5) 环境变量配置

了解path、classpath环境变量，理解path变量和classpath变量的作用，并掌握path变量和classpath变量的配置方式。

(6) Java程序入门

当JDK、环境变量配置完毕，我们就可以开始编写Java程序。编写Java程序可以使用如下几种工具：notepad（微软操作系统自带）、Editplus、Notepad++、Eclipse、MyEclipse。

2 编程基础

此模块学习主要是了解编程的具体流程，学习Java基础语法的格式等。具体要掌握不同数据类型的变量定义与使用，掌握不同运算符的运算规则，掌握流程控制语句的执行流程，编写方法的声明与调用，创建数组并访问数组元素等知识。

(1) 注释

在程序开发工程中，用于解释和说明程序的文字我们称之为注释，Java中的注释分为以下几种：单行注释、多行注释、文档注释。

(2) 关键字

了解Java关键字的含义及特点，掌握关键字使用的注意事项。

( 3) 标识符

了解什么是标识符，标识符的组成规则，以及标识符使用时的注意事项。

( 4) 常量与变量

理解常量与变量的含义，并掌握常量与变量的区别、变量的定义格式以及变量的赋值。

( 5) 数据类型

掌握Java语言的数据类型，如基本数据类型：byte、short、int、long、float、double、char、boolean，以及引用类型：类、接口、数组。

深入解析Java垃圾回收机制

Mon, 23 Oct 2017 21:41:45 +0800

引入垃圾回收哪些内存需要回收？引用计数法可达性分析如何回收 Marking 标记 Normal Deletion 清除 Deletion with Compacting 压缩为什么需要分代收集？ JVM的分代新生代老年代永久代分代垃圾收集过程详述引入垃圾回收

JAVA

程序计数器、虚拟机栈、本地方法栈3个区域随线程而生，随线程而灭；栈中的栈帧随着方法的进入和退出而有条不紊地执行着出栈和入栈操作。每一个栈帧中分配多少内存基本上是在类结构确定下来时就已知的（尽管在运行期会由JIT编译器进行一些优化，但在本章基于概念模型的讨论中，大体上可以认为是编译期可知的），因此这几个区域的内存分配和回收都具备确定性，在这几个区域内就不需要过多考虑回收的问题，因为方法结束或者线程结束时，内存自然就跟随着回收了。而Java堆和方法区则不一样，一个接口中的多个实现类需要的内存可能不一样，一个方法中的多个分支需要的内存也可能不一样，我们只有在程序处于运行期间时才能知道会创建哪些对象，这部分内存的分配和回收都是动态的，垃圾收集器所关注的是这部分内存—–《深入理解Java虚拟机》自动垃圾回收机制就是寻找Java堆中的对象，并对对象进行分类判别，寻找出正在使用的对象和已经不会使用的对象，然后把那些不会使用的对象从堆上清除。自动垃圾回收机制就是要解决三个问题：

哪些内存需要回收？什么时候回收？如何回收？哪些内存需要回收？

引用计数法

对于第一个问题，也就是判断是否还需要使用，最简单的方法就是通过目前是否有引用指向这个对象，如果没有就说明这个对象不会再被使用了，如果有就说明这个对象可能还会继续被使用，这种通过引用是否存在的方法就叫做引用计数法，但这个方法存在一个问题就是无法解决对象循环引用的问题，因此又出现了可达性分析的方法来判断对象是否可以被会回收。

可达性分析

这个算法的基本思路就是通过一系列的称为“GC Roots”的对象作为起始点，从这些节点开始向下搜索，搜索所走过的路径称为引用链（Reference Chain），当一个对象到GC Roots没有任何引用链相连（用图论的话来说，就是从GC Roots到这个对象不可达）时，则证明此对象是不可用的。在Java语言中，可作为GC Roots的对象包括下面几种：

虚拟机栈（栈帧中的本地变量表）中引用的对象。方法区中类静态属性引用的对象。方法区中常量引用的对象。本地方法栈中JNI（即一般说的Native方法）引用的对象。如何回收

垃圾收集器通常会帮我们在后台自动进行垃圾回收。关于具体的回收过程只要有以下这些步骤

Step 1: Marking 标记第一步就是标记，也就是垃圾收集器会找出那些需要回收的对象所在的内存和不需要回收的对象所在的内存，并把它们标记出来，简单的说，也就是先找出垃圾在哪所有堆中的对象都会被扫描一遍，以此来确定回收的对象，所以这通常会是一个相对比较耗时的过程

Step 2: Normal Deletion 垃圾收集器会清除掉上一步标记出来的那些需要回收的对象区域

服务端 I/O 性能大比拼：Node、PHP、Java 和 Go

Sat, 14 Oct 2017 19:47:46 +0800

理解应用程序的输入/输出（I/O）模型，意味着其在计划处理负载与残酷的实际使用场景之间的差异。若应用程序比较小，也没有服务于很高的负载，也许它影响甚微。但随着应用程序的负载逐渐上涨，采用错误的I/O模型有可能会让你到处踩坑，伤痕累累。

正如大部分存在多种解决途径的场景一样，重点不在于哪一种途径更好，而是在于理解如何进行权衡。让我们来参观下I/O的景观，看下可以从中窃取点什么。

在这篇文章，我们将会结合Apache分别比较Node，Java，Go，和PHP，讨论这些不同的语言如何对他们的I/O进行建模，各个模型的优点和缺点，并得出一些初步基准的结论。如果关心你下一个Web应用的I/O性能，那你就找对文章了。

I/O基础知识：快速回顾

为了理解与I/O密切相关的因素，必须先来回顾在操作系统底层的概念。虽然不会直接处理这些概念的大部分，但通过应用程序的运行时环境你一直在间接地处理他们。而关键在于细节。

系统调用

首先，我们有系统调用，它可以描述成这样：

你的程序（在“用户区域”，正如他们所说的）必须让操作系统内核在它自身执行I/O操作。
“系统调用”（syscall）意味着你的程序要求内核做某事。不同的操作系统，实现系统调用的细节有所不同，但基本的概念是一样的。这将会有一些特定的指令，把控制权从你的程序转交到内核（类似函数调用但有一些专门用于处理这种场景的特殊sauce）。通常来说，系统调用是阻塞的，意味着你的程序需要等待内核返回到你的代码。
内核在我们所说的物理设备（硬盘、网卡等）上执行底层的I/O操作，并回复给系统调用。在现实世界中，内核可能需要做很多事情才能完成你的请求，包括等待设备准备就绪，更新它的内部状态等，但作为一名应用程序开发人员，你可以不用关心这些。以下是内核的工作情况。

阻塞调用与非阻塞调用

好了，我刚刚在上面说系统调用是阻塞的，通常来说这是对的。然而，有些调用被分类为“非阻塞”，意味着内核接收了你的请求后，把它放进了队列或者缓冲的某个地方，然后立即返回而并没有等待实际的I/O调用。所以它只是“阻塞”了一段非常短的时间，短到只是把你的请求入列而已。

这里有一些有助于解释清楚的（Linux系统调用）例子：-read()是阻塞调用——你传给它一个文件句柄和一个存放所读到数据的缓冲，然后此调用会在当数据好后返回。注意这种方式有着优雅和简单的优点。-epoll_create()，epoll_ctl()，和epoll_wait()这些调用分别是，让你创建一组用于侦听的句柄，从该组添加/删除句柄，和然后直到有活动时才阻塞。这使得你可以通过一个线程有效地控制一系列I/O操作。如果需要这些功能，这非常棒，但也正如你所看到的，使用起来当然也相当复杂。

理解这里分时差异的数量级是很重要的。如果一个CPU内核运行在3GHz，在没有优化的情况下，它每秒执行30亿次循环（或者每纳秒3次循环）。非阻塞系统调用可能需要10纳秒这样数量级的周期才能完成——或者“相对较少的纳秒”。对于正在通过网络接收信息的阻塞调用可能需要更多的时间——例如200毫秒（0.2秒）。例如，假设非阻塞调用消耗了20纳秒，那么阻塞调用消耗了200,000,000纳秒。对于阻塞调用，你的程序多等待了1000万倍的时间。

内核提供了阻塞I/O（“从网络连接中读取并把数据给我”）和非阻塞I/O（“当这些网络连接有新数据时就告诉我”）这两种方法。而使用何种机制，对应调用过程的阻塞时间明显长度不同。

调度

接下来第三件关键的事情是，当有大量线程或进程开始阻塞时怎么办。

出于我们的目的，线程和进程之间没有太大的区别。实际上，最显而易见的执行相关的区别是，线程共享相同的内存，而每个进程则拥有他们独自的内存空间，使得分离的进程往往占据了大量的内存。但当我们讨论调度时，它最终可归结为一个事件清单（线程和进程类似），其中每个事件需要在有效的CPU内核上获得一片执行时间。如果你有300个线程正在运行并且运行在8核上，那么你得通过每个内核运行一段很短的时间然后切换到下一个线程的方式，把这些时间划分开来以便每个线程都能获得它的分时。这是通过“上下文切换”来实现的，使得CPU可以从正在运行的某个线程/进程切换到下一个。

这些上下文切换有一定的成本——它们消耗了一些时间。在快的时候，可能少于100纳秒，但是根据实现的细节，处理器速度/架构，CPU缓存等，消耗1000纳秒甚至更长的时间也并不罕见。

线程（或者进程）越多，上下文切换就越多。当我们谈论成千上万的线程，并且每一次切换需要数百纳秒时，速度将会变得非常慢。

然而，非阻塞调用本质上是告诉内核“当你有一些新的数据或者这些连接中的任意一个有事件时才调用我”。这些非阻塞调用设计于高效地处理大量的I/O负载，以及减少上下文切换。

到目前为止你还在看这篇文章吗？因为现在来到了有趣的部分：让我们来看下一些流利的语言如何使用这些工具，并就在易用性和性能之间的权衡作出一些结论……以及其他有趣的点评。

请注意，虽然在这篇文章中展示的示例是琐碎的（并且是不完整的，只是显示了相关部分的代码），但数据库访问，外部缓存系统（memcache等全部）和需要I/O的任何东西，都以执行某些背后的I/O操作而结束，这些和展示的示例一样有着同样的影响。同样地，对于I/O被描述为“阻塞”（PHP，Java）这样的情节，HTTP请求与响应的读取与写入本身是阻塞的调用：再一次，更多隐藏在系统中的I/O及其伴随的性能问题需要考虑。

为项目选择编程语言要考虑的因素有很多。当你只考虑性能时，要考虑的因素甚至有更多。但是，如果你关注的是程序主要受限于I/O，如果I/O性能对于你的项目至关重要，那这些都是你需要了解的。“保持简单”的方法：PHP。

回到90年代的时候，很多人穿着匡威鞋，用Perl写着CGI脚本。随后出现了PHP，很多人喜欢使用它，它使得制作动态网页更为容易。

PHP使用的模型相当简单。虽然有一些变化，但基本上PHP服务器看起来像：

HTTP请求来自用户的浏览器，并且访问了你的Apache网站服务器。Apache为每个请求创建一个单独的进程，通过一些优化来重用它们，以便最大程度地减少其需要执行的次数（创建进程相对来说较慢）。Apache调用PHP并告诉它在磁盘上运行相应的.php文件。PHP代码执行并做一些阻塞的I/O调用。若在PHP中调用了file_get_contents()，那在背后它会触发read()系统调用并等待结果返回。

当然，实际的代码只是简单地嵌在你的页面中，并且操作是阻塞的：

关于它如何与系统集成，就像这样：

相当简单：一个请求，一个进程。I/O是阻塞的。优点是什么呢？简单，可行。那缺点是什么呢？同时与20,000个客户端连接，你的服务器就挂了。由于内核提供的用于处理大容量I/O（epoll等）的工具没有被使用，所以这种方法不能很好地扩展。更糟糕的是，为每个请求运行一个单独的过程往往会使用大量的系统资源，尤其是内存，这通常是在这样的场景中遇到的第一件事情。

注意：Ruby使用的方法与PHP非常相似，在广泛而普遍的方式下，我们可以将其视为是相同的。

多线程的方式：Java

所以就在你买了你的第一个域名的时候，Java来了，并且在一个句子之后随便说一句“dot com”是很酷的。而Java具有语言内置的多线程（特别是在创建时），这一点非常棒。

大多数Java网站服务器通过为每个进来的请求启动一个新的执行线程，然后在该线程中最终调用作为应用程序开发人员的你所编写的函数。

在Java的Servlet中执行I/O操作，往往看起来像是这样：

由于我们上面的doGet方法对应于一个请求并且在自己的线程中运行，而不是每次请求都对应需要有自己专属内存的单独进程，所以我们会有一个单独的线程。这样会有一些不错的优点，例如可以在线程之间共享状态、共享缓存的数据等，因为它们可以相互访问各自的内存，但是它如何与调度进行交互的影响，仍然与前面PHP例子中所做的内容几乎一模一样。每个请求都会产生一个新的线程，而在这个线程中的各种I/O操作会一直阻塞，直到这个请求被完全处理为止。为了最小化创建和销毁它们的成本，线程会被汇集在一起，但是依然，有成千上万个连接就意味着成千上万个线程，这对于调度器是不利的。

死磕 Java 并发：Java 内存模型之 happens-before

Tue, 10 Oct 2017 22:10:06 +0800

那么我们正确使用同步、锁的情况下，线程A修改了变量a何时对线程B可见？

我们无法就所有场景来规定某个线程修改的变量何时对其他线程可见，但是我们可以指定某些规则，这规则就是happens-before，从JDK 5 开始，JMM就使用happens-before的概念来阐述多线程之间的内存可见性。

在JMM中，如果一个操作执行的结果需要对另一个操作可见，那么这两个操作之间必须存在happens-before关系。

happens-before原则非常重要，它是判断数据是否存在竞争、线程是否安全的主要依据，依靠这个原则，我们解决在并发环境下两操作之间是否可能存在冲突的所有问题。下面我们就一个简单的例子稍微了解下happens-before ；

i = 1; //线程A执行

j = i ; //线程B执行

j 是否等于1呢？假定线程A的操作（i = 1）happens-before线程B的操作（j = i）,那么可以确定线程B执行后j = 1 一定成立，如果他们不存在happens-before原则，那么j = 1 不一定成立。这就是happens-before原则的威力。

happens-before原则定义如下：

如果一个操作happens-before另一个操作，那么第一个操作的执行结果将对第二个操作可见，而且第一个操作的执行顺序排在第二个操作之前。

两个操作之间存在happens-before关系，并不意味着一定要按照happens-before原则制定的顺序来执行。如果重排序之后的执行结果与按照happens-before关系来执行的结果一致，那么这种重排序并不非法。

下面是happens-before原则规则：

程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作；

锁定规则：一个unLock操作先行发生于后面对同一个锁额lock操作；

volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作；

传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C；

线程启动规则：Thread对象的start()方法先行发生于此线程的每个一个动作；

线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生；

线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行；

对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始；

我们来详细看看上面每条规则（摘自《深入理解Java虚拟机第12章》）：

程序次序规则：一段代码在单线程中执行的结果是有序的。注意是执行结果，因为虚拟机、处理器会对指令进行重排序（重排序后面会详细介绍）。虽然重排序了，但是并不会影响程序的执行结果，所以程序最终执行的结果与顺序执行的结果是一致的。故而这个规则只对单线程有效，在多线程环境下无法保证正确性。

锁定规则：这个规则比较好理解，无论是在单线程环境还是多线程环境，一个锁处于被锁定状态，那么必须先执行unlock操作后面才能进行lock操作。

volatile变量规则：这是一条比较重要的规则，它标志着volatile保证了线程可见性。通俗点讲就是如果一个线程先去写一个volatile变量，然后一个线程去读这个变量，那么这个写操作一定是happens-before读操作的。

传递规则：提现了happens-before原则具有传递性，即A happens-before B , B happens-before C，那么A happens-before C

Java面试常被问到的题目+解答

Thu, 05 Oct 2017 21:24:02 +0800

摘要：第一，anonymousinnerclass(匿名内部类)是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)? 不行,对于匿名内部类,看到的一句话说的很到位: new <类或接口> <类的主体> 这种形式的new语句声明一个新的匿名类，他对一个给定的类进行扩展，或实现一个给定的接口。

第一，anonymousinnerclass(匿名内部类)是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?

不行,对于匿名内部类,看到的一句话说的很到位:

new <类或接口> <类的主体>

这种形式的new语句声明一个新的匿名类，他对一个给定的类进行扩展，或实现一个给定的接口。他还创建那个类的一个新实例，并把他作为语句的结果而返回。

这就是匿名类的实质,它本身就是一个类的继承或一个接口的实现,所以继承其它类或借口是无意义的.在eclipse中冶证实了我的想法.无论是继承其它类还是实现其它借口都显示Syntax error on token。

第二，staticnestedclass和innerclass的不同，说得越多越好(面试题有的很笼统)。

static nested class 指静态嵌套类,或称嵌套类,是C++中常用的说法,inner class指内部类,是JAVA中的说法。

内部类是一个类内部类的统称,具体分为四种：成员类,静态成员类，局部类，匿名类。其中匿名类是局部类的特殊情况。对于成员类和静态成员类都存在于类的顶层代码中。相当于类的静态方法和非静态方法的关系。区别在于成员类依赖于类实例而静态成员类不依赖。所以前者只能访问实例方法和成员而后者只能访问静态方法和成员。它们都用于创建一个只和当前类有关。和其它类无关的依赖类.是否静态取决于是否依赖类的实例。局部类相当于局部变量。存在于类的局部代码中。相当于在main()中随意定义和使用类。唯一的不同是它只能使用final型的局部变量。这和垃圾回收机制有关。即局部变量会在代码块结束后被回收。而对象不一定。所以对象只能使用final的局部变量。同样，局部类存在的局部代码块也可以有静态和非静态的差别。局部类罪常见的应用就是匿名类。匿名类就是无名子的局部类。常在SWING设计中的添加监听中出现。

static nested class相当于inner class中的静态成员类。

第三，&和&&的区别。

这个问得很少。

&和^,<<,<<<,|同属于位运算符,其中&是按位与,例如,1&1=1，1&0=0，&&是逻辑运算符,处理真假值，例如,true&&true=true。

如果你想学习Java可以来这个群，首先是二二零，中间是142，最后是906，里面可以学习和交流，也有资料可以下载。

第四，hashmap和hashtable的区别。

常问。

hashmap可以看做是hashtable的替代者，HashMap的Value和Key都可为NULL，而HashTable不可以，同时，HashTable是线程同步的，而HashMap不是.HashTable用Iterator遍历，HashMap用Enumeration遍历。HashTable中hash数组默认大小是11，增加的方式是 old*2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数。计算index的方法不同，HashTable直接利用hashcode()得出，HashMap对hashcode重新计算得出。

第五，collection和collections的区别。

你千万别说一个是单数一个是复数。

collection是结合类的上级接口，子接口有List和Set等，Collections是java.util下的一个工具类，提供一些列静态方法对集合搜索排序线程同步化等。

第六，什么时候用assert。

api级的技术人员有可能会问这个。

在调试和优化中使用，用于判断逻辑表达式真假,若为假，终止程序并返回异常.assert比if的优点在于可以选择是否开启assert检查，也就是说assert产生的测试代码可以在正式发布时候选择忽略，这带来极大便利，默认assert检查是关闭的。此外，Junit相比assert来说，有着相似但更强大的测试能力。

第七，gc是什么?为什么要有gc?

基础。

GC 即 garbage collection(垃圾收集)，是JAVA用于回收内存的一种方式，主要的实现方法有引用计数，标记回收，复制清除等，GC可以避免内存泄露和堆栈溢出，有效提高内存的利用效率，同时将程序员从繁琐的内存管理中释放出来。

第八，string s=new string("xyz");创建了几个stringobject?

学习Java需吃透这些基本概念你知道吗？

Sun, 24 Sep 2017 21:14:30 +0800

学习好比盖房子，打地基好很重要，房了能盖多高关键看地基；学习同样道理，基础知识是以后学习一切技术的必要条件，我们在准备学习一门开发语言时，首先要学习它的基础，不仅要会，更要融会贯通；万变不离其宗，无论技术框架怎么变，本质都是对基础的封装再造。

在以往的工作学习中，我总结了一些Java非常重要的知识点或者说基本概念，好了，进入正题：

1、面向对象编程（OOP）:OOP最重要的思想是类,类是模板,从类中构造一个对象,即创建了这个类的一个实例；

2、封装:是把数据和行为结合在一起，并对对象使用者隐藏数据的实现过程,通常一个对象中的数据叫他的实例字段(instance field) ；

3、继承:Java中允许在已经存在的类的基础上构建新的类,当你继承一个已经存在的类时,那么你就复用了这个类的方法和字段,同时你可以在新类中添加新的方法和字段；

4、多态:在java中,对象变量是多态的；需要注意的是java中不支持多重继承；

5、类之间的关系:

use-a :依赖关系；

has-a :聚合关系；

is-a : 继承关系–例:A类继承了B类,此时A类不仅有了B类的方法,还有其自己的方法；

6、构造对象使用构造器:构造器是一种特殊的方法,它的作用是构造对象并对其初始化，

构造器特点:构造器可以有0个,一个或多个参数；

构造器和类名称是相同的；

一个类可以有多个构造器；

构造器没有返回值；

构造器一定是和new运算符一起使用的；

7、包(package)：Java允许把一个或多个类放在一起成为一组,称作为包,以便于更好的管理,标准Java库分为许多包如java.lang、java.util、java,net等,包是分层次的，所有的java包都在java和javax包层次内；

8、重载:当多个方法具有相同的名字而含有不同的参数时,这时就发生了重载，编译器会选出调用哪个方法；

9、健壮特性:Java采取了一个安全指针模型,能有效防止重写内存和数据崩溃；

10、安全:Java可以用来构建防病毒和防攻击的系统，事实证明Java在防毒方面做的比较好；

11、可移植性:Java中对基本数据结构类型的大小和算法都有严格的规定，所以有很好的可移植性；

12、多线程:由于Java的机制，它处理多线程的过程很简单,Java把多线程实现交给底下操作系统或线程程序完成，所以多线程是Java作为服务器端开发语言的流行原因之一；

13、动态绑定:这是Java调用对象方法的机制；

14、Java中的每一个类都是从Object类扩展而来的；

15、内部类:一个内部类的定义是定义在另一个内部类中；

以上只列出了比较重要的，必须掌握的知识点。

【分享】Java并发面试题精选

Wed, 13 Sep 2017 20:20:01 +0800

1，什么是线程？

线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。

2，线程和进程有什么区别？

线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间。每个线程都拥有单独的栈内存用来存储本地数据。

3，如何在Java中实现线程？

两种方式：java.lang.Thread 类的实例就是一个线程但是它需要调用java.lang.Runnable接口来执行，由于线程类本身就是调用的Runnable接口所以你可以继承java.lang.Thread 类或者直接调用Runnable接口来重写run()方法实现线程。

4，Java 关键字volatile 与 synchronized 作用与区别？

1，volatile

它所修饰的变量不保留拷贝，直接访问主内存中的。

在Java内存模型中，有main memory，每个线程也有自己的memory (例如寄存器)。为了性能，一个线程会在自己的memory中保持要访问的变量的副本。这样就会出现同一个变量在某个瞬间，在一个线程的memory中的值可能与另外一个线程memory中的值，或者main memory中的值不一致的情况。一个变量声明为volatile，就意味着这个变量是随时会被其他线程修改的，因此不能将它cache在线程memory中。

2，synchronized

当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

四、当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

五、以上规则对其它对象锁同样适用。

5，有哪些不同的线程生命周期？

当我们在Java程序中新建一个线程时，它的状态是New。当我们调用线程的start()方法时，状态被改变为Runnable。线程调度器会为Runnable线程池中的线程分配CPU时间并且讲它们的状态改变为Running。其他的线程状态还有Waiting，Blocked 和Dead。

6，你对线程优先级的理解是什么？

每一个线程都是有优先级的，一般来说，高优先级的线程在运行时会具有优先权，但这依赖于线程调度的实现，这个实现是和操作系统相关的(OS dependent)。我们可以定义线程的优先级，但是这并不能保证高优先级的线程会在低优先级的线程前执行。线程优先级是一个int变量(从1-10)，1代表最低优先级，10代表最高优先级。

7，什么是死锁(Deadlock)？如何分析和避免死锁？

死锁是指两个以上的线程永远阻塞的情况，这种情况产生至少需要两个以上的线程和两个以上的资源。

Java面试经验，兼谈互联网公司后端面试经验

Sun, 10 Sep 2017 19:47:01 +0800

应聘相关

声明：

程序员相关的哈

万事无定论，比如说，就算你小学毕业，但是java基础却扎实到变态，我相信open的公司还是会给你机会的。

心态很重要，虽然日常的心态不容易控制，面试那俩小时的心态，只要你想，就能控制。

1、先来一份前辈的劝戒

坚持三年，不管在哪干，有一个好的平台，坚持三年以上才能出效果。

如果跳的话，新公司需要稳定，最少过了B轮融资，，五万比一是创业型公司的失败率

不要着急，不要比较为了5000块的工资差价跳，不值得跳，从一万到三万，并且有一个好的平台的话，才值得跳。

长期的看普华挺好的，从平台上讲，除了BAT华为，基本没有更好的

每天要多投些简历，每天投个几十份，别着急，多面面。

2、再来一份傲骄的互联网公司的不收标准

符合以下条件的不要

二本以下，特别是学校名XXX学院

应届或者未毕业

在职并且不打算换工作

目标非北京

纯 windows / asp / c# / c sharp / .net / dot net

纯嵌入式

纯移动端 android / iOS

特别底层，比如操作系统内核裁剪

非计算机专业，计算机工作经验在一年以下

最近的项目，空白超过半年，比如现在8月份，项目经历只写到2月

87 年以前，除非背景特别牛

Java集合类

Fri, 08 Sep 2017 21:07:49 +0800

看了一些所谓大公司的JAVA面试问题，发现对于JAVA集合类的使用都比较看重似的，而自己在这方面还真的是所真甚少，抽空也学习学习吧。

java.util包中包含了一系列重要的集合类，而对于集合类，主要需要掌握的就是它的内部结构，以及遍历集合的迭代模式。

接口：Collection

Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。

所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。

主要的一个接口方法：boolean add(Ojbect c)

虽然返回的是boolean，但不是表示添加成功与否，这个返回值表示的意义是add()执行后，集合的内容是否改变了（就是元素的数量、位置等有无变化）。类似的addAll，remove，removeAll，remainAll也是一样的。

用Iterator模式实现遍历集合

Collection有一个重要的方法：iterator()，返回一个Iterator（迭代器），用于遍历集合的所有元素。Iterator模式可以把访问逻辑从不同的集合类中抽象出来，从而避免向客户端暴露集合的内部结构。典型的用法如下：

Iterator it = collection.iterator(); // 获得一个迭代器
while(it.hasNext()) {
Object obj = it.next(); // 得到下一个元素
}

不需要维护遍历集合的“指针”，所有的内部状态都由Iterator来维护，而这个Iterator由集合类通过工厂方法生成。

每一种集合类返回的Iterator具体类型可能不同，但它们都实现了Iterator接口，因此，我们不需要关心到底是哪种Iterator，它只需要获得这个Iterator接口即可，这就是接口的好处，面向对象的威力。

要确保遍历过程顺利完成，必须保证遍历过程中不更改集合的内容（Iterator的remove()方法除外），所以，确保遍历可靠的原则是：只在一个线程中使用这个集合，或者在多线程中对遍历代码进行同步。

由Collection接口派生的两个接口是List和Set。　

List接口

List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。和下面要提到的Set不同，List允许有相同的元素。

除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。

实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。

LinkedList类

LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。

注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：List list = Collections.synchronizedList(new LinkedList(...));

ArrayList类

ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。

size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。

每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。

和LinkedList一样，ArrayList也是非同步的（unsynchronized）。

Java中堆内存和栈内存详解

Sun, 27 Aug 2017 19:13:26 +0800

Java把内存分成两种，一种叫做栈内存，一种叫做堆内存.

在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配。当在一段代码块中定义一个变量时，java就在栈中为这个变量分配内存空间，当超过变量的作用域后，java会自动释放掉为该变量分配的内存空间，该内存空间可以立刻被另作他用。

堆内存用于存放由new创建的对象和数组。在堆中分配的内存，由java虚拟机自动垃圾回收器来管理。在堆中产生了一个数组或者对象后，还可以在栈中定义一个特殊的变量，这个变量的取值等于数组或者对象在堆内存中的首地址，在栈中的这个特殊的变量就变成了数组或者对象的引用变量，以后就可以在程序中使用栈内存中的引用变量来访问堆中的数组或者对象，引用变量相当于为数组或者对象起的一个别名，或者代号。

引用变量是普通变量，定义时在栈中分配内存，引用变量在程序运行到作用域外释放。而数组＆对象本身在堆中分配，即使程序运行到使用new产生数组和对象的语句所在地代码块之外，数组和对象本身占用的堆内存也不会被释放，数组和对象在没有引用变量指向它的时候，才变成垃圾，不能再被使用，但是仍然占着内存，在随后的一个不确定的时间被垃圾回收器释放掉。这个也是java比较占内存的主要原因，实际上，栈中的变量指向堆内存中的变量，这就是 Java 中的指针!

java中内存分配策略及堆和栈的比较

1 内存分配策略

按照编译原理的观点,程序运行时的内存分配有三种策略,分别是静态的,栈式的,和堆式的.

静态存储分配是指在编译时就能确定每个数据目标在运行时刻的存储空间需求,因而在编译时就可以给他们分配固定的内存空间.这种分配策略要求程序代码中不允许有可变数据结构(比如可变数组)的存在,也不允许有嵌套或者递归的结构出现,因为它们都会导致编译程序无法计算准确的存储空间需求.

栈式存储分配也可称为动态存储分配,是由一个类似于堆栈的运行栈来实现的.和静态存储分配相反,在栈式存储方案中,程序对数据区的需求在编译时是完全未知的,只有到运行的时候才能够知道,但是规定在运行中进入一个程序模块时,必须知道该程序模块所需的数据区大小才能够为其分配内存.和我们在数据结构所熟知的栈一样,栈式存储分配按照先进后出的原则进行分配。

静态存储分配要求在编译时能知道所有变量的存储要求,栈式存储分配要求在过程的入口处必须知道所有的存储要求,而堆式存储分配则专门负责在编译时或运行时模块入口处都无法确定存储要求的数据结构的内存分配,比如可变长度串和对象实例.堆由大片的可利用块或空闲块组成,堆中的内存可以按照任意顺序分配和释放.

2 堆和栈的比较

上面的定义从编译原理的教材中总结而来,除静态存储分配之外,都显得很呆板和难以理解,下面撇开静态存储分配,集中比较堆和栈:

从堆和栈的功能和作用来通俗的比较,堆主要用来存放对象的，栈主要是用来执行程序的.而这种不同又主要是由于堆和栈的特点决定的:

在编程中，例如C/C++中，所有的方法调用都是通过栈来进行的,所有的局部变量,形式参数都是从栈中分配内存空间的。实际上也不是什么分配,只是从栈顶向上用就行,就好像工厂中的传送带(conveyor belt)一样,Stack Pointer会自动指引你到放东西的位置,你所要做的只是把东西放下来就行.退出函数的时候，修改栈指针就可以把栈中的内容销毁.这样的模式速度最快, 当然要用来运行程序了.需要注意的是,在分配的时候,比如为一个即将要调用的程序模块分配数据区时,应事先知道这个数据区的大小,也就说是虽然分配是在程序运行时进行的,但是分配的大小多少是确定的,不变的,而这个”大小多少”是在编译时确定的,不是在运行时.

堆是应用程序在运行的时候请求操作系统分配给自己内存，由于从操作系统管理的内存分配,所以在分配和销毁时都要占用时间，因此用堆的效率非常低.但是堆的优点在于,编译器不必知道要从堆里分配多少存储空间，也不必知道存储的数据要在堆里停留多长的时间,因此,用堆保存数据时会得到更大的灵活性。事实上,面向对象的多态性,堆内存分配是必不可少的,因为多态变量所需的存储空间只有在运行时创建了对象之后才能确定.在C++中，要求创建一个对象时，只需用 new命令编制相关的代码即可。执行这些代码时，会在堆里自动进行数据的保存.当然，为达到这种灵活性，必然会付出一定的代价:在堆里分配存储空间时会花掉更长的时间!这也正是导致我们刚才所说的效率低的原因,看来列宁同志说的好,人的优点往往也是人的缺点,人的缺点往往也是人的优点(晕~).

3 JVM中的堆和栈

JVM是基于堆栈的虚拟机.JVM为每个新创建的线程都分配一个堆栈.也就是说,对于一个Java程序来说，它的运行就是通过对堆栈的操作来完成的。堆栈以帧为单位保存线程的状态。JVM对堆栈只进行两种操作:以帧为单位的压栈和出栈操作。

我们知道,某个线程正在执行的方法称为此线程的当前方法.我们可能不知道,当前方法使用的帧称为当前帧。当线程激活一个Java方法,JVM就会在线程的 Java堆栈里新压入一个帧。这个帧自然成为了当前帧.在此方法执行期间,这个帧将用来保存参数,局部变量,中间计算过程和其他数据.这个帧在这里和编译原理中的活动纪录的概念是差不多的.

从Java的这种分配机制来看,堆栈又可以这样理解:堆栈(Stack)是操作系统在建立某个进程时或者线程(在支持多线程的操作系统中是线程)为这个线程建立的存储区域，该区域具有先进后出的特性。

每一个Java应用都唯一对应一个JVM实例，每一个实例唯一对应一个堆。应用程序在运行中所创建的所有类实例或数组都放在这个堆中,并由应用所有的线程共享.跟C/C++不同，Java中分配堆内存是自动初始化的。Java中所有对象的存储空间都是在堆中分配的，但是这个对象的引用却是在堆栈中分配,也就是说在建立一个对象时从两个地方都分配内存，在堆中分配的内存实际建立这个对象，而在堆栈中分配的内存只是一个指向这个堆对象的指针(引用)而已。

Java 中的堆和栈

Java把内存划分成两种：一种是栈内存，一种是堆内存。

在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。

当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。

堆内存用来存放由new创建的对象和数组。

在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。

在堆中产生了一个数组或对象后，还可以在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量。

引用变量就相当于是为数组或对象起的一个名称，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。

具体的说：

栈与堆都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。

转载自【 Java编程精选】深入理解 Java final 变量的内存模型

Fri, 11 Aug 2017 22:11:15 +0800

对于 final 域，编译器和处理器要遵守两个重排序规则：

在构造函数内对一个 final 域的写，与随后把这个构造对象的引用赋值给一个变量，这两个操作之间不能重排序
初次读一个包含 final 域的对象的引用，与随后初次读这个 final 域，这两个操作之间不能重排序

举个例子：

public class FinalExample {

int i;// 普通变量

final int j;// final 变量

static FinalExample obj;

public FinalExample() {

i = 1;// 写普通域

j = 2;// 写 final 域

}

public static void writer() {// 写线程 A 执行

obj = new FinalExample();

}

public static void reader() {// 读线程 B 执行

FinalExample object = obj;

int a = object.i;

int b = object.j;

}

这里假设一个线程 A 执行 writer ()方法,随后另一个线程 B 执行 reader ()方法。

转载自【Java编程精选】Java Web架构知识整理——记一次阿里面试经历

Thu, 10 Aug 2017 20:47:53 +0800

“你学习一门技术的最佳时机是三年前，其次是现在。”这话从来很灵验。经过这次面试，觉得需要整理下Java Web相关的资料，以便自己提高或者更快适应可能面临的新的工作。

首先谈谈Java Web需要掌握哪些东西。这里是一些知识点的搜集，暂不做详细说明，欢迎各位博友补充指正。

1.底层

Java语言相关的就不说了，首先是JVM的结构和工作原理。比较重要的是Java内存模型，各种GC算法，Classloader的加载原理等。个人对底层的一些东西还算比较了解，所以不过多纠结，实际上程序编译链接过程以及二进制文件的处理还是很值得研究的。
JVM监控及调优。作为一个开发人员并不一定需要非常熟悉JVM调优的方法，但如果具备JVM监控及调优的能力，将让你对程序运行状况了如指掌，对于问题定位也会敏感得多。
Java多线程。对于线程安全的理解，以及如何在自己的程序中避免多线程造成的不一致问题等。
I/O。Java中常常提到的是BIO/NIO，即阻塞型I/O与非阻塞型I/O，其实并不难理解，结合Linux中的同步I/O和异步I/O的实现原理，基本都是相通的，每种I/O方式解决的问题，又存在什么问题，为什么使用epoll。

2.Servlet

Servlet是运行于服务端的java程序，一般实现自己的Java服务端应用都从HttpServlet类继承，然后实现自己的init | doGet | doPost | service方法。Servlet的生命周期从其加载开始，首先执行一次初始化，调用init方法，之后便可运行自身的服务，当生命周期结束时，调用destroy方法回收资源，结束服务。

仅了解原理当然是不够的，还要实战能力，在IDE中写写简单的代码谁都会，然而真正让一个程序能够运行起来也还需要点其他的东西，这里我指的是Servlet的容器。servlet的容器有很多，常用的以Tomcat为例，安装好Tomcat后，在开发时必须包含进Tomcat的lib。IDE确实惯坏了好多人，目录如何组织，程序如何编译、如何部署这些问题都被IDE屏蔽掉了，如果要对整体有比较透彻的了解，建议一切从命令行动手。

具体可参考：《Servlet与JSP核心编程》。

3.框架

Java Web开发的用到的框架之多简直令人发指，而且因为版本的更新换代导致的问题也是层出不穷。然而这也是Web技术不断演化的结果，要么选择接受，要么引领节奏。

Spring

Spring是一个强大而又“轻量级”的Java开发框架，之所以打引号是因为感觉并不是那么轻量。Spring的主要目的在于简化Java应用开发，以配置方式代替硬编码方式的编程，模块解耦，其架构如下图所示。包括了数据访问、远程通信、AOP、核心容器等部分。

Figure 1 Spring体系架构

Spring的核心主要有三点：

IoC：反转控制。

反转控制就是指将控制权由类内部抽离到容器，由容器类的实例化及动作进行配置管理。

Dependency-injection：依赖注入

对象的依赖关系由负责协调系统中各个对象的第三方组件在创建对象时设定。对象不自行创建或管理它们的依赖关系，依赖关系被自动注入到需要它们的对象中。通过参数和配置能够体会出“注入”这个词在这里有多形象。依赖注入的最大好处就是松耦合。不需要再类内部去和特定的类进行绑定，而是将一些依赖关系以参数的形式注入到类内部。

Aspect Oriented Programming：面向切向编程

在软件开发中，分布于应用中多处的功能被称为横切关注点。这些横切关注点往往和业务逻辑是相分离的，将这些横切关注点与业务逻辑相分离正式AOP要解决的。AOP编程能够让遍布在应用各处的功能分离出来形成可重用的组件。是高内聚低耦合的又一个体现，将通用实现模块与核心业务模块相分离。

具体参考：《Spring In Action》

Hibernate

数据持久化框架其实也有很多，需要掌握的不仅是Hibernate，只是因为Hibernate在以前的企业级应用中用的比较多而已，另外MyBatis也占有相当重要的份额。Hibernate是一个全自动的持久化框架，并不是那么方便，所以很多开发者更倾向于使用MyBatis，淘宝就是这样。

Hibernate的工作流程：首先通过configuration对象读取配置文件；解析映射信息，创建StandardSessionFactory；调用openSession打开session；创建事务transaction，之后进行持久化操作；完成后提交事务，关闭session，关闭sessionFactory。

Figuer 2 Hibernate工作流程

要理解ORM的理念：ORM意为对象关系映射。是一种为了解决程序的面向对象模型与数据库关系模型互不匹配问题的技术。

hibernate中比较重要的是对象的4种状态转换及条件。分别是transient瞬时态、persistent持久态、detached游离态和移除态，状态转换如下：

Figure 3 Hibernate对象状态转换图

多线程 on 庞玉栋个人博客

Java面试基础知识--重点

Java后端程序员1年工作经验总结

Java精选笔试题

1，volatile关键字是否能保证线程安全？（）

2，下面哪个流类属于面向字符的输入流( )

Java小技巧，从运行、控制到框架

Java小技巧，从运行、控制到框架

java多线程高级教程，这些你都懂了吗？

Java入门学习进阶知识点汇总

深入解析Java垃圾回收机制

服务端 I/O 性能大比拼：Node、PHP、Java 和 Go

I/O基础知识：快速回顾

系统调用

阻塞调用与非阻塞调用

调度

多线程的方式：Java

死磕 Java 并发 ：Java 内存模型之 happens-before

Java面试常被问到的题目+解答

学习Java需吃透这些基本概念你知道吗？

【分享】Java并发面试题精选

Java面试经验，兼谈互联网公司后端面试经验

Java集合类

Java中堆内存和栈内存详解

转载自【 Java编程精选】深入理解 Java final 变量的内存模型

转载自【Java编程精选】Java Web架构知识整理——记一次阿里面试经历

1.底层

2.Servlet

3.框架

Spring

Hibernate

Struts 2

死磕 Java 并发：Java 内存模型之 happens-before