无标题

4.1 共享带来的问题

小故事

小男小女（线程）共用算盘（CPU），小南算加法，小女算减法，临时结果写到账本（内存），老王（操作系统）来调度两人使用。小王算到一半暂停（时间片用完），轮到小女使用，小女使用完写会结果。小男被唤醒继续算数，把1写到账本。
小男小女都觉得自己没做错，但笔记本里的结果是 1 而不是 0

Java 的体现

两个线程对初始值为 0 的静态变量一个做自增，一个做自减，各做 5000 次，结果是 0 吗？

@Slf4j
public class TestShare {
    static int counter = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                counter++;
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                counter--;
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}",counter);
    }
}

运行结果

09:53:27.002 [main] com.zhr.thread.TestShare - 461

问题分析
以上的结果可能是正数、负数、零。为什么呢？因为 Java 中对静态变量的自增，自减并不是原子操作，要彻底理解，必须从字节码来进行分析
例如对于 i++ 而言（i 为静态变量），实际会产生如下的 JVM 字节码指令：

getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
iadd // 自增
putstatic i // 将修改后的值存入静态变量i

而对应 i— 也是类似：

getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
isub // 自减
putstatic i // 将修改后的值存入静态变量i

而 Java 的内存模型如下，完成静态变量的自增，自减需要在主存和工作内存中进行数据交换：

如果是单线程以上 8 行代码是顺序执行（不会交错）没有问题，但多线程下这 8 行代码可能交错运行：
出现负数的情况如下图，若线程12顺序交换则为正数，若一个线程已经执行putstatic ,则结果是0

临界区 Critical Section

• 一个程序运行多个线程本身是没有问题的
• 问题出在多个线程访问共享资源
  • 多个线程读共享资源其实也没有问题
  • 在多个线程对共享资源读写操作时发生指令交错，就会出现问题
• 一段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为临界区

例如，下面代码中的临界区

static int counter = 0;
static void increment() { 
    // 临界区
    counter++; 
}
static void decrement() { 
    // 临界区
    counter--; 
}

竞态条件 Race Condition

多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件

4.2 synchronized

* 应用之互斥

为了避免临界区的竞态条件发生，有多种手段可以达到目的。

• 阻塞式的解决方案：synchronized，Lock
• 非阻塞式的解决方案：原子变量

本次课使用阻塞式的解决方案：synchronized，来解决上述问题，即俗称的【对象锁】，它采用互斥的方式让同一
时刻至多只有一个线程能持有【对象锁】，其它线程再想获取这个【对象锁】时就会阻塞住。这样就能保证拥有锁
的线程可以安全的执行临界区内的代码，不用担心线程上下文切换

注意 虽然 java 中互斥和同步都可以采用 synchronized 关键字来完成，但它们还是有区别的：

• 互斥是保证临界区的竞态条件发生，同一时刻只能有一个线程执行临界区代码
• 同步是由于线程执行的先后、顺序不同、需要一个线程等待其它线程运行到某个点

synchronized 语法1

synchronized(对象) // 线程1， 线程2(blocked)
{
 临界区
}

解决问题

@Slf4j
public class TestShare1 {
    static int counter = 0;
    //static final Object room = new Object();
    public static void main(String[] args) throws InterruptedException {
        System.out.println();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (TestShare1.class){
                    counter++;
                }
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (TestShare1.class){
                    counter--;
                }
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}",counter);
    }
}

你可以做这样的类比：

• synchronized(对象) 中的对象，可以想象为一个房间（room），有唯一入口（门）房间只能一次进入一人进行计算，线程 t1，t2 想象成两个人
• 当线程 t1 执行到 synchronized(room)时就好比 t1 进入了这个房间，并锁住了门拿走了钥匙，在门内执行count++代码
• 这时候如果 t2 也运行到了``synchronized(room)时，它发现门被锁住了，只能在门外等待，发生了上下文切换，阻塞住了
• 这中间即使 t1 的 cpu 时间片不幸用完，被踢出了门外（不要错误理解为锁住了对象就能一直执行下去哦），这时门还是锁住的，t1 仍拿着钥匙，t2 线程还在阻塞状态进不来，只有下次轮到 t1 自己再次获得时间片时才能开门进入
• 当 t1 执行完 synchronized{} 块内的代码，这时候才会从 obj 房间出来并解开门上的锁，唤醒 t2 线程把钥匙给他。t2 线程这时才可以进入 obj 房间，锁住了门拿上钥匙，执行它的 count--代码

