发生原因

要想解决线程安全问题,那么我们首先得知道线程安全问题为什么会发生.

发生原因:

1. 线程在操作系统中是"随机调度,抢占式执行的"[根本原因].
2. 多个线程,同时修改同一个变量
3. 修改操作不是"原子"的
4. 内存可见性问题
5. 指令重排序

解决方案

原因1和2,我们很难去改变.本文主要介绍3 . 4 , 5 后面再说.

解决线程安全问题,最主要的办法就是把"非原子"的修改,变成"原子".也就是 ---- 加锁.
此处的加锁并不是真的让 count++ 变成原子的,也没有干预到线程的调度,只不过是通过这种加锁的方式,使一个线程在执行count++的过程中,其他的线程的count++不能插队进来~

synchronized关键字

Java中提供了synchronized关键字来完成加锁操作.

synchronized ()

synchronized ( ) 是关键字,不是函数,后面的()并非是参数,而是"锁对象". ( )里的对象可以指定任何的对象.

public class Demo9 {
	//锁对象
    private static Object locker = new Object();
    
    private static int count = 0;
    
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
            	//加锁
                synchronized (locker) {
                    count++;
                }
            }
        });
        Thread t2 = new Thread(()->{
            for(int i = 0; i < 50000;i++) {
            	//加锁
                synchronized (locker) {
                    count++;
                }
            }
        });

		//创建线程
        t1.start();
        t2.start();

		//让main线程等待t1和t2
        t1.join();
        t2.join();

        System.out.println(count);
    }
}

上述代码有效的前提是,两个线程都加锁了,而且是针对同一个对象加锁了!!!

锁对象的作用就是来区分两个线程是否是针对"同一个对象"加锁.

• 是针对同一个对象加锁,此时就会出现"阻塞"(锁竞争 / 锁冲突)
• 不是针对同一个对象加锁,此时不会出现"阻塞",两个线程仍然是随机调度的并发执行.
• 锁对象,填哪个对象不重要,重要的是,多个线程是否是同一个对象~

---

刚才看到的情况是两个线程,针对一个锁加锁的,如果是多线程呢?

如果是3个线程针对同一个对象加锁~

也是类似的情况
其中某个线程先加上锁,另外两个线程阻塞等待,(哪个线程拿到锁,这个过程是不可预期的)

拿到锁的线程释放了锁之后,剩下的两个线程谁先拿到锁呢? 也是顺序不确定的!

1 2 3
比如最开始 1 拿到锁, 2 3 阻塞等待
1释放锁之后,2 和 3 谁先拿到锁? 不一定! 也是随机的,即使 2 先加锁,3后加锁,也不一定谁先拿到~

---

此处的 synchronized 是JVM 提供的功能,synchronized 底层实现就是JVM中通过C++代码来实现的
进一步的,也是依靠操作系统的 api 实现的加锁, 操作系统的 api 则是来自于cpu上支持的特殊的指令来实现的~

c++ / Python 加锁是一个函数,解锁是一个函数
像Java这种通过 synchronized 关键字,来同时完成加锁解锁,是比较少见的

---

synchronized 还可以修饰一个方法

synchronized 修饰普通的方法:

public void add() {
	synchronized (this) {
		count++;
	}
}

等价于

// 针对这个写法,锁对象就是this
synchronized public void add() {
	count++;
}

synchronized 修饰static方法:

class Counter {
	public static void func() {
		synchronized (Counter.class) {
		}
	}
}

等价于

class Counter {
	synchronized public static void func() {
	}
}

并非是写了synchronized 就一定线程安全,还是要看代码具体咋写~

换而言之,到底是否要加synchronized,怎么加锁,都是和具体的场景直接相关的

像上面那种"无脑加锁"的做法是不推荐的
使用锁是需要付出代价的(性能),使用锁就可能触发阻塞,一旦某个线程阻塞,啥时候能恢复阻塞,继续执行,是不可预期的(可能要非常多时间)

总结一下

synchronized 几种使用方式:

1. synchronized ( ) { }
   圆括号指定锁对象
2. synchronized 修饰一个普通的方法
   相当于针对 this 加锁
3. synchronized 修饰一个静态的方法
   相当于针对 对应的类对象 加锁

锁对象:

1. 可以吧任意的 Object / Object 子类的对象,作为锁对象
2. 锁对象是啥不重要,重要的是,两个线程的锁对象是否是同一个
   • 是同一个,才会出现 阻塞 / 锁竞争
   • 不是同一个,不会出现 阻塞 / 锁竞争

本文到这里就结束啦~