博客

一、共享导致的问题

1.1 举例

老王(操作系统)有一一个功能强大的算盘(CPU),现在想把它租出去，赚点外快。

小南、小女(线程)来使用这个算盘来进行一些计算, 并按照时间给老王支付费用。

但小南不能一天24小时使用算盘， 他经常要小憩一会(sleep) ，又或是去吃饭上厕所(阻塞io操作)，有时还需要一根烟，没烟时思路全无(wait) 这些情况统称为(阻塞)。



在这些时候，算盘没利用起来(不能收钱了)， 老王觉得有点不划算。另外，小女也想用用算盘,如果总是小南占着算盘，让小女觉得不公平。

于是，老王灵机一动，想了个办法[让他们每人用一会，轮流使用算盘。这样，当小南阻塞的时候，算盘可以分给小女使用，不会浪费，反之亦然。

最近执行的计算比较复杂，需要存储一些中间结果，而学生们的脑容量(工作内存)不够，所以老王申请

了一个笔记本(主存) ，把一些中间结果先记在本上。

计算流程是这样的：



但是由于分时系统，有一天还是发生了事故：

小南刚读取了初始值0做了个+1运算，还没来得及写回结果，老王说【小南，你的时间到了，该别人了，记住结果走吧】，于是小南念叨着【结果是1，结果是…】不甘心地到一边待着去了(上下文切换)。

老王说【小女,该你了】，小女看到了笔记本，上还写着0做了一个-1运算，将结果-1写入笔记本。

这时小女的时间也用完了，老王又叫醒了小南: 【小南，把你上次的题目算完吧】，小南将他脑海中的结果1写入了笔记本。



小南和小女都觉得自己没做错，但笔记本里的结果是1而不是0。

1.2 Java的体现

两个线程同时对变量

counter

进行5000次自增和5000次自减，但是结果不为0。

@Slf4j(topic = "test1")
public class test1 {
    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("result: {}", counter);
    }
}

运算结果（不唯一）：

19:08:55.503 [main] DEBUG test1 - result: -1211

问题分析：

以上的结果可能是正数、负数、零。为什么呢？因为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行代码可能交错运行：

出现负数的情况：



出现正数情况

1.3 相关概念

1.3.1 临界区 Critical Section

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

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

1.3.2 竞态条件 Race Condition

多个线程在临界区内执行，由于代码的

执行序列不同

而导致结果无法预测，称之为发生了

竞态条件

。

二、synchronized语法

2.1 互斥

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

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

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

注意

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

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

2.2 synchronized

语法

：

synchronized (对象) {
    临界区
}

解决

：创建一个对象，使用创建的对象对临界区进行加锁。上面提到的例子就能有效的解决：

@Slf4j(topic = "test2")
public class test2 {
    static int counter = 0;
    static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (lock) {
                    counter++;
                }
            }
        },"t1");

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (lock) {
                    counter--;
                }
            }
        },"t2");

        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("result: {}", counter);
    }
}

运行结果：

19:34:05.261 [main] DEBUG test2 - result: 0

可以做这样的类比：

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

2.3 思考

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

为了加深理解，请思考下面的问题

• 如果把synchronized(obj)放在for循环的外面，如何理解？
• 如果t1 synchronized(obj1)而t2 synchronized(obj2)会怎样运作?
• 如果t1 synchronized(obj)而t2没有加会怎么样?如何理解?

三、方法上的synchronized

3.1 普通方法加synchronized

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

等价于

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

3.2 静态方法加synchronized

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

等价于

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

3.3 线程八锁

考察synchronized锁住的是哪个对象

情况1

：一个对象，两个普通方法，

n1

对象被两个线程调用，其中一个线程调用时就会锁住这个对象，互斥。

@Slf4j(topic = "test3")
public class test3 {
    public static void main(String[] args) {
        Number n1 = new Number();
        new Thread(() -> {
            log.debug("begin");
            n1.a();
        }).start();
        new Thread(() -> {
            log.debug("begin");
            n1.b();
        }).start();

    }
}

@Slf4j(topic = "number")
class Number {
    public synchronized void a() {
        log.debug("1");
    }

