Java多线程——线程安全、synchronized、volatile关键字以及多线程案例

---

前言

多线程是java编程中很重要的一个知识点，上一篇文章大致介绍了多线程的基础，本篇紧接上篇，将对线程安全以及解决线程安全的手段进行总结，然后介绍几个多线程案例。

---

一、线程安全—多线程不可避免的风险！

线程安全的定义：如果多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，则说这个程序是线程安全的。

1、线程不安全的示例

先观察下面这段代码：

public class Demo23 {
    private static int count = 0;

    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();
        Thread t1 = new Thread(() -> {
                for (int i = 0; i < 5_0000; i++) {
                    count++;
                }
        });
        Thread t2 = new Thread(()->{
                for (int i = 0; i < 5_0000; i++) {
                    count++;
                }
        });
        t1.start();
        t2.start();
        //打印count值的时候, 需要等待t1 和t2 执行完
        t1.join();
        t2.join();
        System.out.println(count);

    }
}

如果放在单线程的情况下，那么两个for循环分别对count变量进行50_000次自增，所以结果应该是100_000，但结果并不像我们想的那样，这就是一个线程不安全的案例。运行结果为什么是这样？究其原因，是因为上面这个代码，两个线程在对同一个静态变量count进行了修改，此时这个count是一个多个线程都能访问到的“共享数据”，问题就出在这里！

count++，其实就是count=count+1，这行代码对应了三个指令：指令是原子性的，不可分割，要么成功要么失败，不存在中间态。

• 从内存读取count值 ——LOAD
• 对数据进行+1操作 ——ADD
• 将修改后的数据写回主内存 ——SAVE

线程的调度是随机的，因此线程2得到CPU资源时，可能线程1正在对count进行ADD操作但还没有存回主内存，可能发生在任意时刻。这就导致了有可能两个线程都对count进行了+1，但是count只增加了1。导致线程不安全的根本原因，就是线程的随机性！

画张图解释一下：

通过synchronized加锁，将count++这个操作变成原子性的操作，也就把两个线程对数据的操作变成了串行。如果将锁从run方法开头锁到run方法结束，其实这里的多线程就“名存实亡”了。

2、线程不安全的原因

• 线程调度的随机性（这是根本原因，但我们解决不了，无可奈何）
• 多个线程对同一个变量进行修改操作（也不一定能解决，上面的例子可以解决）
• 原子性：如果对共享变量的操作不是原子性的，就会有安全问题
• 内存可见性一个线程对数据的操作，可能是其他线程是无感知的，所以对数据进行了更改其他线程没有及时从主内存中读取数据
• 指令重排序：编译器会对代码进行优化，可能会打乱代码的执行顺序。

既然前两个原因不好解决，后面将要讲到的解决方案，就是针对后面三个的。

二、synchronized关键字

1.synchronized的特性

1）互斥

synchronized 会起到互斥效果, 某个线程执行到某个对象的 synchronized 中时, 其他线程如果也执行到同一个对象 synchronized 就会阻塞等待(进入Blocked状态)。

• 进入 synchronized 修饰的代码块, 相当于 加锁
• 退出 synchronized 修饰的代码块, 相当于 解锁

synchronized用的锁是存在Java对象头里的。

可以粗略理解成, 每个对象在内存中存储的时候, 都存有一块内存表示当前的 “锁定” 状态(类似于厕所的 “有人/无人”).
如果当前是 “无人” 状态, 那么就可以使用, 使用时需要设为 “有人” 状态.
如果当前是 “有人” 状态, 那么其他人无法使用, 只能排队

理解 “阻塞等待”.
针对每一把锁, 操作系统内部都维护了一个等待队列. 当这个锁被某个线程占有的时候, 其他线程尝试进行加锁, 就加不上了, 就会阻塞等待, 一直等到之前的线程解锁之后, 由操作系统唤醒一个新的线程, 再来获取到这个锁。

注意

• 上一个线程解锁之后, 下一个线程并不是立即就能获取到锁. 而是要靠操作系统来 “唤醒”. 这也就是操作系统线程调度的一部分工作.
• 假设有 A B C 三个线程, 线程 A 先获取到锁, 然后 B 尝试获取锁, 然后 C 再尝试获取锁, 此时 B和 C 都在阻塞队列中排队等待. 但是当 A 释放锁之后, 虽然 B 比 C 先来的, 但是 B 不一定就能获取到锁, 而是和 C 重新竞争, 并不遵守先来后到的规则（非公平锁）
• synchronized的底层是使用操作系统的mutex lock实现的。

2）刷新内存

synchronized的工作过程：

1. 获得互斥锁
2. 从主内存拷贝变量的最新副本到工作内存
3. 执行代码
4. 将更改后的共享变量的值刷新到主内存
5. 释放互斥锁

所以synchronized也能保证内存可见性，可以对比下面的volatile部分。

3）可重入