图解

思考

synchronized 实际是用对象锁保证了临界区内代码的原子性，临界区内的代码对外是不可分割的，不会被线程切
换所打断。
为了加深理解，请思考下面的问题如果把 synchronized(obj) 放在 for 循环的外面，如何理解？— 原子性
结果正常，相当于整个for循环
如果 t1 synchronized(obj1) 而 t2 synchronized(obj2) 会怎样运作？— 锁对象
结果不正常，不是同一把锁
如果 t1 synchronized(obj) 而 t2 没有加会怎么样？如何理解？— 锁对象
结果不正常，t2能继续访问

面向对象的改进

@Slf4j
public class TestSynchronized {
    int value = 0;
    public void increment() {
        synchronized (this) {
            value++;
        }
    }
    public void decrement() {
        synchronized (this) {
            value--;
        }
    }
    public int get() {
        //确保读取到的值不是中间值
        synchronized (this) {
            return value;
        }
    }
    public static void main(String[] args) throws InterruptedException {
        TestSynchronized room = new TestSynchronized();
        Thread t1 = new Thread(() -> {
            for (int j = 0; j < 5000; j++) {
                room.increment();
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int j = 0; j < 5000; j++) {
                room.decrement();
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("count: {}", room.get());
    }
}

4.3 方法上的 synchronized

class Test{
    public synchronized void test() {
    }
}

等价于

class Test{
    public void test() {
        synchronized(this) {
        }
    }
}

class Test{
    public synchronized static void test() {
    }
}

等价于

class Test{
    public static void test() {
        synchronized(Test.class) {
        }
    }
}

不加 synchronized 的方法
不加 synchronzied 的方法就好比不遵守规则的人，不去老实排队（好比翻窗户进去的）

线程八锁

所谓的“线程八锁”其实就是考察 synchronized 锁住的是哪个对象

/**1
 * 结果 n1 n2 或者 n2 n1
 * 竞争同一个对象
 *
 * @author zhr
 * @date 2021/1/18 13:55
 **/
@Slf4j
public class 线程八锁_1 {
    public static void main(String[] args) {
        Number number = new Number();
        new Thread(() -> number.n1()).start();
        new Thread(() -> number.n2()).start();
    }
}
@Slf4j
class Number {
    public synchronized void n1() {
        log.info("n1");
    }
    public synchronized void n2() {
        log.info("n2");
    }
}

/**2
 * 1S 后 n1 n2或者 n2 1S后n1
 * 竞争同一个对象
 *
 * @author zhr
 * @date 2021/1/18 13:55
 **/
@Slf4j
public class 线程八锁_2 {
    public static void main(String[] args) {
        Number2 number = new Number2();
        new Thread(() -> number.n1()).start();
        new Thread(() -> number.n2()).start();
    }
}
@Slf4j
class Number2 {
    public synchronized void n1() {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("n1");
    }
    public synchronized void n2() {
        log.info("n2");
    }
}

/**3
 * n3   一秒后 n1 n2
 * n3 n2  一秒后n1
 * n2 n3  一秒后n1
 * n3 不参与锁竞争  n1n2 竞争同一个对象
 *
 * @author zhr
 * @date 2021/1/18 13:55
 **/
@Slf4j
public class 线程八锁_3 {
    public static void main(String[] args) {
        Number3 number = new Number3();
        new Thread(() -> number.n1()).start();
        new Thread(() -> number.n2()).start();
        new Thread(() -> number.n3()).start();
    }
}
@Slf4j
class Number3 {
    public synchronized void n1() {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("n1");
    }
    public synchronized void n2() {
        log.info("n2");
    }
    public void n3() {
        log.info("n3");
    }
}

/**4
 * n2 n1
 * 两个对象 无竞争
 *
 * @author zhr
 * @date 2021/1/18 13:55
 **/
@Slf4j
public class 线程八锁_4 {
    public static void main(String[] args) {
        Number4 number = new Number4();
        Number4 number1 = new Number4();
        new Thread(() -> number.n1()).start();
        new Thread(() -> number1.n2()).start();
    }
}
@Slf4j
class Number4 {
    public synchronized void n1() {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("n1");
    }
    public synchronized void n2() {
        log.info("n2");
    }
}

/**5
 * n2 n1
 * n1 线程的锁是类对象 n2 的锁是number这个对象
 *
 * @author zhr
 * @date 2021/1/18 13:55
 **/
@Slf4j
public class 线程八锁_5 {
    public static void main(String[] args) {
        Number5 number = new Number5();
        new Thread(() -> number.n1()).start();
        new Thread(() -> number.n2()).start();
    }
}
@Slf4j
class Number5 {
    public static synchronized void n1() {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("n1");
    }
    public synchronized void n2() {
        log.info("n2");
    }
}

/**6
 * 1S 后 n1 n2或者 n2 1S后n1
 * 存在竞争 竞争的是这个类对象
 *
 * @author zhr
 * @date 2021/1/18 13:55
 **/
@Slf4j
public class 线程八锁_6 {
    public static void main(String[] args) {
        Number6 number6 = new Number6();
        new Thread(() -> number6.n1()).start();
        new Thread(() -> number6.n2()).start();
    }
}
@Slf4j
class Number6 {
    public static synchronized void n1() {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("n1");
    }
    public static synchronized void n2() {
        log.info("n2");
    }
}

/**7
 * n2 1S n1
 * 不存在竞争 n1线程锁是类对象 n2 线程锁是实例number2
 *
 * @author zhr
 * @date 2021/1/18 13:55
 **/
@Slf4j
public class 线程八锁_7 {
    public static void main(String[] args) {
        Number7 number1 = new Number7();
        Number7 number2 = new Number7();
        new Thread(() -> number1.n1()).start();
        new Thread(() -> number2.n2()).start();
    }
}
@Slf4j
class Number7 {
    public static synchronized void n1() {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("n1");
    }
    public synchronized void n2() {
        log.info("n2");
    }
}

/**8
 * 1s 后12， 或 2 1s后 1
 * 存在竞争，竞争的是同一个类对象
 *
 * @author zhr
 * @date 2021/1/18 13:55
 **/
@Slf4j
public class 线程八锁_8 {
    public static void main(String[] args) {
        Number8 number1 = new Number8();
        Number8 number2 = new Number8();
        new Thread(() -> number1.n1()).start();
        new Thread(() -> number2.n2()).start();
    }
}
@Slf4j
class Number8 {
    public static synchronized void n1() {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("n1");
    }
    public static synchronized void n2() {
        log.info("n2");
    }
}

4.4 变量的线程安全分析

成员变量和静态变量是否线程安全？

• 如果它们没有共享，则线程安全

• 如果它们被共享了，根据它们的状态是否能够改变，又分两种情况

  • 如果只有读操作，则线程安全
  • 如果有读写操作，则这段代码是临界区，需要考虑线程安全

    局部变量是否线程安全？

• 局部变量是线程安全的

• 但局部变量引用的对象则未必
  • 如果该对象没有逃离方法的作用访问，它是线程安全的
  • 如果该对象逃离方法的作用范围，需要考虑线程安全

    局部变量线程安全分析

    public static void test1() {
    int i = 10;
    i++; 
    }

    每个线程调用 test1() 方法时局部变量 i，会在每个线程的栈帧内存中被创建多份，因此不存在共享

    public static void test1();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
     stack=1, locals=1, args_size=0
        0: bipush        10
        2: istore_0
        3: iinc          0, 1
        6: return
     LineNumberTable:
       line 5: 0
       line 6: 3
       line 7: 6
     LocalVariableTable:
       Start  Length  Slot  Name   Signature
           3       4     0     i   I

    如图
    

局部变量的引用稍有不同
先看一个成员变量的例子

class ThreadUnsafe {
    ArrayList<String> list = new ArrayList<>();
    public void method1(int loopNumber) {
        for (int i = 0; i < loopNumber; i++) {
            // { 临界区, 会产生竞态条件
            method2();
            method3();
            // } 临界区
        }
    }
    private void method2() {
        list.add("1");
    }
    private void method3() {
        list.remove(0);
    }
    public static void main(String[] args) {
        ThreadUnsafe test = new ThreadUnsafe();
        //创建 2 个线程  每个线程执行  200 次
        for (int i = 0; i < 2; i++) {
            new Thread(() -> test.method1(200), "Thread" + i).start();
        }
    }
}

运行结果，可能正常也可能报错

Exception in thread "Thread1" java.lang.IndexOutOfBoundsException: Index: 0, Size: 0
    at java.util.ArrayList.rangeCheck(ArrayList.java:657)
    at java.util.ArrayList.remove(ArrayList.java:496)
    at com.zhr.thread.ThreadUnsafe.method3(ThreadUnsafe.java:19)
    at com.zhr.thread.ThreadUnsafe.method1(ThreadUnsafe.java:11)
    at com.zhr.thread.ThreadUnsafe.lambda$main$0(ThreadUnsafe.java:28)
    at java.lang.Thread.run(Thread.java:748)

分析：
无论哪个线程中的 method2 引用的都是同一个对象中的 list 成员变量
method3 与 method2 分析相同

将 list 修改为局部变量那么就不会有上述问题了

class ThreadUnsafe1 {
    public void method1(int loopNumber) {
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < loopNumber; i++) {
            // { 临界区, 会产生竞态条件
            method2(list);
            method3(list);
            // } 临界区
        }
    }
    private void method2(ArrayList<String> list) {
        list.add("1");
    }
    private void method3(ArrayList<String> list) {
        list.remove(0);
    }
    public static void main(String[] args) {
        ThreadUnsafe1 test = new ThreadUnsafe1();
        //创建 2 个线程  每个线程执行  200 次
        for (int i = 0; i < 2; i++) {
            new Thread(() -> test.method1(200), "Thread" + i).start();
        }
    }
}

分析：
list 是局部变量，每个线程调用时会创建其不同实例，没有共享
而 method2 的参数是从 method1 中传递过来的，与 method1 中引用同一个对象
method3 的参数分析与 method2 相同

方法访问修饰符带来的思考，如果把 method2 和 method3 的方法修改为 public 会不会代理线程安全问题？
情况1：有其它线程调用 method2 和 method3
情况2：在 情况1 的基础上，为 ThreadSafe 类添加子类，子类覆盖 method2 或 method3 方法，即

class ThreadSafe {
    public final void method1(int loopNumber) {
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < loopNumber; i++) {
            method2(list);
            method3(list);
        }
    }
    public void method2(ArrayList<String> list) {
        list.add("1");
    }
    public void method3(ArrayList<String> list) {
        list.remove(0);
    }
}
class ThreadSafeSubClass extends ThreadSafe {
    @Override
    public void method3(ArrayList<String> list) {
        new Thread(() -> list.remove(0)).start();
    }
}

从这个例子可以看出 private 或 fifinal 提供【安全】的意义所在，请体会开闭原则中的【闭】

常见线程安全类

String
Integer
StringBuffffer
Random
Vector
Hashtable
java.util.concurrent 包下的类
这里说它们是线程安全的是指，多个线程调用它们同一个实例的某个方法时，是线程安全的。也可以理解为

Hashtable table = new Hashtable();
new Thread(()-> table.put("key", "value1")).start();
new Thread(()-> table.put("key", "value2")).start();

线程安全类方法的组合

它们的每个方法是原子的,但注意它们多个方法的组合不是原子的，见后面分析
分析下面代码是否线程安全？

Hashtable table = new Hashtable();
// 线程1，线程2
if( table.get("key") == null) {
    table.put("key", value);
}

不可变类线程安全性
String、Integer 等都是不可变类，因为其内部的状态不可以改变，因此它们的方法都是线程安全的
有同学或许有疑问，String 有 replace，substring 等方法【可以】改变值啊，那么这些方法又是如何保证线程安
全的呢？

public class Immutable{
 private int value = 0;
 public Immutable(int value){
 this.value = value;
 }
 public int getValue(){
 return this.value;
 }
}

如果想增加一个增加的方法呢？

public class Immutable{
 private int value = 0;
 public Immutable(int value){
 this.value = value;
 }
 public int getValue(){
 return this.value;
 }
 public Immutable add(int v){
 return new Immutable(this.value + v);
 } 
}

实例分析

例1：

//运行在Tomcat容器中，只有一个实例，会被tomcat的多个线程共享使用
public class MyServlet extends HttpServlet {
 // 是否安全？  线程不安全，key,value可以修改，多个线程读写会发生混乱
 Map<String,Object> map = new HashMap<>();
 // 是否安全？ 线程安全，属性不可修改
 String S1 = "...";
 // 是否安全？ 线程安全，属性不可修改
 final String S2 = "...";
 // 是否安全？ 线程不安全，会被共享，属性可修改
 Date D1 = new Date();
 // 是否安全？ 线程不安全，引用不能变，但是属性可修改
 final Date D2 = new Date();
 public void doGet(HttpServletRequest request, HttpServletResponse response) {
     // 使用上述变量
 }
}

例2：

public class MyServlet extends HttpServlet {
 // 是否安全？ 存在线程安全问题
 private UserService userService = new UserServiceImpl();
 public void doGet(HttpServletRequest request, HttpServletResponse response) {
 userService.update(...);
 }
}
public class UserServiceImpl implements UserService {
 // 记录调用次数     不安全
 private int count = 0;
 public void update() {
 // ...
 count++;
 }
}

例3：

@Aspect
@Component
//Spring 容器实例默认是单例，会被多个线程共享，可以换成环绕通知
public class MyAspect {
 // 是否安全？  不安全
 private long start = 0L;
 @Before("execution(* *(..))")
 public void before() {
 start = System.nanoTime();
 }
 @After("execution(* *(..))")
 public void after() {
 long end = System.nanoTime();
 System.out.println("cost time:" + (end-start));
 }
}

例4：

public class MyServlet extends HttpServlet {
 // 是否安全   是  私有的，不可变
 private UserService userService = new UserServiceImpl();
 public void doGet(HttpServletRequest request, HttpServletResponse response) {
 userService.update(...);
 }
}
public class UserServiceImpl implements UserService {
 // 是否安全  是，无成员变量
 private UserDao userDao = new UserDaoImpl();
 public void update() {
 userDao.update();
 }
}
//没有成员变量，线程安全
public class UserDaoImpl implements UserDao { 
 public void update() {
 String sql = "update user set password = ? where username = ?";
 // 是否安全  安全，局部变量
 try (Connection conn = DriverManager.getConnection("","","")){
 // ...
 } catch (Exception e) {
 // ...
 }
 }
}

例5：

public class MyServlet extends HttpServlet {
 // 是否安全  否
 private UserService userService = new UserServiceImpl();
 public void doGet(HttpServletRequest request, HttpServletResponse response) {
 userService.update(...);
 }
}
public class UserServiceImpl implements UserService {
 // 是否安全  否
 private UserDao userDao = new UserDaoImpl();
 public void update() {
 userDao.update();
 }
}
public class UserDaoImpl implements UserDao {
 // 是否安全  不安全
 private Connection conn = null;
 public void update() throws SQLException {
 String sql = "update user set password = ? where username = ?";
 conn = DriverManager.getConnection("","","");
 // ...
 conn.close();
 }
}

例6：

public class MyServlet extends HttpServlet {
 // 是否安全
 private UserService userService = new UserServiceImpl();
 public void doGet(HttpServletRequest request, HttpServletResponse response) {
 userService.update(...);
 }
}
public class UserServiceImpl implements UserService { 
 public void update() {
 UserDao userDao = new UserDaoImpl();
 userDao.update();
 }
}
public class UserDaoImpl implements UserDao {
 // 是否安全  线程安全，但不推荐这种写法
 private Connection conn = null;
 public void update() throws SQLException {
 String sql = "update user set password = ? where username = ?";
 conn = DriverManager.getConnection("","","");
 // ...
 conn.close();
 }
}

例7：

public abstract class Test {
    public void bar() {
        // 是否安全   SimpleDateFormat本身不是线程安全的
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        foo(sdf);
    }
    //foo 方法被继承，从而可能被修改造成线程不安全
    public abstract foo(SimpleDateFormat sdf);
    public static void main(String[] args) {
        new Test().bar();
    }
}

其中 foo 的行为是不确定的，可能导致不安全的发生，被称之为外星方法

public void foo(SimpleDateFormat sdf) {
    String dateStr = "1999-10-11 00:00:00";
    for (int i = 0; i < 20; i++) {
        new Thread(() -> {
            try {
                sdf.parse(dateStr);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

请比较 JDK 中 String 类的实现
String 为什么是final 类的原因之一就是 防止被子类继承后状态被修改，造成线程不安全，体现了闭合原则

例8： 线程不安全

@Slf4j
public class TestConcurrent {
    private static Integer i = 0;
    private final static Object o = 0;
    public static void main(String[] args) {
        List<Thread> list = new ArrayList<>();
        for (int j = 0; j < 2; j++) {
            Thread thread = new Thread(() -> {
                for (int k = 0; k < 5000; k++) {
                    synchronized (i) {
                        i++;
                    }
                }
            }, "" + j);
            list.add(thread);
        }
        list.stream().forEach(t -> t.start());
        list.stream().forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        log.debug("{}", i);
    }
}

4.5 习题

卖票练习

//模拟卖票
public class TestSell {
    public static void main(String[] args) throws InterruptedException {
        //模拟多人买票
        TicketWindow window = new TicketWindow(2000);
        //卖出的票数统计,线程安全
        List<Integer> soldAmount = new Vector<>();
        //买票人数
        List<Thread> threads = new ArrayList<>();
        for (int i = 0; i < 5000; i++) {
            Thread thread = new Thread(() -> {
                int sell = window.sell(Tools.getTicket());
                soldAmount.add(sell);
            });
            threads.add(thread);
            thread.start();
        }
        //等待所有线程执行完毕
        for (Thread thread : threads) {
            thread.join();
        }
        System.out.println("余票:" + window.getCount());
        System.out.println("卖出:" + soldAmount.stream().mapToInt(i -> i).sum());
    }
}
//售票窗口
class TicketWindow {
    private int count;
    public TicketWindow(int count) {
        this.count = count;
    }
    //获取余票数量
    public int getCount() {
        return count;
    }
    //售票
    public synchronized int sell(int amount) {
        if (this.count >= amount) {
            this.count = this.count - amount;
            return amount;
        } else {
            return 0;
        }
    }
}

将上述代码打包成可运行jar

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-shade-plugin</artifactId>
    <version>2.4.1</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>shade</goal>
            </goals>
            <configuration>
                <transformers>
                    <transformer
                            implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                        <mainClass>com.zhr.TestSell</mainClass>
                    </transformer>
                </transformers>
            </configuration>
        </execution>
    </executions>
</plugin>

使用windows脚本多次运行

for /L %n in (1,1,10) do java -jar codeforpackage-1.0.0.jar

售票方法不加synchronized关键字，运行结果

F:\DOCUMENTS\IDEAProjects\java-study\codeforpackage\target>java -jar codeforpackage-1.0.0.jar
08:20:41.605 [main] INFO com.zhr.TestSell - 余票:0
08:20:41.620 [main] INFO com.zhr.TestSell - 卖出:2004
F:\DOCUMENTS\IDEAProjects\java-study\codeforpackage\target>java -jar codeforpackage-1.0.0.jar
08:20:42.641 [main] INFO com.zhr.TestSell - 余票:0
08:20:42.656 [main] INFO com.zhr.TestSell - 卖出:2002

加synchronized关键字之后则OK

转账练习

public class 转账 {
    public static void main(String[] args) throws InterruptedException {
        Account a = new Account(1000);
        Account b = new Account(1000);
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                a.transfer(b, Tools.get(100));
            }
        }, "aaa");
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                b.transfer(a, Tools.get(100));
            }
        }, "bbb");
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println("当前总额:" + (a.getMoney() + b.getMoney()));
    }
}
class Account {
    private int money;
    public Account(int money) {
        this.money = money;
    }
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
    public void transfer(Account target, int amount) {
        //效率低，是一个简单的解决方法
        synchronized (Account.class) {
            if (this.money >= amount) {
                this.setMoney(this.getMoney() - amount);
                target.setMoney(target.getMoney() + amount);
            }
        }
    }
}

