From 1eeb3abddf458bbb203f2e32e2c0deb75dd6d3d7 Mon Sep 17 00:00:00 2001 From: "hollis.zhl" Date: Sun, 1 Dec 2019 21:12:59 +0800 Subject: [PATCH] =?UTF-8?q?=E5=A2=9E=E5=8A=A0=E9=83=A8=E5=88=86=E7=9F=A5?= =?UTF-8?q?=E8=AF=86=E5=86=85=E5=AE=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 8 +- basics/java-basic/polymorphism.md | 2 +- .../simpledateformat-thread-safe.md | 280 +++++++ basics/java-basic/stack-alloc.md | 166 ++++ basics/java-basic/syntactic-sugar.md | 767 ++++++++++++++++++ basics/jvm/stack-alloc.md | 166 ++++ 6 files changed, 1384 insertions(+), 5 deletions(-) create mode 100644 basics/java-basic/simpledateformat-thread-safe.md create mode 100644 basics/java-basic/stack-alloc.md create mode 100644 basics/java-basic/syntactic-sugar.md create mode 100644 basics/jvm/stack-alloc.md diff --git a/README.md b/README.md index fc0e3d5..3484d7c 100644 --- a/README.md +++ b/README.md @@ -233,7 +233,7 @@ finally和return的执行顺序 格林威治时间、CET,UTC,GMT,CST几种常见时间的含义和关系 -SimpleDateFormat的线程安全性问题 +[SimpleDateFormat的线程安全性问题](/basics/java-basic/simpledateformat-thread-safe.md) Java 8中的时间处理 @@ -253,9 +253,9 @@ URL编解码、Big Endian和Little Endian #### 语法糖 -Java中语法糖原理、解语法糖 +[Java中语法糖原理、解语法糖](/basics/java-basic/syntactic-sugar.md) -语法糖：switch 支持 String 与枚举、泛型、自动装箱与拆箱、方法变长参数、枚举、内部类、条件编译、 断言、数值字面量、for-each、try-with-resource、Lambda表达式、 +[语法糖：switch 支持 String 与枚举、泛型、自动装箱与拆箱、方法变长参数、枚举、内部类、条件编译、 断言、数值字面量、for-each、try-with-resource、Lambda表达式](/basics/java-basic/syntactic-sugar.md) ### 阅读源代码 @@ -345,7 +345,7 @@ class文件格式、运行时数据区：堆、栈、方法区、直接内存、 堆和栈区别 -Java中的对象一定在堆上分配吗？ +[Java中的对象一定在堆上分配吗？](/basics/jvm/stack-alloc.md) #### Java内存模型 diff --git a/basics/java-basic/polymorphism.md b/basics/java-basic/polymorphism.md index e67ec85..2e9e8b1 100644 --- a/basics/java-basic/polymorphism.md +++ b/basics/java-basic/polymorphism.md @@ -1,4 +1,4 @@ -###什么是多态，多态有什么好处，多态的必要条件是什么、Java中多态的实现方式 +### 什么是多态，多态有什么好处，多态的必要条件是什么、Java中多态的实现方式 多态的概念呢比较简单，就是同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。 diff --git a/basics/java-basic/simpledateformat-thread-safe.md b/basics/java-basic/simpledateformat-thread-safe.md new file mode 100644 index 0000000..7e8e424 --- /dev/null +++ b/basics/java-basic/simpledateformat-thread-safe.md @@ -0,0 +1,280 @@ +在日常开发中，我们经常会用到时间，我们有很多办法在Java代码中获取时间。但是不同的方法获取到的时间的格式都不尽相同，这时候就需要一种格式化工具，把时间显示成我们需要的格式。 + +最常用的方法就是使用SimpleDateFormat类。这是一个看上去功能比较简单的类，但是，一旦使用不当也有可能导致很大的问题。 + +在阿里巴巴Java开发手册中，有如下明确规定： + + + +那么，本文就围绕SimpleDateFormat的用法、原理等来深入分析下如何以正确的姿势使用它。 + +### SimpleDateFormat用法 + +SimpleDateFormat是Java提供的一个格式化和解析日期的工具类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。SimpleDateFormat 使得可以选择任何用户定义的日期-时间格式的模式。 + +在Java中，可以使用SimpleDateFormat的format方法，将一个Date类型转化成String类型，并且可以指定输出格式。 + + // Date转String + Date data = new Date(); + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + String dataStr = sdf.format(data); + System.out.println(dataStr); + + +以上代码，转换的结果是：2018-11-25 13:00:00，日期和时间格式由"日期和时间模式"字符串指定。如果你想要转换成其他格式，只要指定不同的时间模式就行了。 + +在Java中，可以使用SimpleDateFormat的parse方法，将一个String类型转化成Date类型。 + + // String转Data + System.out.println(sdf.parse(dataStr)); + + +#### 日期和时间模式表达方法 + +在使用SimpleDateFormat的时候，需要通过字母来描述时间元素，并组装成想要的日期和时间模式。常用的时间元素和字母的对应表如下： + +![-w717][1] + +模式字母通常是重复的，其数量确定其精确表示。如下表是常用的输出格式的表示方法。 + +![-w535][2] + +#### 输出不同时区的时间 + +时区是地球上的区域使用同一个时间定义。以前，人们通过观察太阳的位置（时角）决定时间，这就使得不同经度的地方的时间有所不同（地方时）。1863年，首次使用时区的概念。时区通过设立一个区域的标准时间部分地解决了这个问题。 + +世界各个国家位于地球不同位置上，因此不同国家，特别是东西跨度大的国家日出、日落时间必定有所偏差。这些偏差就是所谓的时差。 + +现今全球共分为24个时区。由于实用上常常1个国家，或1个省份同时跨着2个或更多时区，为了照顾到行政上的方便，常将1个国家或1个省份划在一起。所以时区并不严格按南北直线来划分，而是按自然条件来划分。例如，中国幅员宽广，差不多跨5个时区，但为了使用方便简单，实际上在只用东八时区的标准时即北京时间为准。 + +由于不同的时区的时间是不一样的，甚至同一个国家的不同城市时间都可能不一样，所以，在Java中想要获取时间的时候，要重点关注一下时区问题。 + +默认情况下，如果不指明，在创建日期的时候，会使用当前计算机所在的时区作为默认时区，这也是为什么我们通过只要使用`new Date()`就可以获取中国的当前时间的原因。 + +那么，如何在Java代码中获取不同时区的时间呢？SimpleDateFormat可以实现这个功能。 + + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + sdf.setTimeZone(TimeZone.getTimeZone("America/Los_Angeles")); + System.out.println(sdf.format(Calendar.getInstance().getTime())); + + +以上代码，转换的结果是： 2018-11-24 21:00:00 。既中国的时间是11月25日的13点，而美国洛杉矶时间比中国北京时间慢了16个小时（这还和冬夏令时有关系，就不详细展开了）。 + +> 如果你感兴趣，你还可以尝试打印一下美国纽约时间（America/New_York）。纽约时间是2018-11-25 00:00:00。纽约时间比中国北京时间早了13个小时。 + +当然，这不是显示其他时区的唯一方法，不过本文主要为了介绍SimpleDateFormat，其他方法暂不介绍了。 + +## SimpleDateFormat线程安全性 + +由于SimpleDateFormat比较常用，而且在一般情况下，一个应用中的时间显示模式都是一样的，所以很多人愿意使用如下方式定义SimpleDateFormat： + + public class Main { + + private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + + public static void main(String[] args) { + simpleDateFormat.setTimeZone(TimeZone.getTimeZone("America/New_York")); + System.out.println(simpleDateFormat.format(Calendar.getInstance().getTime())); + } + } + + +**这种定义方式，存在很大的安全隐患。** + +#### 问题重现 + +我们来看一段代码，以下代码使用线程池来执行时间输出。 + + /** * @author Hollis */ + public class Main { + + /** + * 定义一个全局的SimpleDateFormat + */ + private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + + /** + * 使用ThreadFactoryBuilder定义一个线程池 + */ + private static ThreadFactory namedThreadFactory = new ThreadFactoryBuilder() + .setNameFormat("demo-pool-%d").build(); + + private static ExecutorService pool = new ThreadPoolExecutor(5, 200, + 0L, TimeUnit.MILLISECONDS, + new LinkedBlockingQueue(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy()); + + /** + * 定义一个CountDownLatch，保证所有子线程执行完之后主线程再执行 + */ + private static CountDownLatch countDownLatch = new CountDownLatch(100); + + public static void main(String[] args) { + //定义一个线程安全的HashSet + Set dates = Collections.synchronizedSet(new HashSet()); + for (int i = 0; i < 100; i++) { + //获取当前时间 + Calendar calendar = Calendar.getInstance(); + int finalI = i; + pool.execute(() -> { + //时间增加 + calendar.add(Calendar.DATE, finalI); + //通过simpleDateFormat把时间转换成字符串 + String dateString = simpleDateFormat.format(calendar.getTime()); + //把字符串放入Set中 + dates.add(dateString); + //countDown + countDownLatch.countDown(); + }); + } + //阻塞，直到countDown数量为0 + countDownLatch.await(); + //输出去重后的时间个数 + System.out.println(dates.size()); + } + } + + +以上代码，其实比较简单，很容易理解。就是循环一百次，每次循环的时候都在当前时间基础上增加一个天数（这个天数随着循环次数而变化），然后把所有日期放入一个**线程安全的**、**带有去重功能**的Set中，然后输出Set中元素个数。 + +> 上面的例子我特意写的稍微复杂了一些，不过我几乎都加了注释。这里面涉及到了[线程池的创建][3]、[CountDownLatch][4]、lambda表达式、线程安全的HashSet等知识。感兴趣的朋友可以逐一了解一下。 + +正常情况下，以上代码输出结果应该是100。但是实际执行结果是一个小于100的数字。 + +原因就是因为SimpleDateFormat作为一个非线程安全的类，被当做了共享变量在多个线程中进行使用，这就出现了线程安全问题。 + +在阿里巴巴Java开发手册的第一章第六节——并发处理中关于这一点也有明确说明： + + + +那么，接下来我们就来看下到底是为什么，以及该如何解决。 + +#### 线程不安全原因 + +通过以上代码，我们发现了在并发场景中使用SimpleDateFormat会有线程安全问题。其实，JDK文档中已经明确表明了SimpleDateFormat不应该用在多线程场景中： + +> Date formats are not synchronized. It is recommended to create separate format instances for each thread. If multiple threads access a format concurrently, it must be synchronized externally. + +那么接下来分析下为什么会出现这种问题，SimpleDateFormat底层到底是怎么实现的？ + +我们跟一下SimpleDateFormat类中format方法的实现其实就能发现端倪。 + +![][5] + +SimpleDateFormat中的format方法在执行过程中，会使用一个成员变量calendar来保存时间。这其实就是问题的关键。 + +由于我们在声明SimpleDateFormat的时候，使用的是static定义的。那么这个SimpleDateFormat就是一个共享变量，随之，SimpleDateFormat中的calendar也就可以被多个线程访问到。 + +假设线程1刚刚执行完`calendar.setTime`把时间设置成2018-11-11，还没等执行完，线程2又执行了`calendar.setTime`把时间改成了2018-12-12。这时候线程1继续往下执行，拿到的`calendar.getTime`得到的时间就是线程2改过之后的。 + +除了format方法以外，SimpleDateFormat的parse方法也有同样的问题。 + +所以，不要把SimpleDateFormat作为一个共享变量使用。 + +#### 如何解决 + +前面介绍过了SimpleDateFormat存在的问题以及问题存在的原因，那么有什么办法解决这种问题呢？ + +解决方法有很多，这里介绍三个比较常用的方法。 + +**使用局部变量** + + for (int i = 0; i < 100; i++) { + //获取当前时间 + Calendar calendar = Calendar.getInstance(); + int finalI = i; + pool.execute(() -> { + // SimpleDateFormat声明成局部变量 + SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + //时间增加 + calendar.add(Calendar.DATE, finalI); + //通过simpleDateFormat把时间转换成字符串 + String dateString = simpleDateFormat.format(calendar.getTime()); + //把字符串放入Set中 + dates.add(dateString); + //countDown + countDownLatch.countDown(); + }); + } + + +SimpleDateFormat变成了局部变量，就不会被多个线程同时访问到了，就避免了线程安全问题。 + +**加同步锁** + +除了改成局部变量以外，还有一种方法大家可能比较熟悉的，就是对于共享变量进行加锁。 + + for (int i = 0; i < 100; i++) { + //获取当前时间 + Calendar calendar = Calendar.getInstance(); + int finalI = i; + pool.execute(() -> { + //加锁 + synchronized (simpleDateFormat) { + //时间增加 + calendar.add(Calendar.DATE, finalI); + //通过simpleDateFormat把时间转换成字符串 + String dateString = simpleDateFormat.format(calendar.getTime()); + //把字符串放入Set中 + dates.add(dateString); + //countDown + countDownLatch.countDown(); + } + }); + } + + +通过加锁，使多个线程排队顺序执行。避免了并发导致的线程安全问题。 + +其实以上代码还有可以改进的地方，就是可以把锁的粒度再设置的小一点，可以只对`simpleDateFormat.format`这一行加锁，这样效率更高一些。 + +**使用ThreadLocal** + +第三种方式，就是使用 ThreadLocal。 ThreadLocal 可以确保每个线程都可以得到单独的一个 SimpleDateFormat 的对象，那么自然也就不存在竞争问题了。 + + /** + * 使用ThreadLocal定义一个全局的SimpleDateFormat + */ + private static ThreadLocal simpleDateFormatThreadLocal = new ThreadLocal() { + @Override + protected SimpleDateFormat initialValue() { + return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + } + }; + + //用法 + String dateString = simpleDateFormatThreadLocal.get().format(calendar.getTime()); + + +用 ThreadLocal 来实现其实是有点类似于缓存的思路，每个线程都有一个独享的对象，避免了频繁创建对象，也避免了多线程的竞争。 + +当然，以上代码也有改进空间，就是，其实SimpleDateFormat的创建过程可以改为延迟加载。这里就不详细介绍了。 + +**使用DateTimeFormatter** + +如果是Java8应用，可以使用DateTimeFormatter代替SimpleDateFormat，这是一个线程安全的格式化工具类。就像官方文档中说的，这个类 simple beautiful strong immutable thread-safe。 + + //解析日期 + String dateStr= "2016年10月25日"; + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日"); + LocalDate date= LocalDate.parse(dateStr, formatter); + + //日期转换为字符串 + LocalDateTime now = LocalDateTime.now(); + DateTimeFormatter format = DateTimeFormatter.ofPattern("yyyy年MM月dd日 hh:mm a"); + String nowStr = now .format(format); + System.out.println(nowStr); + + +### 总结 + +本文介绍了SimpleDateFormat的用法，SimpleDateFormat主要可以在String和Date之间做转换，还可以将时间转换成不同时区输出。同时提到在并发场景中SimpleDateFormat是不能保证线程安全的，需要开发者自己来保证其安全性。 + +主要的几个手段有改为局部变量、使用synchronized加锁、使用Threadlocal为每一个线程单独创建一个等。 + +希望通过此文，你可以在使用SimpleDateFormat的时候更加得心应手。 + + [1]: https://www.hollischuang.com/wp-content/uploads/2018/11/15431240092595.jpg + [2]: https://www.hollischuang.com/wp-content/uploads/2018/11/15431240361504.jpg + [3]: https://www.hollischuang.com/archives/2888 + [4]: https://www.hollischuang.com/archives/290 + [5]: https://www.hollischuang.com/wp-content/uploads/2018/11/15431313894397.jpg \ No newline at end of file diff --git a/basics/java-basic/stack-alloc.md b/basics/java-basic/stack-alloc.md new file mode 100644 index 0000000..eb00b21 --- /dev/null +++ b/basics/java-basic/stack-alloc.md @@ -0,0 +1,166 @@ +### JVM内存分配策略 + +关于JVM的内存结构及内存分配方式，不是本文的重点，这里只做简单回顾。以下是我们知道的一些常识： + +1、根据Java虚拟机规范，Java虚拟机所管理的内存包括方法区、虚拟机栈、本地方法栈、堆、程序计数器等。 + +2、我们通常认为JVM中运行时数据存储包括堆和栈。这里所提到的栈其实指的是虚拟机栈，或者说是虚拟栈中的局部变量表。 + +3、栈中存放一些基本类型的变量数据（int/short/long/byte/float/double/Boolean/char）和对象引用。 + +4、堆中主要存放对象，即通过new关键字创建的对象。 + +5、数组引用变量是存放在栈内存中，数组元素是存放在堆内存中。 + +在《深入理解Java虚拟机中》关于Java堆内存有这样一段描述： + +但是，随着JIT编译期的发展与逃逸分析技术逐渐成熟，栈上分配、标量替换优化技术将会导致一些微妙的变化，所有的对象都分配到堆上也渐渐变得不那么“绝对”了。 + +这里只是简单提了一句，并没有深入分析，很多人看到这里由于对JIT、逃逸分析等技术不了解，所以也无法真正理解上面这段话的含义。 + +**PS：这里默认大家都了解什么是JIT，不了解的朋友可以先自行Google了解下，或者加入我的知识星球，阅读那篇球友专享文章。** + +其实，在编译期间，JIT会对代码做很多优化。其中有一部分优化的目的就是减少内存堆分配压力，其中一种重要的技术叫做**逃逸分析**。 + +### 逃逸分析 + +逃逸分析(Escape Analysis)是目前Java虚拟机中比较前沿的优化技术。这是一种可以有效减少Java 程序中同步负载和内存堆分配压力的跨函数全局数据流分析算法。通过逃逸分析，Java Hotspot编译器能够分析出一个新的对象的引用的使用范围从而决定是否要将这个对象分配到堆上。 + +逃逸分析的基本行为就是分析对象动态作用域：当一个对象在方法中被定义后，它可能被外部方法所引用，例如作为调用参数传递到其他地方中，称为方法逃逸。 + +例如： + + public static StringBuffer craeteStringBuffer(String s1, String s2) { + StringBuffer sb = new StringBuffer(); + sb.append(s1); + sb.append(s2); + return sb; + } + + +StringBuffer sb是一个方法内部变量，上述代码中直接将sb返回，这样这个StringBuffer有可能被其他方法所改变，这样它的作用域就不只是在方法内部，虽然它是一个局部变量，称其逃逸到了方法外部。甚至还有可能被外部线程访问到，譬如赋值给类变量或可以在其他线程中访问的实例变量，称为线程逃逸。 + +上述代码如果想要StringBuffer sb不逃出方法，可以这样写： + + public static String createStringBuffer(String s1, String s2) { + StringBuffer sb = new StringBuffer(); + sb.append(s1); + sb.append(s2); + return sb.toString(); + } + + +不直接返回 StringBuffer，那么StringBuffer将不会逃逸出方法。 + +使用逃逸分析，编译器可以对代码做如下优化： + +一、同步省略。如果一个对象被发现只能从一个线程被访问到，那么对于这个对象的操作可以不考虑同步。 + +二、将堆分配转化为栈分配。如果一个对象在子程序中被分配，要使指向该对象的指针永远不会逃逸，对象可能是栈分配的候选，而不是堆分配。 + +三、分离对象或标量替换。有的对象可能不需要作为一个连续的内存结构存在也可以被访问到，那么对象的部分（或全部）可以不存储在内存，而是存储在CPU寄存器中。 + +上面的关于同步省略的内容，我在《[深入理解多线程（五）—— Java虚拟机的锁优化技术][1]》中有介绍过，即锁优化中的锁消除技术，依赖的也是逃逸分析技术。 + +本文，主要来介绍逃逸分析的第二个用途：将堆分配转化为栈分配。 + +> 其实，以上三种优化中，栈上内存分配其实是依靠标量替换来实现的。由于不是本文重点，这里就不展开介绍了。如果大家感兴趣，我后面专门出一篇文章，全面介绍下逃逸分析。 + +在Java代码运行时，通过JVM参数可指定是否开启逃逸分析， `-XX:+DoEscapeAnalysis` ： 表示开启逃逸分析 `-XX:-DoEscapeAnalysis` ： 表示关闭逃逸分析 从jdk 1.7开始已经默认开始逃逸分析，如需关闭，需要指定`-XX:-DoEscapeAnalysis` + +### 对象的栈上内存分配 + +我们知道，在一般情况下，对象和数组元素的内存分配是在堆内存上进行的。但是随着JIT编译器的日渐成熟，很多优化使这种分配策略并不绝对。JIT编译器就可以在编译期间根据逃逸分析的结果，来决定是否可以将对象的内存分配从堆转化为栈。 + +我们来看以下代码： + + public static void main(String[] args) { + long a1 = System.currentTimeMillis(); + for (int i = 0; i < 1000000; i++) { + alloc(); + } + // 查看执行时间 + long a2 = System.currentTimeMillis(); + System.out.println("cost " + (a2 - a1) + " ms"); + // 为了方便查看堆内存中对象个数，线程sleep + try { + Thread.sleep(100000); + } catch (InterruptedException e1) { + e1.printStackTrace(); + } + } + + private static void alloc() { + User user = new User(); + } + + static class User { + + } + + +其实代码内容很简单，就是使用for循环，在代码中创建100万个User对象。 + +**我们在alloc方法中定义了User对象，但是并没有在方法外部引用他。也就是说，这个对象并不会逃逸到alloc外部。经过JIT的逃逸分析之后，就可以对其内存分配进行优化。** + +我们指定以下JVM参数并运行： + + -Xmx4G -Xms4G -XX:-DoEscapeAnalysis -XX:+PrintGCDetails -XX:+HeapDumpOnOutOfMemoryError + + +在程序打印出 `cost XX ms` 后，代码运行结束之前，我们使用`[jmap][1]`命令，来查看下当前堆内存中有多少个User对象： + + ➜ ~ jps + 2809 StackAllocTest + 2810 Jps + ➜ ~ jmap -histo 2809 + + num #instances #bytes class name + ---------------------------------------------- + 1: 524 87282184 [I + 2: 1000000 16000000 StackAllocTest$User + 3: 6806 2093136 [B + 4: 8006 1320872 [C + 5: 4188 100512 java.lang.String + 6: 581 66304 java.lang.Class + + +从上面的jmap执行结果中我们可以看到，堆中共创建了100万个`StackAllocTest$User`实例。 + +在关闭逃避分析的情况下（-XX:-DoEscapeAnalysis），虽然在alloc方法中创建的User对象并没有逃逸到方法外部，但是还是被分配在堆内存中。也就说，如果没有JIT编译器优化，没有逃逸分析技术，正常情况下就应该是这样的。即所有对象都分配到堆内存中。 + +接下来，我们开启逃逸分析，再来执行下以上代码。 + + -Xmx4G -Xms4G -XX:+DoEscapeAnalysis -XX:+PrintGCDetails -XX:+HeapDumpOnOutOfMemoryError + + +在程序打印出 `cost XX ms` 后，代码运行结束之前，我们使用`jmap`命令，来查看下当前堆内存中有多少个User对象： + + ➜ ~ jps + 709 + 2858 Launcher + 2859 StackAllocTest + 2860 Jps + ➜ ~ jmap -histo 2859 + + num #instances #bytes class name + ---------------------------------------------- + 1: 524 101944280 [I + 2: 6806 2093136 [B + 3: 83619 1337904 StackAllocTest$User + 4: 8006 1320872 [C + 5: 4188 100512 java.lang.String + 6: 581 66304 java.lang.Class + + +从以上打印结果中可以发现，开启了逃逸分析之后（-XX:+DoEscapeAnalysis），在堆内存中只有8万多个`StackAllocTest$User`对象。也就是说在经过JIT优化之后，堆内存中分配的对象数量，从100万降到了8万。 + +> 除了以上通过jmap验证对象个数的方法以外，读者还可以尝试将堆内存调小，然后执行以上代码，根据GC的次数来分析，也能发现，开启了逃逸分析之后，在运行期间，GC次数会明显减少。正是因为很多堆上分配被优化成了栈上分配，所以GC次数有了明显的减少。 + +### 总结 + +所以，如果以后再有人问你：是不是所有的对象和数组都会在堆内存分配空间？ + +那么你可以告诉他：不一定，随着JIT编译器的发展，在编译期间，如果JIT经过逃逸分析，发现有些对象没有逃逸出方法，那么有可能堆内存分配会被优化成栈内存分配。但是这也并不是绝对的。就像我们前面看到的一样，在开启逃逸分析之后，也并不是所有User对象都没有在堆上分配。 + + [1]: http://www.hollischuang.com/archives/2344 \ No newline at end of file diff --git a/basics/java-basic/syntactic-sugar.md b/basics/java-basic/syntactic-sugar.md new file mode 100644 index 0000000..0a31bf1 --- /dev/null +++ b/basics/java-basic/syntactic-sugar.md @@ -0,0 +1,767 @@ + + +语法糖（Syntactic Sugar），也称糖衣语法，是由英国计算机学家 Peter.J.Landin 发明的一个术语，指在计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。 + +本 Chat 从 Java 编译原理角度，深入字节码及 class 文件，抽丝剥茧，了解 Java 中的语法糖原理及用法，帮助大家在学会如何使用 Java 语法糖的同时，了解这些语法糖背后的原理，主要内容如下： + +什么是语法糖 糖块一 —— switch 支持 String 与枚举 糖块二 —— 泛型与类型擦除 糖块三 —— 自动装箱与拆箱 ...... 糖块十一 —— try-with-resource 糖块十二 —— lambda 表达式 糖衣炮弹 —— 语法糖使用过程中需要注意的点 综合应用 + + +### 语法糖 + +语法糖（Syntactic Sugar），也称糖衣语法，是由英国计算机学家 Peter.J.Landin 发明的一个术语，指在计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。简而言之，语法糖让程序更加简洁，有更高的可读性。 + +> 有意思的是，在编程领域，除了语法糖，还有语法盐和语法糖精的说法，篇幅有限这里不做扩展了。 + +我们所熟知的编程语言中几乎都有语法糖。作者认为，语法糖的多少是评判一个语言够不够牛逼的标准之一。很多人说Java是一个“低糖语言”，其实从Java 7开始Java语言层面上一直在添加各种糖，主要是在“Project Coin”项目下研发。尽管现在Java有人还是认为现在的Java是低糖，未来还会持续向着“高糖”的方向发展。 + +### 解语法糖 + +前面提到过，语法糖的存在主要是方便开发人员使用。但其实，Java虚拟机并不支持这些语法糖。这些语法糖在编译阶段就会被还原成简单的基础语法结构，这个过程就是解语法糖。 + +说到编译，大家肯定都知道，Java语言中，`javac`命令可以将后缀名为`.java`的源文件编译为后缀名为`.class`的可以运行于Java虚拟机的字节码。如果你去看`com.sun.tools.javac.main.JavaCompiler`的源码，你会发现在`compile()`中有一个步骤就是调用`desugar()`，这个方法就是负责解语法糖的实现的。 + +Java 中最常用的语法糖主要有泛型、变长参数、条件编译、自动拆装箱、内部类等。本文主要来分析下这些语法糖背后的原理。一步一步剥去糖衣，看看其本质。 + +### 糖块一、 switch 支持 String 与枚举 + +前面提到过，从Java 7 开始，Java语言中的语法糖在逐渐丰富，其中一个比较重要的就是Java 7中`switch`开始支持`String`。 + +在开始coding之前先科普下，Java中的`swith`自身原本就支持基本类型。比如`int`、`char`等。对于`int`类型，直接进行数值的比较。对于`char`类型则是比较其ascii码。所以，对于编译器来说，`switch`中其实只能使用整型，任何类型的比较都要转换成整型。比如`byte`。`short`，`char`(ackii码是整型)以及`int`。 + +那么接下来看下`switch`对`String`得支持，有以下代码： + + public class switchDemoString { + public static void main(String[] args) { + String str = "world"; + switch (str) { + case "hello": + System.out.println("hello"); + break; + case "world": + System.out.println("world"); + break; + default: + break; + } + } + } + + +[反编译][1]后内容如下： + + public class switchDemoString + { + public switchDemoString() + { + } + public static void main(String args[]) + { + String str = "world"; + String s; + switch((s = str).hashCode()) + { + default: + break; + case 99162322: + if(s.equals("hello")) + System.out.println("hello"); + break; + case 113318802: + if(s.equals("world")) + System.out.println("world"); + break; + } + } + } + + +看到这个代码，你知道原来**字符串的switch是通过`equals()`和`hashCode()`方法来实现的。**还好`hashCode()`方法返回的是`int`，而不是`long`。 + +> 仔细看下可以发现，进行`switch`的实际是哈希值，然后通过使用`equals`方法比较进行安全检查，这个检查是必要的，因为哈希可能会发生碰撞。因此它的性能是不如使用枚举进行switch或者使用纯整数常量，但这也不是很差。 + +### 糖块二、 泛型 + +我们都知道，很多语言都是支持泛型的，但是很多人不知道的是，不同的编译器对于泛型的处理方式是不同的，通常情况下，一个编译器处理泛型有两种方式：`Code specialization`和`Code sharing`。C++和C#是使用`Code specialization`的处理机制，而Java使用的是`Code sharing`的机制。 + +> Code sharing方式为每个泛型类型创建唯一的字节码表示，并且将该泛型类型的实例都映射到这个唯一的字节码表示上。将多种泛型类形实例映射到唯一的字节码表示是通过类型擦除（`type erasue`）实现的。 + +也就是说，**对于Java虚拟机来说，他根本不认识`Map map`这样的语法。需要在编译阶段通过类型擦除的方式进行解语法糖。** + +类型擦除的主要过程如下： 1.将所有的泛型参数用其最左边界（最顶级的父类型）类型替换。 2.移除所有的类型参数。 + +以下代码： + + Map map = new HashMap(); + map.put("name", "hollis"); + map.put("wechat", "Hollis"); + map.put("blog", "www.hollischuang.com"); + + +解语法糖之后会变成： + + Map map = new HashMap(); + map.put("name", "hollis"); + map.put("wechat", "Hollis"); + map.put("blog", "www.hollischuang.com"); + + +以下代码： + + public static > A max(Collection xs) { + Iterator xi = xs.iterator(); + A w = xi.next(); + while (xi.hasNext()) { + A x = xi.next(); + if (w.compareTo(x) < 0) + w = x; + } + return w; + } + + +类型擦除后会变成： + + public static Comparable max(Collection xs){ + Iterator xi = xs.iterator(); + Comparable w = (Comparable)xi.next(); + while(xi.hasNext()) + { + Comparable x = (Comparable)xi.next(); + if(w.compareTo(x) < 0) + w = x; + } + return w; + } + + +**虚拟机中没有泛型，只有普通类和普通方法，所有泛型类的类型参数在编译时都会被擦除，泛型类并没有自己独有的`Class`类对象。比如并不存在`List.class`或是`List.class`，而只有`List.class`。** + +### 糖块三、 自动装箱与拆箱 + +自动装箱就是Java自动将原始类型值转换成对应的对象，比如将int的变量转换成Integer对象，这个过程叫做装箱，反之将Integer对象转换成int类型值，这个过程叫做拆箱。因为这里的装箱和拆箱是自动进行的非人为转换，所以就称作为自动装箱和拆箱。原始类型byte, short, char, int, long, float, double 和 boolean 对应的封装类为Byte, Short, Character, Integer, Long, Float, Double, Boolean。 + +先来看个自动装箱的代码： + + public static void main(String[] args) { + int i = 10; + Integer n = i; + } + + +反编译后代码如下: + + public static void main(String args[]) + { + int i = 10; + Integer n = Integer.valueOf(i); + } + + +再来看个自动拆箱的代码： + + public static void main(String[] args) { + + Integer i = 10; + int n = i; + } + + +反编译后代码如下： + + public static void main(String args[]) + { + Integer i = Integer.valueOf(10); + int n = i.intValue(); + } + + +从反编译得到内容可以看出，在装箱的时候自动调用的是`Integer`的`valueOf(int)`方法。而在拆箱的时候自动调用的是`Integer`的`intValue`方法。 + +所以，**装箱过程是通过调用包装器的valueOf方法实现的，而拆箱过程是通过调用包装器的 xxxValue方法实现的。** + +### 糖块四 、 方法变长参数 + +可变参数(`variable arguments`)是在Java 1.5中引入的一个特性。它允许一个方法把任意数量的值作为参数。 + +看下以下可变参数代码，其中print方法接收可变参数： + + public static void main(String[] args) + { + print("Holis", "公众号:Hollis", "博客：www.hollischuang.com", "QQ：907607222"); + } + + public static void print(String... strs) + { + for (int i = 0; i < strs.length; i++) + { + System.out.println(strs[i]); + } + } + + +反编译后代码： + + public static void main(String args[]) + { + print(new String[] { + "Holis", "\u516C\u4F17\u53F7:Hollis", "\u535A\u5BA2\uFF1Awww.hollischuang.com", "QQ\uFF1A907607222" + }); + } + + public static transient void print(String strs[]) + { + for(int i = 0; i < strs.length; i++) + System.out.println(strs[i]); + + } + + +从反编译后代码可以看出，可变参数在被使用的时候，他首先会创建一个数组，数组的长度就是调用该方法是传递的实参的个数，然后再把参数值全部放到这个数组当中，然后再把这个数组作为参数传递到被调用的方法中。 + +> PS：反编译后的print方法声明中有一个transient标识，是不是很奇怪？transient不是不可以修饰方法吗？transient不是和序列化有关么？transient在这里的作用是什么？因为这个与本文关系不大，这里不做深入分析了。相了解的同学可以关注我微信公众号或者博客。 + +### 糖块五 、 枚举 + +Java SE5提供了一种新的类型-Java的枚举类型，关键字`enum`可以将一组具名的值的有限集合创建为一种新的类型，而这些具名的值可以作为常规的程序组件使用，这是一种非常有用的功能。 + +要想看源码，首先得有一个类吧，那么枚举类型到底是什么类呢？是`enum`吗？答案很明显不是，`enum`就和`class`一样，只是一个关键字，他并不是一个类，那么枚举是由什么类维护的呢，我们简单的写一个枚举： + + public enum t { + SPRING,SUMMER; + } + + +然后我们使用反编译，看看这段代码到底是怎么实现的，反编译后代码内容如下： + + public final class T extends Enum + { + private T(String s, int i) + { + super(s, i); + } + public static T[] values() + { + T at[]; + int i; + T at1[]; + System.arraycopy(at = ENUM$VALUES, 0, at1 = new T[i = at.length], 0, i); + return at1; + } + + public static T valueOf(String s) + { + return (T)Enum.valueOf(demo/T, s); + } + + public static final T SPRING; + public static final T SUMMER; + private static final T ENUM$VALUES[]; + static + { + SPRING = new T("SPRING", 0); + SUMMER = new T("SUMMER", 1); + ENUM$VALUES = (new T[] { + SPRING, SUMMER + }); + } + } + + +通过反编译后代码我们可以看到，`public final class T extends Enum`，说明，该类是继承了`Enum`类的，同时`final`关键字告诉我们，这个类也是不能被继承的。**当我们使用`enmu`来定义一个枚举类型的时候，编译器会自动帮我们创建一个`final`类型的类继承`Enum`类，所以枚举类型不能被继承。** + +### 糖块六 、 内部类 + +内部类又称为嵌套类，可以把内部类理解为外部类的一个普通成员。 + +**内部类之所以也是语法糖，是因为它仅仅是一个编译时的概念，`outer.java`里面定义了一个内部类`inner`，一旦编译成功，就会生成两个完全不同的`.class`文件了，分别是`outer.class`和`outer$inner.class`。所以内部类的名字完全可以和它的外部类名字相同。** + + public class OutterClass { + private String userName; + + public String getUserName() { + return userName; + } + + public void setUserName(String userName) { + this.userName = userName; + } + + public static void main(String[] args) { + + } + + class InnerClass{ + private String name; + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + } + } + + +以上代码编译后会生成两个class文件：`OutterClass$InnerClass.class` 、`OutterClass.class` 。当我们尝试对`OutterClass.class`文件进行反编译的时候，命令行会打印以下内容：`Parsing OutterClass.class...Parsing inner class OutterClass$InnerClass.class... Generating OutterClass.jad` 。他会把两个文件全部进行反编译，然后一起生成一个`OutterClass.jad`文件。文件内容如下： + + public class OutterClass + { + class InnerClass + { + public String getName() + { + return name; + } + public void setName(String name) + { + this.name = name; + } + private String name; + final OutterClass this$0; + + InnerClass() + { + this.this$0 = OutterClass.this; + super(); + } + } + + public OutterClass() + { + } + public String getUserName() + { + return userName; + } + public void setUserName(String userName){ + this.userName = userName; + } + public static void main(String args1[]) + { + } + private String userName; + } + + +### 糖块七 、条件编译 + +—般情况下，程序中的每一行代码都要参加编译。但有时候出于对程序代码优化的考虑，希望只对其中一部分内容进行编译，此时就需要在程序中加上条件，让编译器只对满足条件的代码进行编译，将不满足条件的代码舍弃，这就是条件编译。 + +如在C或CPP中，可以通过预处理语句来实现条件编译。其实在Java中也可实现条件编译。我们先来看一段代码： + + public class ConditionalCompilation { + public static void main(String[] args) { + final boolean DEBUG = true; + if(DEBUG) { + System.out.println("Hello, DEBUG!"); + } + + final boolean ONLINE = false; + + if(ONLINE){ + System.out.println("Hello, ONLINE!"); + } + } + } + + +反编译后代码如下： + + public class ConditionalCompilation + { + + public ConditionalCompilation() + { + } + + public static void main(String args[]) + { + boolean DEBUG = true; + System.out.println("Hello, DEBUG!"); + boolean ONLINE = false; + } + } + + +首先，我们发现，在反编译后的代码中没有`System.out.println("Hello, ONLINE!");`，这其实就是条件编译。当`if(ONLINE)`为false的时候，编译器就没有对其内的代码进行编译。 + +所以，**Java语法的条件编译，是通过判断条件为常量的if语句实现的。其原理也是Java语言的语法糖。根据if判断条件的真假，编译器直接把分支为false的代码块消除。通过该方式实现的条件编译，必须在方法体内实现，而无法在正整个Java类的结构或者类的属性上进行条件编译，这与C/C++的条件编译相比，确实更有局限性。在Java语言设计之初并没有引入条件编译的功能，虽有局限，但是总比没有更强。** + +### 糖块八 、 断言 + +在Java中，`assert`关键字是从JAVA SE 1.4 引入的，为了避免和老版本的Java代码中使用了`assert`关键字导致错误，Java在执行的时候默认是不启动断言检查的（这个时候，所有的断言语句都将忽略！），如果要开启断言检查，则需要用开关`-enableassertions`或`-ea`来开启。 + +看一段包含断言的代码： + + public class AssertTest { + public static void main(String args[]) { + int a = 1; + int b = 1; + assert a == b; + System.out.println("公众号：Hollis"); + assert a != b : "Hollis"; + System.out.println("博客：www.hollischuang.com"); + } + } + + +反编译后代码如下： + + public class AssertTest { + public AssertTest() + { + } + public static void main(String args[]) + { + int a = 1; + int b = 1; + if(!$assertionsDisabled && a != b) + throw new AssertionError(); + System.out.println("\u516C\u4F17\u53F7\uFF1AHollis"); + if(!$assertionsDisabled && a == b) + { + throw new AssertionError("Hollis"); + } else + { + System.out.println("\u535A\u5BA2\uFF1Awww.hollischuang.com"); + return; + } + } + + static final boolean $assertionsDisabled = !com/hollis/suguar/AssertTest.desiredAssertionStatus(); + + + } + + +很明显，反编译之后的代码要比我们自己的代码复杂的多。所以，使用了assert这个语法糖我们节省了很多代码。**其实断言的底层实现就是if语言，如果断言结果为true，则什么都不做，程序继续执行，如果断言结果为false，则程序抛出AssertError来打断程序的执行。**`-enableassertions`会设置$assertionsDisabled字段的值。 + +### 糖块九 、 数值字面量 + +在java 7中，数值字面量，不管是整数还是浮点数，都允许在数字之间插入任意多个下划线。这些下划线不会对字面量的数值产生影响，目的就是方便阅读。 + +比如： + + public class Test { + public static void main(String... args) { + int i = 10_000; + System.out.println(i); + } + } + + +反编译后： + + public class Test + { + public static void main(String[] args) + { + int i = 10000; + System.out.println(i); + } + } + + +反编译后就是把`_`删除了。也就是说 **编译器并不认识在数字字面量中的`_`，需要在编译阶段把他去掉。** + +### 糖块十 、 for-each + +增强for循环（`for-each`）相信大家都不陌生，日常开发经常会用到的，他会比for循环要少写很多代码，那么这个语法糖背后是如何实现的呢？ + + public static void main(String... args) { + String[] strs = {"Hollis", "公众号：Hollis", "博客：www.hollischuang.com"}; + for (String s : strs) { + System.out.println(s); + } + List strList = ImmutableList.of("Hollis", "公众号：Hollis", "博客：www.hollischuang.com"); + for (String s : strList) { + System.out.println(s); + } + } + + +反编译后代码如下： + + public static transient void main(String args[]) + { + String strs[] = { + "Hollis", "\u516C\u4F17\u53F7\uFF1AHollis", "\u535A\u5BA2\uFF1Awww.hollischuang.com" + }; + String args1[] = strs; + int i = args1.length; + for(int j = 0; j < i; j++) + { + String s = args1[j]; + System.out.println(s); + } + + List strList = ImmutableList.of("Hollis", "\u516C\u4F17\u53F7\uFF1AHollis", "\u535A\u5BA2\uFF1Awww.hollischuang.com"); + String s; + for(Iterator iterator = strList.iterator(); iterator.hasNext(); System.out.println(s)) + s = (String)iterator.next(); + + } + + +代码很简单，**for-each的实现原理其实就是使用了普通的for循环和迭代器。** + +### 糖块十一 、 try-with-resource + +Java里，对于文件操作IO流、数据库连接等开销非常昂贵的资源，用完之后必须及时通过close方法将其关闭，否则资源会一直处于打开状态，可能会导致内存泄露等问题。 + +关闭资源的常用方式就是在`finally`块里是释放，即调用`close`方法。比如，我们经常会写这样的代码： + + public static void main(String[] args) { + BufferedReader br = null; + try { + String line; + br = new BufferedReader(new FileReader("d:\\hollischuang.xml")); + while ((line = br.readLine()) != null) { + System.out.println(line); + } + } catch (IOException e) { + // handle exception + } finally { + try { + if (br != null) { + br.close(); + } + } catch (IOException ex) { + // handle exception + } + } + } + + +从Java 7开始，jdk提供了一种更好的方式关闭资源，使用`try-with-resources`语句，改写一下上面的代码，效果如下： + + public static void main(String... args) { + try (BufferedReader br = new BufferedReader(new FileReader("d:\\ hollischuang.xml"))) { + String line; + while ((line = br.readLine()) != null) { + System.out.println(line); + } + } catch (IOException e) { + // handle exception + } + } + + +看，这简直是一大福音啊，虽然我之前一般使用`IOUtils`去关闭流，并不会使用在`finally`中写很多代码的方式，但是这种新的语法糖看上去好像优雅很多呢。看下他的背后： + + public static transient void main(String args[]) + { + BufferedReader br; + Throwable throwable; + br = new BufferedReader(new FileReader("d:\\ hollischuang.xml")); + throwable = null; + String line; + try + { + while((line = br.readLine()) != null) + System.out.println(line); + } + catch(Throwable throwable2) + { + throwable = throwable2; + throw throwable2; + } + if(br != null) + if(throwable != null) + try + { + br.close(); + } + catch(Throwable throwable1) + { + throwable.addSuppressed(throwable1); + } + else + br.close(); + break MISSING_BLOCK_LABEL_113; + Exception exception; + exception; + if(br != null) + if(throwable != null) + try + { + br.close(); + } + catch(Throwable throwable3) + { + throwable.addSuppressed(throwable3); + } + else + br.close(); + throw exception; + IOException ioexception; + ioexception; + } + } + + +**其实背后的原理也很简单，那些我们没有做的关闭资源的操作，编译器都帮我们做了。所以，再次印证了，语法糖的作用就是方便程序员的使用，但最终还是要转成编译器认识的语言。** + +### 糖块十二、Lambda表达式 + +关于lambda表达式，有人可能会有质疑，因为网上有人说他并不是语法糖。其实我想纠正下这个说法。**Labmda表达式不是匿名内部类的语法糖，但是他也是一个语法糖。实现方式其实是依赖了几个JVM底层提供的lambda相关api。** + +先来看一个简单的lambda表达式。遍历一个list： + + public static void main(String... args) { + List strList = ImmutableList.of("Hollis", "公众号：Hollis", "博客：www.hollischuang.com"); + + strList.forEach( s -> { System.out.println(s); } ); + } + + +为啥说他并不是内部类的语法糖呢，前面讲内部类我们说过，内部类在编译之后会有两个class文件，但是，包含lambda表达式的类编译后只有一个文件。 + +反编译后代码如下: + + public static /* varargs */ void main(String ... args) { + ImmutableList strList = ImmutableList.of((Object)"Hollis", (Object)"\u516c\u4f17\u53f7\uff1aHollis", (Object)"\u535a\u5ba2\uff1awww.hollischuang.com"); + strList.forEach((Consumer)LambdaMetafactory.metafactory(null, null, null, (Ljava/lang/Object;)V, lambda$main$0(java.lang.String ), (Ljava/lang/String;)V)()); + } + + private static /* synthetic */ void lambda$main$0(String s) { + System.out.println(s); + } + + +可以看到，在`forEach`方法中，其实是调用了`java.lang.invoke.LambdaMetafactory#metafactory`方法，该方法的第四个参数implMethod指定了方法实现。可以看到这里其实是调用了一个`lambda$main$0`方法进行了输出。 + +再来看一个稍微复杂一点的，先对List进行过滤，然后再输出： + + public static void main(String... args) { + List strList = ImmutableList.of("Hollis", "公众号：Hollis", "博客：www.hollischuang.com"); + + List HollisList = strList.stream().filter(string -> string.contains("Hollis")).collect(Collectors.toList()); + + HollisList.forEach( s -> { System.out.println(s); } ); + } + + +反编译后代码如下： + + public static /* varargs */ void main(String ... args) { + ImmutableList strList = ImmutableList.of((Object)"Hollis", (Object)"\u516c\u4f17\u53f7\uff1aHollis", (Object)"\u535a\u5ba2\uff1awww.hollischuang.com"); + List HollisList = strList.stream().filter((Predicate)LambdaMetafactory.metafactory(null, null, null, (Ljava/lang/Object;)Z, lambda$main$0(java.lang.String ), (Ljava/lang/String;)Z)()).collect(Collectors.toList()); + HollisList.forEach((Consumer)LambdaMetafactory.metafactory(null, null, null, (Ljava/lang/Object;)V, lambda$main$1(java.lang.Object ), (Ljava/lang/Object;)V)()); + } + + private static /* synthetic */ void lambda$main$1(Object s) { + System.out.println(s); + } + + private static /* synthetic */ boolean lambda$main$0(String string) { + return string.contains("Hollis"); + } + + +两个lambda表达式分别调用了`lambda$main$1`和`lambda$main$0`两个方法。 + +**所以，lambda表达式的实现其实是依赖了一些底层的api，在编译阶段，编译器会把lambda表达式进行解糖，转换成调用内部api的方式。** + +### 可能遇到的坑 + +#### 泛型 + +**一、当泛型遇到重载** public class GenericTypes { + + public static void method(List list) { + System.out.println("invoke method(List list)"); + } + + public static void method(List list) { + System.out.println("invoke method(List list)"); + } + } + + +上面这段代码，有两个重载的函数，因为他们的参数类型不同，一个是List另一个是List ，但是，这段代码是编译通不过的。因为我们前面讲过，参数List和List编译之后都被擦除了，变成了一样的原生类型List，擦除动作导致这两个方法的特征签名变得一模一样。 + +**二、当泛型遇到catch** 泛型的类型参数不能用在Java异常处理的catch语句中。因为异常处理是由JVM在运行时刻来进行的。由于类型信息被擦除，JVM是无法区分两个异常类型`MyException`和`MyException`的 + +**三、当泛型内包含静态变量** + + public class StaticTest{ + public static void main(String[] args){ + GT gti = new GT(); + gti.var=1; + GT gts = new GT(); + gts.var=2; + System.out.println(gti.var); + } + } + class GT{ + public static int var=0; + public void nothing(T x){} + } + + +以上代码输出结果为：2！由于经过类型擦除，所有的泛型类实例都关联到同一份字节码上，泛型类的所有静态变量是共享的。 + +#### 自动装箱与拆箱 + +**对象相等比较** + +public class BoxingTest { + + public static void main(String[] args) { + Integer a = 1000; + Integer b = 1000; + Integer c = 100; + Integer d = 100; + System.out.println("a == b is " + (a == b)); + System.out.println(("c == d is " + (c == d))); + } + + +输出结果： + + a == b is false + c == d is true + + +在Java 5中，在Integer的操作上引入了一个新功能来节省内存和提高性能。整型对象通过使用相同的对象引用实现了缓存和重用。 + +> 适用于整数值区间-128 至 +127。 +> +> 只适用于自动装箱。使用构造函数创建对象不适用。 + +#### 增强for循环 + +**ConcurrentModificationException** + + for (Student stu : students) { + if (stu.getId() == 2) + students.remove(stu); + } + + +会抛出`ConcurrentModificationException`异常。 + +Iterator是工作在一个独立的线程中，并且拥有一个 mutex 锁。 Iterator被创建之后会建立一个指向原来对象的单链索引表，当原来的对象数量发生变化时，这个索引表的内容不会同步改变，所以当索引指针往后移动的时候就找不到要迭代的对象，所以按照 fail-fast 原则 Iterator 会马上抛出`java.util.ConcurrentModificationException`异常。 + +所以 `Iterator` 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 `Iterator` 本身的方法`remove()`来删除对象，`Iterator.remove()` 方法会在删除当前迭代对象的同时维护索引的一致性。 + +### 总结 + +前面介绍了12种Java中常用的语法糖。所谓语法糖就是提供给开发人员便于开发的一种语法而已。但是这种语法只有开发人员认识。要想被执行，需要进行解糖，即转成JVM认识的语法。当我们把语法糖解糖之后，你就会发现其实我们日常使用的这些方便的语法，其实都是一些其他更简单的语法构成的。 + +有了这些语法糖，我们在日常开发的时候可以大大提升效率，但是同时也要避免过渡使用。使用之前最好了解下原理，避免掉坑。 + +参考资料： [Java的反编译][1] [Java中的Switch对整型、字符型、字符串型的具体实现细节][2] [深度分析Java的枚举类型—-枚举的线程安全性及序列化问题][3] [Java的枚举类型用法介绍][4] [Java中的增强for循环（for each）的实现原理与坑][5] [Java中泛型的理解][6] [Java中整型的缓存机制][7] [Java中的可变参数][8] + + [1]: http://www.hollischuang.com/archives/58 + [2]: http://www.hollischuang.com/archives/61 + [3]: http://www.hollischuang.com/archives/197 + [4]: http://www.hollischuang.com/archives/195 + [5]: http://www.hollischuang.com/archives/1776 + [6]: http://www.hollischuang.com/archives/230 + [7]: http://www.hollischuang.com/archives/1174 + [8]: http://www.hollischuang.com/archives/1271 \ No newline at end of file diff --git a/basics/jvm/stack-alloc.md b/basics/jvm/stack-alloc.md new file mode 100644 index 0000000..eb00b21 --- /dev/null +++ b/basics/jvm/stack-alloc.md @@ -0,0 +1,166 @@ +### JVM内存分配策略 + +关于JVM的内存结构及内存分配方式，不是本文的重点，这里只做简单回顾。以下是我们知道的一些常识： + +1、根据Java虚拟机规范，Java虚拟机所管理的内存包括方法区、虚拟机栈、本地方法栈、堆、程序计数器等。 + +2、我们通常认为JVM中运行时数据存储包括堆和栈。这里所提到的栈其实指的是虚拟机栈，或者说是虚拟栈中的局部变量表。 + +3、栈中存放一些基本类型的变量数据（int/short/long/byte/float/double/Boolean/char）和对象引用。 + +4、堆中主要存放对象，即通过new关键字创建的对象。 + +5、数组引用变量是存放在栈内存中，数组元素是存放在堆内存中。 + +在《深入理解Java虚拟机中》关于Java堆内存有这样一段描述： + +但是，随着JIT编译期的发展与逃逸分析技术逐渐成熟，栈上分配、标量替换优化技术将会导致一些微妙的变化，所有的对象都分配到堆上也渐渐变得不那么“绝对”了。 + +这里只是简单提了一句，并没有深入分析，很多人看到这里由于对JIT、逃逸分析等技术不了解，所以也无法真正理解上面这段话的含义。 + +**PS：这里默认大家都了解什么是JIT，不了解的朋友可以先自行Google了解下，或者加入我的知识星球，阅读那篇球友专享文章。** + +其实，在编译期间，JIT会对代码做很多优化。其中有一部分优化的目的就是减少内存堆分配压力，其中一种重要的技术叫做**逃逸分析**。 + +### 逃逸分析 + +逃逸分析(Escape Analysis)是目前Java虚拟机中比较前沿的优化技术。这是一种可以有效减少Java 程序中同步负载和内存堆分配压力的跨函数全局数据流分析算法。通过逃逸分析，Java Hotspot编译器能够分析出一个新的对象的引用的使用范围从而决定是否要将这个对象分配到堆上。 + +逃逸分析的基本行为就是分析对象动态作用域：当一个对象在方法中被定义后，它可能被外部方法所引用，例如作为调用参数传递到其他地方中，称为方法逃逸。 + +例如： + + public static StringBuffer craeteStringBuffer(String s1, String s2) { + StringBuffer sb = new StringBuffer(); + sb.append(s1); + sb.append(s2); + return sb; + } + + +StringBuffer sb是一个方法内部变量，上述代码中直接将sb返回，这样这个StringBuffer有可能被其他方法所改变，这样它的作用域就不只是在方法内部，虽然它是一个局部变量，称其逃逸到了方法外部。甚至还有可能被外部线程访问到，譬如赋值给类变量或可以在其他线程中访问的实例变量，称为线程逃逸。 + +上述代码如果想要StringBuffer sb不逃出方法，可以这样写： + + public static String createStringBuffer(String s1, String s2) { + StringBuffer sb = new StringBuffer(); + sb.append(s1); + sb.append(s2); + return sb.toString(); + } + + +不直接返回 StringBuffer，那么StringBuffer将不会逃逸出方法。 + +使用逃逸分析，编译器可以对代码做如下优化： + +一、同步省略。如果一个对象被发现只能从一个线程被访问到，那么对于这个对象的操作可以不考虑同步。 + +二、将堆分配转化为栈分配。如果一个对象在子程序中被分配，要使指向该对象的指针永远不会逃逸，对象可能是栈分配的候选，而不是堆分配。 + +三、分离对象或标量替换。有的对象可能不需要作为一个连续的内存结构存在也可以被访问到，那么对象的部分（或全部）可以不存储在内存，而是存储在CPU寄存器中。 + +上面的关于同步省略的内容，我在《[深入理解多线程（五）—— Java虚拟机的锁优化技术][1]》中有介绍过，即锁优化中的锁消除技术，依赖的也是逃逸分析技术。 + +本文，主要来介绍逃逸分析的第二个用途：将堆分配转化为栈分配。 + +> 其实，以上三种优化中，栈上内存分配其实是依靠标量替换来实现的。由于不是本文重点，这里就不展开介绍了。如果大家感兴趣，我后面专门出一篇文章，全面介绍下逃逸分析。 + +在Java代码运行时，通过JVM参数可指定是否开启逃逸分析， `-XX:+DoEscapeAnalysis` ： 表示开启逃逸分析 `-XX:-DoEscapeAnalysis` ： 表示关闭逃逸分析 从jdk 1.7开始已经默认开始逃逸分析，如需关闭，需要指定`-XX:-DoEscapeAnalysis` + +### 对象的栈上内存分配 + +我们知道，在一般情况下，对象和数组元素的内存分配是在堆内存上进行的。但是随着JIT编译器的日渐成熟，很多优化使这种分配策略并不绝对。JIT编译器就可以在编译期间根据逃逸分析的结果，来决定是否可以将对象的内存分配从堆转化为栈。 + +我们来看以下代码： + + public static void main(String[] args) { + long a1 = System.currentTimeMillis(); + for (int i = 0; i < 1000000; i++) { + alloc(); + } + // 查看执行时间 + long a2 = System.currentTimeMillis(); + System.out.println("cost " + (a2 - a1) + " ms"); + // 为了方便查看堆内存中对象个数，线程sleep + try { + Thread.sleep(100000); + } catch (InterruptedException e1) { + e1.printStackTrace(); + } + } + + private static void alloc() { + User user = new User(); + } + + static class User { + + } + + +其实代码内容很简单，就是使用for循环，在代码中创建100万个User对象。 + +**我们在alloc方法中定义了User对象，但是并没有在方法外部引用他。也就是说，这个对象并不会逃逸到alloc外部。经过JIT的逃逸分析之后，就可以对其内存分配进行优化。** + +我们指定以下JVM参数并运行： + + -Xmx4G -Xms4G -XX:-DoEscapeAnalysis -XX:+PrintGCDetails -XX:+HeapDumpOnOutOfMemoryError + + +在程序打印出 `cost XX ms` 后，代码运行结束之前，我们使用`[jmap][1]`命令，来查看下当前堆内存中有多少个User对象： + + ➜ ~ jps + 2809 StackAllocTest + 2810 Jps + ➜ ~ jmap -histo 2809 + + num #instances #bytes class name + ---------------------------------------------- + 1: 524 87282184 [I + 2: 1000000 16000000 StackAllocTest$User + 3: 6806 2093136 [B + 4: 8006 1320872 [C + 5: 4188 100512 java.lang.String + 6: 581 66304 java.lang.Class + + +从上面的jmap执行结果中我们可以看到，堆中共创建了100万个`StackAllocTest$User`实例。 + +在关闭逃避分析的情况下（-XX:-DoEscapeAnalysis），虽然在alloc方法中创建的User对象并没有逃逸到方法外部，但是还是被分配在堆内存中。也就说，如果没有JIT编译器优化，没有逃逸分析技术，正常情况下就应该是这样的。即所有对象都分配到堆内存中。 + +接下来，我们开启逃逸分析，再来执行下以上代码。 + + -Xmx4G -Xms4G -XX:+DoEscapeAnalysis -XX:+PrintGCDetails -XX:+HeapDumpOnOutOfMemoryError + + +在程序打印出 `cost XX ms` 后，代码运行结束之前，我们使用`jmap`命令，来查看下当前堆内存中有多少个User对象： + + ➜ ~ jps + 709 + 2858 Launcher + 2859 StackAllocTest + 2860 Jps + ➜ ~ jmap -histo 2859 + + num #instances #bytes class name + ---------------------------------------------- + 1: 524 101944280 [I + 2: 6806 2093136 [B + 3: 83619 1337904 StackAllocTest$User + 4: 8006 1320872 [C + 5: 4188 100512 java.lang.String + 6: 581 66304 java.lang.Class + + +从以上打印结果中可以发现，开启了逃逸分析之后（-XX:+DoEscapeAnalysis），在堆内存中只有8万多个`StackAllocTest$User`对象。也就是说在经过JIT优化之后，堆内存中分配的对象数量，从100万降到了8万。 + +> 除了以上通过jmap验证对象个数的方法以外，读者还可以尝试将堆内存调小，然后执行以上代码，根据GC的次数来分析，也能发现，开启了逃逸分析之后，在运行期间，GC次数会明显减少。正是因为很多堆上分配被优化成了栈上分配，所以GC次数有了明显的减少。 + +### 总结 + +所以，如果以后再有人问你：是不是所有的对象和数组都会在堆内存分配空间？ + +那么你可以告诉他：不一定，随着JIT编译器的发展，在编译期间，如果JIT经过逃逸分析，发现有些对象没有逃逸出方法，那么有可能堆内存分配会被优化成栈内存分配。但是这也并不是绝对的。就像我们前面看到的一样，在开启逃逸分析之后，也并不是所有User对象都没有在堆上分配。 + + [1]: http://www.hollischuang.com/archives/2344 \ No newline at end of file -- GitLab