    public synchronized void b() {
        log.debug("2");
    }
}

可能的结果为：

1 2
2 1

情况2

：一个对象，两个普通方法，给方法a加一个sleep，如果方法a先进入线程的话，那就要等待1s才能执行另一个线程。sleep不会释放锁。

@Slf4j(topic = "test3")
public class test3 {
    public static void main(String[] args) {
        Number n1 = new Number();
        new Thread(() -> {
            log.debug("begin");
            n1.a();
        }).start();
        new Thread(() -> {
            log.debug("begin");
            n1.b();
        }).start();

    }
}

@Slf4j(topic = "number")
class Number {
    public synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("1");
    }

    public synchronized void b() {
        log.debug("2");
    }
}

可能的结果有：

等待1s 1 2
2 1

情况3

：三个方法，其中一个方法无synchronized，该方法不会受到约束。

@Slf4j(topic = "test3")
public class test3 {
    public static void main(String[] args) {
        Number n1 = new Number();
        new Thread(() -> {
            log.debug("begin");
            n1.a();
        }).start();
        new Thread(() -> {
            log.debug("begin");
            n1.b();
        }).start();
        new Thread(() -> {
            log.debug("begin");
            n1.c();
        }).start();

    }
}

@Slf4j(topic = "number")
class Number {
    public synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("1");
    }

    public synchronized void b() {
        log.debug("2");
    }

    public void c() {
        log.debug("3");
    }
}

可能的结果有：

3 等待1s 1 2
2 3 等待1s 1
3 2 等待1s 1

情况4

：两个对象，两个线程分别调用两个不同的对象方法。所以，两个线程互不影响。

@Slf4j(topic = "test3")
public class test3 {
    public static void main(String[] args) {
        Number n1 = new Number();
        Number n2 = new Number();
        new Thread(() -> { n1.a();}).start();
        new Thread(() -> { n2.b();}).start();
    }
}

@Slf4j(topic = "number")
class Number {
    public synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("1");
    }

    public synchronized void b() {
        log.debug("2");
    }
}

结果：

2 等待1s  1

情况5

：一个静态方法、一个普通方法，原理与情况4相同。

@Slf4j(topic = "test3")
public class test3 {
    public static void main(String[] args) {
        Number n1 = new Number();
        new Thread(() -> { n1.a();}).start();
        new Thread(() -> { n1.b();}).start();
    }
}

@Slf4j(topic = "number")
class Number {
    public static synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("1");
    }

    public synchronized void b() {
        log.debug("2");
    }
}

结果：

2 等待1s  1

情况6

：两个静态方法，线程调用同一对象，互斥，原理与情况2相同。

@Slf4j(topic = "test3")
public class test3 {
    public static void main(String[] args) {
        Number n1 = new Number();
        new Thread(() -> { n1.a();}).start();
        new Thread(() -> { n1.b();}).start();
    }
}

@Slf4j(topic = "number")
class Number {
    public static synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("1");
    }

    public static synchronized void b() {
        log.debug("2");
    }
}

可能的结果有：

等待1s 1 2
2 等待1s 1

情况7

：一个普通方法、一个静态方法，线程调用同一对象，互斥，原理与情况2、6相同。

@Slf4j(topic = "test3")
public class test3 {
    public static void main(String[] args) {
        Number n1 = new Number();
        new Thread(() -> { n1.a();}).start();
        new Thread(() -> { n1.b();}).start();
    }
}

@Slf4j(topic = "number")
class Number {
    public static synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("1");
    }

    public synchronized void b() {
        log.debug("2");
    }
}

结果：

2 等待1s 1

情况8

：两个静态方法、两个线程调用两个对象，因为两个对象对应一个类，所以他们互斥。

@Slf4j(topic = "test3")
public class test3 {
    public static void main(String[] args) {
        Number n1 = new Number();
        Number n2 = new Number();
        new Thread(() -> { n1.a();}).start();
        new Thread(() -> { n2.b();}).start();
    }
}

@Slf4j(topic = "number")
class Number {
    public static synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("1");
    }

    public static synchronized void b() {
        log.debug("2");
    }
}

可能的结果有：

等待1s 1 2
2 等待1s 1