共计 6128 个字符，预计需要花费 16 分钟才能阅读完成。
前言
- 上篇文章总结了 java 线程与 os 线程的分割，以及模仿 java 调用 os 函数创立线程。通过上篇文章的总结，咱们理解了 java 的线程与 os 线程是一一对等的。同时也理解到了应用多线程的起因。凡事都有利与弊，在多线程晋升程序运行效率的长处下，也带来了另外的问题——
同步。没错，只有应用到多线程，咱们就要思考同步，不然就乱套了！在同步问题中，java 有一个亲儿子——synchronized关键字。在 jdk 1.5 后，它就有了一些孪生兄弟 ——JUC包下的各种锁实现。它们之间的特点将在后续的文章中做出总结。
一、为什么在多线程中要应用同步？
-
如以后章节的主题，为什么在多线程中要应用同步？咱们来看一下上面这段代码：
/** * 模仿 4 个窗口卖 20 张票 */ public class TestMulThread { private static int ticketNum = 10; public static void main(String[] args) throws InterruptedException {for (int i = 0; i < 4; i++) {new Thread(() -> {while (!Thread.currentThread().isInterrupted() && ticketNum > 0) {System.out.println(Thread.currentThread().getName() + "售出第" + ticketNum-- + "张票"); } }, "窗口" + (i + 1)).start();} } }运行上段代码，你会发现输入的后果毫无法则，可能呈现票号为正数的状况，也有可能呈现卖出反复票的状况(` 自己电脑 cpu 为 12 核的，处理速度比拟快，不会呈现上述情况 `)。这显著是有问题的。要解决这个问题咱们能够应用同步策略，所谓同步策略即是应用 synchronized 关键字(** 这里只思考 synchronized 关键字，不思考其余的状况 **)。于是，咱们进行代码批改，如下所示：```java /** * 模仿 4 个窗口卖 20 张票 */ public class TestMulThread { private static int ticketNum = 10; static Lock lock = new Lock(); public static void main(String[] args) throws InterruptedException {for (int i = 0; i < 4; i++) {new Thread(() -> {while (!Thread.currentThread().isInterrupted()) {synchronized (lock) {if (ticketNum > 0) {System.out.println(Thread.currentThread().getName() + "售出第" + ticketNum-- + "张票"); } else {Thread.currentThread().interrupt();} } } }, "窗口" + (i + 1)).start();} } } class Lock { } ``` 批改后的代码为，新建了一个 Lock 类作为锁对象。这样就实现了同步的操作。上面总结下 synchronized 关键字的常见应用形式、经典案例及其特点。二、synchronized 关键字的几种用法即特点
-
这里要明确一个点：
synchronized 锁住的是对象，是通过一个标识来示意是具体的哪一种锁2.1 锁类实例和类对象
-
具体参考如下代码：
// 状况一：锁 object 对象 public class Demo {private Object object = new Object(); public void test(){synchronized (object) {System.out.println(Thread.currentThread().getName()); } } } // 状况二: 锁以后对象 this，锁定某个代码块 // 应用此种形式要留神调用进来的 this 是否为同一对象 // 若 Demo 的实例不是单例的，那么这把锁基本上起不到同步的作用 public class Demo {public void test() {//synchronized(this)锁定的是以后类的实例, 这里锁定的是 Demo 类的实例 synchronized (this) {System.out.println(Thread.currentThread().getName()); } } } // 状况三: 锁以后对象 this，锁定整个办法 // 与状况二相似，然而它是锁住了整个办法，粒度比状况二大 public class Demo {public synchronized void test() {System.out.println(Thread.currentThread().getName()); } } // // ===> 当调用以后类的所有同步静态方法将会期待获取锁 // 留神: 然而此时还是能调用类实例的同步办法。为什么呢？// 因为动态同步办法和类实例同步办法领有的锁不一样 // 一个是类对象一个是类实例对象。// 同时，此时还能调用类对象的动态非同步办法以及类实例的 // 非同步办法。为什么呢？因为这些办法没有加锁啊，能够间接调用。public class Demo {public static synchronized void test() {System.out.println(Thread.currentThread().getName()); } }2.2 锁同一个 String 常量
-
查看如下代码：
/** 下面说了，synchronized 关键字锁的是对象，而对于 s1 和 s2 这两个对象，他们的值都是 lock，也就是放在常量池中的(堆内的办法区)，所以 s1 和 s2 指向的是同一个对象。所以 上面的 test1 和 test2 办法应用的都是同一把锁，最终的运行后果就是线程 2 会期待线程 1 把锁开释结束后 能力获取锁并执行如下代码。*/ public class Demo { String s1 = "lock"; String s2 = "lock"; public void test1() {synchronized (s1) {System.out.println("t1 start"); try {TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) {e.printStackTrace(); } System.out.println("t1 end"); } } public void test2() {synchronized (s2) {System.out.println("t2 start"); } } public static void main(String[] args) {Demo demo = new Demo(); new Thread(demo :: test1, "test1").start(); new Thread(demo :: test2, "test2").start();} }2.3 锁 Integer 对象
-
见如下代码：
public static class BadLockOnInteger implements Runnable{ public static Integer i = 0; static BadLockOnInteger instance = new BadLockOnInteger(); @Override public void run() {for (int j = 0; j < 10000000; j++) {synchronized(i) {// 在 jvm 执行时, 这是这样的一段代码: i = Integer.valueOf(i.intValue() + 1), // 跟踪 Integer.valueOf()源码可知, 每次都是返回一个新的 Integer 对象, 导致加锁的都是新对象, 当然会导致多线程同步生效 i++; } } } public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(instance); Thread t2 = new Thread(instance); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println(i); } }
2.4 可重入性(包含继承)
- 概念解释：所谓可重入性就是间断申请获取同一把锁
-
见如下代码
/** 一个同步办法调用另外一个同步办法，反对可重入 */ public class Demo {public synchronized void test1() {System.out.println("test1 start"); try {TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) {e.printStackTrace(); } test2();} public synchronized void test2() {System.out.println("test2 start"); } public static void main(String[] args) {Demo demo = new Demo(); demo.test1();} } /** 继承也反对可重入个性 */ public class Demo {synchronized void test() {System.out.println("demo test start"); try {TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) {e.printStackTrace(); } System.out.println("demo test end"); } public static void main(String[] args) {new Demo2().test();} } class Demo2 extends Demo { @Override synchronized void test() {System.out.println("demo2 test start"); // 此处调用了父类的办法 super.test(); System.out.println("demo2 test end"); } }2.5 synchronized 开释锁的几种状况
- synchronized 关键字是 手动上锁主动开释锁 的。同时主动开释锁包含：
加锁代码块执行完结或者抛出的异样 - 在执行 await 办法时，锁会被主动开释。
三、初识对象头
3.1 对象头构造
- 下面介绍了 synchronized 的一些根本用法和个性。接下来咱们开始意识下对象头。(ps：要想了解 synchronized 关键字，理解对象头是根底)
-
大家都晓得，synchroinzed 在 jdk1.6 之后会存在锁降级过程，所以会依据不同的状况产生不同的锁：
偏差锁、轻量锁、分量锁。而这些所谓锁对应的仅仅是对象头的一些信息。上面两张图将列举出不同状态下的对象头信息3.2 如何查看对象头
-
第一步：maven 我的项目引入如下 jar 包
<dependency> <groupId>org.openjdk.jol</groupId> <artifactId>jol-core</artifactId> <version>0.9</version> </dependency> -
第二步：新建 User.java 类
public class User {public static void main(String[] args) {User user = new User(); System.out.println(ClassLayout.parseInstance(user).toPrintable()); } } -
第三步：运行 main 办法查看对象头信息
3.3 证实无锁状态对象的前 56 位存储的是 hascode
3.3.1 cpu 的大小端模式
- 为什么要总结这个呢？因为 jol 打印进去的一些对象信息外面有很多 0101 以及对应的十六进制的值。咱们要晓得 hashcode 存在哪，就要晓得 cpu 的大小端模式。
3.3.2 何为大小端模式
-
参考链接：https://www.cnblogs.com/0YHT0/p/3403474.html。大抵总结为：咱们的数据是存在内存中的，而每个 cpu 对应的存储形式是不统一的。所谓大端模式就是高位存在内存低位上，eg：假如要存储 12345678 这个数字时，两两为一对。87 属于第一位、56 属于第二位 ….. 以此类推。那么，咱们就能晓得 12 是最高位，所以它会被存到内存的低位。拿上述链接的总结来说就是如下表所示：
| 内存地址 | 存储的数据（Byte）|
| :——–: | :—————-: |
| 0x00000000 | 0x12 |
| 0x00000001 | 0x34 |
| 0x00000002 | 0x56 |
| 0x00000003 | 0x78 |大抵意思就是这样，** 所以在大端模式下，最终取数据时(从低位开始取)**，于是完满还原 **12345678**。小端模式的话，相同的。这里就不总结了。那么问题来了，咱们如何晓得咱们的 cpu 是大端存储模式还是小端存储模式呢？java 提供了如下 api：```java // 输入后果参考如下内容：// BIG_ENDIAN：大端模式 // LITTLE_ENDIAN: 小端模式 System.out.println(ByteOrder.nativeOrder().toString()); ```
3.3.3 证实 hashcode
- 接下来咱们来证实前 56 位存储的 hashcode。
-
新建如下类
public class Valid {public static void main(String[] args) {System.out.println(ByteOrder.nativeOrder().toString()); User user = new User(); System.out.println("before hashcode"); System.out.println(ClassLayout.parseInstance(user).toPrintable()); // 将 hashcode 转成 16 进制，因为 jol 在输入的内容中蕴含 16 进制的值 System.out.println(Integer.toHexString(user.hashCode())); System.out.println("after hashcode"); System.out.println(ClassLayout.parseInstance(user).toPrintable()); } } -
运行后果如下图所示：
四、总结
- 综上，咱们理解了 java 对象头的构造以及证实了无锁状态下的前 56 为存储的是 hashcode。咱们要深刻理解 java 的对象头，这是了解 synchronized 关键字的基石。下篇文章主题为：
证实分代年龄、无锁、偏差锁、轻量锁、重 (chong) 偏差、重 (chong) 轻量、分量锁 - 并发模块对应 github 地址：传送门
- I am a slow walker, but I never walk backwards.
正文完