4.6 Monitor 概念

Java 对象头

32 位虚拟机
普通对象

Klass Word 指向对象所从属的class
数组对象

其中 Mark Word 结构为

hashcode hash码
age 垃圾回收时的分代年龄
biased_lock 偏向锁 是否启用了偏向锁 0没有启用偏向锁 1 启用了偏向锁
state 加锁状态

thread 偏向锁时的线程ID
epoch 批量重定向和批量撤销时使用

ptr_to_lock_record 指向栈帧中琐记录的指针
ptr_to_heavyweight_monitor 指向monitor对象的指针

64位虚拟机
java 8默认开启指针压缩 关闭前占96bit 关闭后占128bit(关闭，命令 -XX:-UseCompressedOops)

64 位虚拟机 Mark Word

参考资料 https://stackoverflow.com/questions/26357186/what-is-in-java-object-header

Monitor(锁)原理

Monitor 被翻译为监视器或管程
每个 Java 对象都可以关联一个 Monitor 对象，如果使用 synchronized 给对象上锁（重量级）之后，该对象头的Mark Word 中就被设置指向 Monitor 对象的指针
Monitor 结构如下

刚开始 Monitor 中 Owner 为 null
当 Thread-2 执行 synchronized(obj) 就会将 Monitor 的所有者 Owner 置为 Thread-2，Monitor中只能有一个 Owner
在 Thread-2 上锁的过程中，如果 Thread-3，Thread-4，Thread-5 也来执行 synchronized(obj)，就会进入EntryList BLOCKED
Thread-2 执行完同步代码块的内容，然后唤醒 EntryList 中等待的线程来竞争锁，竞争的时是非公平的
图中 WaitSet 中的 Thread-0，Thread-1 是之前获得过锁，但条件不满足进入 WAITING 状态的线程，后面讲wait-notify 时会分析