synchronized 同步块对同一条线程来说是可重入的，不会出现自己把自己锁死的问题

理解 “把自己锁死”

一个线程没有释放锁, 然后又尝试再次加锁

// 第一次加锁, 加锁成功
lock();
// 第二次加锁, 锁已经被占用, 阻塞等待.
lock();

按照之前对于锁的设定, 第二次加锁的时候, 就会阻塞等待. 直到第一次的锁被释放, 才能获取到第二个锁. 但是释放第一个锁也是由该线程来完成, 结果这个线程已经躺平了, 啥都不想干了, 也就无法进行解锁操作. 这时候就会 死锁,

这样的锁称为不可重入锁，Java中的synchronized是可重入锁，不会有死锁的问题。

在可重入锁的内部, 包含了 “线程持有者” 和 “计数器” 两个信息.

• 如果某个线程加锁的时候, 发现锁已经被人占用, 但是恰好占用的正是自己, 那么仍然可以继续获取到锁, 并让计数器自增.
• 解锁的时候计数器递减为 0 的时候, 才真正释放锁. (才能被别的线程获取到）

2、synchronized使用示例

synchronized 本质上要修改指定对象的 “对象头”. 从使用角度来看, synchronized 也势必要搭配一个具体的对象来使用。

1)直接修饰普通方法: 锁的 SynchronizedDemo 对象

public class SynchronizedDemo {
	public synchronized void methond() {
	}
}

2) 修饰静态方法: 锁的 SynchronizedDemo 类的对象

public class SynchronizedDemo {
	public synchronized static void method() {
	}
}

3) 修饰代码块: 明确指定锁哪个对象.

锁当前对象：

public class SynchronizedDemo {
	public void method() {
		synchronized (this) {
		}
	}
}

锁类对象：

public class SynchronizedDemo {
	public void method() {
		synchronized (SynchronizedDemo.class) {
		}
	}
}

重点要理解，synchronized 锁的是什么. 两个线程竞争同一把锁, 才会产生阻塞等待.
两个线程分别尝试获取两把不同的锁, 不会产生竞争.

3、Java标准库中的线程安全类

Java标准库中很多都是线程不安全的，这些类可能会涉及到多线程修改共享数据，又没有任何加锁措施。

• ArrayList
• LinkedList
• HashMap
• TreeMap
• HashSet
• TreeSet
• StringBuilder

但是还有一些是线程安全的. 使用了一些锁机制来控制.

• Vector (不推荐使用)
• HashTable (不推荐使用)
• ConcurrentHashMap
• StringBuffer

StringBuffer 的核心方法都带有 synchronized

加锁保证安全性，但不加锁普遍效率要高于加锁（StringBuilder效率就高于StringBuffer，但后者是线程安全的）。

三、volatile关键字

1、volatile能保证内存可见性

volatile修饰的变量，能够保证“内存可见性”。

代码在写入volatile修饰的变量时

• 改变线程工作内存中volatile变量副本的值
• 将改变后的副本的值从工作内存刷新到主内存

代码在读取volatile修饰的变量的时候

• 从主内存中读取volatile变量的最新值到线程的工作内存中
• 从工作内存中读取volatile变量的副本

直接访问工作内存(实际是 CPU 的寄存器或者 CPU 的缓存), 速度非常快, 但是可能出现数据不一致的情况.
加上 volatile , 强制读写内存. 速度是慢了, 但是数据变的更准确了

代码示例：

在这个代码中有两个线程（创建的t1和main线程），t1包含一个循环，这个循环以flag==0为循环条件。在主线程中从键盘读入一个整数，并把这个整数赋值给flag。预期当用户输入非零的值时，t1线程结束。

public class Demo28 {
    static  int flag = 0;
    public static void main(String[] args) {

        Thread t1 = new Thread(()->{
            System.out.println("t1 开始循环...");
            while (flag == 0){
              //什么都不做
            }
            System.out.println("t1 循环结束...");
        });
        t1.start();

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入flag的值:");
        flag = scanner.nextInt();
    }
}

执行效果：

与预想的不一样，用户输入非0值时，t1线程没有结束。因为这里的t1读取的是自己工作内存中的内容，当主线程中对flag变量进行修改，t1感知不到flag的变化。

给flag加上volatile关键字后：

2、volatile不保证原子性

volatile和synchronized有着本质的区别，synchronized能够保证原子性，volatile保证的是内存可见性。比如上一篇文章提到的两个线程分别对count进行5w次自增的例子，我们使用volatile修饰count，最终结果仍然不是预期的100000.

3、synchronized和volatile的对比。

严格来说，synchronized和volatile并没有什么联系，但是因为二者都是Java关键字且用来解决线程安全问题，因此很容易扯在一起。

synchronized	volatile
通过加锁解锁的方式，将代码绑定在一起，保证原子性	不能保证原子性
通过加锁解锁的方式，保证了内存可见性	通过强制从主内存读取数据，保证了内存可见性
对指令重排序有一定的约束	禁止指令重排序

