共享模型之管程

1共享带来的问题

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

    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);
    }

字节码的可读性非常低。字节码指令通常是由编译器或解释器生成的，它们被用于在虚拟机上执行程序。

加图片来说明（p36-p38）

1.1 临界区

1.一个程序运行多个线程本身是没有问题的

2.问题出在多个线程访问共享资源

多个线程读共享资源其实也没有问题

在多个线程对共享资源读写操作时发生指令交错，就会出现问题

3.一段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为临界区

1.2 竞态条件 Race Condition

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

 2.synchronized

2.1 synchronized加在对象上

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

阻塞式的解决方案：synchronized，Lock

非阻塞式的解决方案：原子变量

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

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

14:31:38.844 [main] DEBUG tset.ChanellTest - 0

 图片P41

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

 synchronized 实际是用对象锁保证了临界区内代码的原子性，临界区内的代码对外是不可分割的，不会被线程切换所打断

2.2 synchronized加在方法上

synchronized只能锁对象，加在成员方法上，锁的是this对象。静态方法上，锁的就是类对象

        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) {

                }
            }
        }

3变量线程安全分析

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

1. 如果它们没有共享，则线程安全
2. 如果它们被共享了，根据它们的状态是否能够改变，又分两种情况

如果只有读操作，则线程安全

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

局部变量是否线程安全？

1. 局部变量是线程安全的
2. 但局部变量引用的对象则未必

如果该对象没有逃离方法的作用访问，它是线程安全的

如果该对象逃离方法的作用范围，需要考虑线程安全

 3.1 局部变量线程安全分析

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

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

 拓展p50-p53

3.2 常见线程安全类

String

Integer

StringBuffer

Random

Vector

Hashtable

java.util.concurrent 包下的类

说它们是线程安全的是指，多个线程调用它们同一个实例的某个方法时，是线程安全的

它们的每个方法是原子的

但注意它们多个方法的组合不是原子的

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

线程安全类方法的组合不是线程安全的，只能保证get或put方法内的代码为原子性