注意： synchronized 必须是进入同一个对象的 monitor 才有上述的效果 不加 synchronized 的对象不会关联监视器，不遵从以上规则

synchronized原理

static final Object lock = new Object();
static int counter = 0;
public static void main(String[] args) {
    synchronized (lock) {
        counter++;
    }
}

对应字节码

 public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=3, args_size=1
         0: getstatic     #2                      // <- 获取lock引用 （synchronized开始）
         3: dup                                    // 复制一份
         4: astore_1                             // 复制的lock引用 -> 存储到slot 1 （便于解锁）
         5: monitorenter                          // （对应synchronized关键字）将 lock对象 MarkWord 置为 Monitor 指针  
         6: getstatic     #3                      // Field counter:I   // <- i
         9: iconst_1                            // 准备常数 1
        10: iadd                                // +1
        11: putstatic     #3                      // Field counter:I   // -> i
        14: aload_1                                // <- lock引用（astore_1存储的lock引用）
        15: monitorexit                            // 将 lock对象 MarkWord 重置, 唤醒 EntryList
        16: goto          24
        19: astore_2                            // e -> slot 2
        20: aload_1                                // <- lock引用
        21: monitorexit                            // 将 lock对象 MarkWord 重置, 唤醒 EntryList
        22: aload_2                                // <- slot 2 (e)
        23: athrow                                // <- slot 2 (e)
        24: return
      Exception table:
         from    to  target type
             6    16    19   any
            19    22    19   any
      LineNumberTable:
        line 7: 0
        line 8: 6
        line 9: 14
        line 10: 24
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      25     0  args   [Ljava/lang/String;
      StackMapTable: number_of_entries = 2
        frame_type = 255 /* full_frame */
          offset_delta = 19
          locals = [ class "[Ljava/lang/String;", class java/lang/Object ]
          stack = [ class java/lang/Throwable ]
        frame_type = 250 /* chop */
          offset_delta = 4

注意 方法级别的 synchronized 不会在字节码指令中有所体现

小故事

故事角色
老王 - JVM
小南 - 线程
小女 - 线程
房间 - 对象
房间门上 - 防盗锁 - Monitor
房间门上 - 小南书包 - 轻量级锁
房间门上 - 刻上小南大名 - 偏向锁
批量重刻名 - 一个类的偏向锁撤销到达 20 阈值
不能刻名字 - 批量撤销该类对象的偏向锁，设置该类不可偏向
小南要使用房间保证计算不被其它人干扰（原子性），最初，他用的是防盗锁，当上下文切换时，锁住门。这样，即使他离开了，别人也进不了门，他的工作就是安全的。
但是，很多情况下没人跟他来竞争房间的使用权。小女是要用房间，但使用的时间上是错开的，小南白天用，小女晚上用。每次上锁太麻烦了，有没有更简单的办法呢？
小南和小女商量了一下，约定不锁门了，而是谁用房间，谁把自己的书包挂在门口，但他们的书包样式都一样，因此每次进门前得翻翻书包，看课本是谁的，如果是自己的，那么就可以进门，这样省的上锁解锁了。万一书包不是自己的，那么就在门外等，并通知对方下次用锁门的方式。
后来，小女回老家了，很长一段时间都不会用这个房间。小南每次还是挂书包，翻书包，虽然比锁门省事了，但仍然觉得麻烦。
于是，小南干脆在门上刻上了自己的名字：【小南专属房间，其它人勿用】，下次来用房间时，只要名字还在，那么说明没人打扰，还是可以安全地使用房间。如果这期间有其它人要用这个房间，那么由使用者将小南刻的名字擦掉，升级为挂书包的方式。
同学们都放假回老家了，小南就膨胀了，在 20 个房间刻上了自己的名字，想进哪个进哪个。后来他自己放假回老家了，这时小女回来了（她也要用这些房间），结果就是得一个个地擦掉小南刻的名字，升级为挂书包的方式。老王觉得这成本有点高，提出了一种批量重刻名的方法，他让小女不用挂书包了，可以直接在门上刻上自己的名字
后来，刻名的现象越来越频繁，老王受不了了：算了，这些房间都不能刻名了，只能挂书包

1. 轻量级锁

轻量级锁的使用场景：如果一个对象虽然有多线程要加锁，但加锁的时间是错开的（也就是没有竞争），那么可以使用轻量级锁来优化。
轻量级锁对使用者是透明的，即语法仍然是 synchronized
假设有两个方法同步块，利用同一个对象加锁

static final Object obj = new Object();
public static void method1() {
    synchronized( obj ) {
        // 同步块 A
        method2();
    }
}
public static void method2() {
    synchronized( obj ) {
        // 同步块 B
    }
}

创建锁记录（Lock Record）对象，每个线程的栈帧都会包含一个锁记录的结构，内部可以存储锁定对象的Mark Word

让锁记录中 Object reference 指向锁对象，并尝试用 cas 替换 Object 的 Mark Word，将 Mark Word 的值存入锁记录

如果 cas 替换成功，对象头中存储了 锁记录地址和状态 00 ，表示由该线程给对象加锁，这时图示如下

如果 cas 失败，有两种情况

• 如果是其它线程已经持有了该 Object 的轻量级锁，这时表明有竞争，进入锁膨胀过程
• 如果是自己执行了 synchronized 锁重入，那么再添加一条 Lock Record 作为重入的计数

当退出 synchronized 代码块（解锁时）如果有取值为 null 的锁记录，表示有重入，这时重置锁记录，表示重入计数减一

当退出 synchronized 代码块（解锁时）锁记录的值不为 null，这时使用 cas 将 Mark Word 的值恢复给对象头

• 成功，则解锁成功

• 失败，说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁解锁流程

  2. 锁膨胀

  如果在尝试加轻量级锁的过程中，CAS 操作无法成功，这时一种情况就是有其它线程为此对象加上了轻量级锁（有竞争），这时需要进行锁膨胀，将轻量级锁变为重量级锁。

  static Object obj = new Object();
  public static void method1() {
    synchronized( obj ) {
        // 同步块
    }
  }

  当 Thread-1 进行轻量级加锁时，Thread-0 已经对该对象加了轻量级锁
  
  这时 Thread-1 加轻量级锁失败，进入锁膨胀流程

• 即为 Object 对象申请 Monitor 锁，让 Object 指向重量级锁地址

• 然后自己进入 Monitor 的 EntryList BLOCKED

当 Thread-0 退出同步块解锁时，使用 cas 将 Mark Word 的值恢复给对象头，失败。这时会进入重量级解锁流程，即按照 Monitor 地址找到 Monitor 对象，设置 Owner 为 null，唤醒 EntryList 中 BLOCKED 线程

3. 自旋优化

重量级锁竞争的时候，还可以使用自旋来进行优化，如果当前线程自旋成功（即这时候持锁线程已经退出了同步块，释放了锁），这时当前线程就可以避免阻塞。
自旋重试成功的情况

自旋重试失败的情况

自旋会占用 CPU 时间，单核 CPU 自旋就是浪费，多核 CPU 自旋才能发挥优势。
在 Java 6 之后自旋锁是自适应的，比如对象刚刚的一次自旋操作成功过，那么认为这次自旋成功的可能性会高，就多自旋几次；反之，就少自旋甚至不自旋，总之，比较智能。
Java 7 之后不能控制是否开启自旋功能

4. 偏向锁

轻量级锁在没有竞争时（就自己这个线程），每次重入仍然需要执行 CAS 操作。
Java 6 中引入了偏向锁来做进一步优化：只有第一次使用 CAS 将线程 ID 设置到对象的 Mark Word 头，之后这个线程发现对象头线程 ID 是自己的就表示没有竞争，不用重新 CAS。以后只要不发生竞争，这个对象就归该线程所有
例如：

static final Object obj = new Object();
public static void m1() {
    synchronized (obj) {
        // 同步块 A
        m2();
    }
}
public static void m2() {
    synchronized (obj) {
        // 同步块 B
        m3();
    }
}
public static void m3() {
    synchronized (obj) {
        // 同步块 C
    }
}

偏向状态
回忆一下对象头格式