既然synchronized在大多数情况都可以保证线程安全，是不是无脑使用synchronized就行呢？当然不是。

synchronized是要付出一定代价的，synchronized是通过加锁,解锁的方式来保证的,所以,其他线程抢不到锁的时候,线程会阻塞线程就会放弃CPU,放弃之后,什么时候才能重新被调用,是不确定的。使用了synchronized,就代表着,你在一定程度上,放弃了高性能。多线程是为了提高效率，使用synchronized又会放弃一定的效率来保证安全，volatile虽然也会对性能产生一定影响，但不会造成线程阻塞，影响也没有synchronized大。因此有些情况下，使用volatile更合适。

四、wait和notify

1、wait()方法

wait做的事情：

• 使当前执行代码的线程进行等待. (把线程放到等待队列中)
• 释放当前的锁
• 满足一定条件时被唤醒, 重新尝试获取这个锁

wait 要搭配 synchronized 来使用. 脱离 synchronized 使用 wait 会直接抛出异常。

代码示例：

public static void main(String[] args) throws InterruptedException {
	Object object = new Object();
	synchronized (object) {
		System.out.println("等待中");
		object.wait();
		System.out.println("等待结束");
	}
}

这样在执行到object.wait()之后就一直等待下去，那么程序肯定不能一直这么等待下去了。这个时候就需要使用到了另外一个方法唤醒的方法notify()。

2、notify()方法

notify 方法是唤醒等待的线程.

• 方法notify()也要在同步方法或同步块中调用，该方法是用来通知那些可能等待该对象的对象锁的其它线程，对其发出通知notify，并使它们重新获取该对象的对象锁。
• 如果有多个线程等待，则有线程调度器随机挑选出一个呈 wait 状态的线程。(并没有 “先来后到”)
• 在notify()方法后，当前线程不会马上释放该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出同步代码块之后才会释放对象锁。

代码示例: 使用notify()方法唤醒线程

• 创建 WaitTask 类, 对应一个线程, run 内部循环调用 wait.
• 创建 NotifyTask 类, 对应另一个线程, 在 run 内部调用一次 notify
• 注意, WaitTask 和 NotifyTask 内部持有同一个 Object locker. WaitTask 和 NotifyTask 要想配合就需要搭配同一个 Object.

static class WaitTask implements Runnable {
	private Object locker;
	public WaitTask(Object locker) {
		this.locker = locker;
		}
	@Override
	public void run() {
		synchronized (locker) {
			while (true) {
				try {
					System.out.println("wait 开始");
					locker.wait();
					System.out.println("wait 结束");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}
--------------------------------------------------------------
static class NotifyTask implements Runnable {
	private Object locker;
	public NotifyTask(Object locker) {
		this.locker = locker;
	}
	@Override
	public void run() {
		synchronized (locker) {
			System.out.println("notify 开始");
			locker.notify();
			System.out.println("notify 结束");
		}
	}
}
public static void main(String[] args) throws InterruptedException {
		Object locker = new Object();
		Thread t1 = new Thread(new WaitTask(locker));
		Thread t2 = new Thread(new NotifyTask(locker));
		t1.start();
		Thread.sleep(1000);
		t2.start();
	}

3、notifyAll()方法

notify方法只是唤醒某一个等待线程. 使用notifyAll方法可以一次唤醒所有的等待线程.

值得注意的是：虽然是同时唤醒多个线程，但是这些线程还是需要重新竞争锁，并不是同时执行，仍然是有先后的执行。

理解 notify 和 notifyAll

notify 只唤醒等待队列中的一个线程. 其他线程还是乖乖等着

notifyAll 一下全都唤醒, 需要这些线程重新竞争锁

4、wait和sleep对比

其实理论上wait和sleep是完全没有可比性的，因为一个是用于线程之间通信的，一个是让线程阻塞一段时间。

唯一的相同点是都可以让线程放弃执行一段时间。

区别：

• 进入的阻塞状态不同

sleep()→TIMED_WAITTING
wait()→WAITTING
wait(long time)→TIMED_WAITTING

• 使用方面：wait需要搭配synchronized一起使用，sleep不需要

• 类的方面：wait是Object的方法，sleep是Thread的静态方法

总结

保证线程安全的思路：

1. 使用没有共享资源的模型

2. 使用共享资源只读不写的模型

1)不需要写共享资源的模型
2)使用不可变对象

3. 直面线程安全（重点）

1）保证原子性
2）保证内存可见性
3）保证指令顺序性

本篇文章，着重讲解了多线程下的安全问题，以及详细介绍了解决线程安全问题的方法和思路，对synchronized关键字和volatile关键字以及wait、notify方法做了介绍。至此，多线程的初阶知识已经大概学完了，下周开始进阶！！！