JavaEE之线程（4）——线程安全、线程安全的原因，synchronized关键字

前言

在本栏的前面的内容中，我们介绍了线程的创建、Thread 类及常见方法、线程的状态，今天我们来介绍一下关于线程的另一个重点知识——线程安全。

一、线程安全

基本概念：

线程安全的确切定义是复杂的，但我们可以这样认为：如果多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，则说这个程序是线程安全的。

我们给出一个具体例子，这个自加到10000的例子将会很好的体现线程安全：

static class Counter {
	public int count = 0;
	void increase() {
	count++;
	}
}

public static void main(String[] args) throws InterruptedException {
	final Counter counter = new Counter();
	Thread t1 = new Thread(() -> {
		for (int i = 0; i < 50000; i++) {
			counter.increase();
		}
	});
	Thread t2 = new Thread(() -> {
		for (int i = 0; i < 50000; i++) {
			counter.increase();
		}
	});
	t1.start();
	t2.start();
	t1.join();
	t2.join();
	System.out.println(counter.count);
	
	-----------------------------------------------
	
	输出结果:59970
}

那么问题来了，理想输出结果为100000，但实际结果为什么不符合呢？

二、线程不安全的原因

首先，让我们理解一下什么是原子性

2.1 什么是原子性

 我们把一段代码想象成一个房间，每个线程就是要进入这个房间的人。如果没有任何机制保证，A进入房间之后，还没有出来；B 是不是也可以进入房间，打断 A 在房间里的隐私。这个就是不具备原子性的。
那我们应该如何解决这个问题呢?

是不是只要给房间加一把锁，A 进去就把门锁上，其他人是不是就进 不来了。这样就保证了这段代码的原子性了

一条 java 语句不一定是原子的，也不一定只是一条指令
比如刚才我们看到的 n++，其实是由三步操作组成的：

1. 从内存把数据读到 CPU
2. 进行数据更新
3. 把数据写回到 CPU
4. 不保证原子性会给多线程带来什么问题
   如果一个线程正在对一个变量操作，中途其他线程插入进来了，如果这个操作被打断了，结果就可能是
   错误的。这点也和线程的抢占式调度密切相关。如果线程不是 “抢占” 的，就算没有原子性，也问题不大。

2.2 上述代码错误的具体原因

count++ 这个操作，站在CPU的角度上，count++是由CPU通过三个指令完成的。

1. load 把数据从内存, 读到 cpu 寄存器中；
2. add把寄存器中的数据进行 +1；
3. save 把寄存器中的数据,保存到内存中。

 ;如果是多个线程执行上述代码，由于线程之间的调度顺序是“随机”的，就会导致在有些调度顺序下，上述的逻辑就会出现问题。比如，我们简单选取4种的情况举下例子：

上图中1、2两种情况没有发生逻辑错误，因此不会发生错误，但是第三、四情况就会调度顺序随机，造成代码结果出现错误。

2.3 线程安全的具体原因

1. 操作系统对于线程的调度是随机的；
2. 多个线程同时修改同一个变量；
3. 修改操作不是原子的；
4. 内存可见性；
5. 指令重排序。

三、Synchronized关键字

上述出现的线程不安全问题，通过加锁,就能解决上述问题，其中最常用的办法,就是使用synchronized 关键字。

synchronized 在使用的时候，要搭配一个 代码块{ } ；
在已经加锁的状态中，另一个线程尝试同样加这个锁，就会产生“锁冲突/锁竞争”，后一个线程就会阻塞等待-直等到前一个线程解锁为止。

让我们再次回到上面的那个例子，通过加锁便可以加锁线程安全的问题：
实例代码1：

/**
 * @author Zhang
 * @date 2024/5/515:43
 * @Description:
 */
class Counter{
    public int count;
    // 1)直接修饰普通方法;
     synchronized public void increase(){
        count++;
    }
    //上面的写法是下面的简化版本
    public void  increase2(){
         synchronized(this){
             count++;
         }
    }
    // 2)修饰静态方法;
    synchronized public static void increase4(){

    }
    public static void  increase5(){
         synchronized(Counter.class){
         }
    }
}
public class Test2 { 
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread  t1 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                counter.increase();
            }
        });
        Thread t2 = new Thread(()->{
            for (int j = 0; j < 50000; j++) {
                counter.increase();
            }
        });
        t1.start();;
        t2.start();
        t1.join();
        t2.join();
        System.out.println("count:"+counter.count);
    }
}
------------------------------------------------------

输出：100000

实例代码2：

public class Test1 {    
    private static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Object lock= new Object();
        Thread t = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                synchronized (lock){
                    count++;
                }
            }
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
               synchronized (lock){
                   count++;
               }
            }
        });
        //t、t2同时执行
        t.start();
        t2.start();
        t.join();
        t2.join();
        //预期结果100000
        System.out.println("count: "+count);
    }
}

--------------------------------------------------------
输出：100000

总结

好啦！今天我们讲解了线程安全问题，以及为什么会出现线程安全、如何解决线程安全、synchronized关键字。在本栏（https://blog.csdn.net/2301_80653026/category_12660552.html?spm=1001.2014.3001.5482）的下一节我们将继续介绍线程。