3.线程同步
目录
- 3.1 线程同步机制简介
- 3.2 锁概述
- 3.2.1 锁的作用
- 3.2.2 锁相关的概念
- 1.可重入性
- 2.锁的争用与调度
- 3.锁的粒度
- 3.3 synchronized 关键字
- 3.3.1 synchronized 同步代码块
- 3.3.2 同步方法
- 3.3.3 同步静态方法
- 3.3.4同步代码块与同步方法执行效率对比
- 3.3.5 死锁
- 3.3.5 线程出现异常会自动释放锁
- 3.3.6 工作原理
- 3.4volative 关键字
- 3.4.1 volatile 的作用
- 3.4.2 volatile 非原子特性
- 3.4.3 常用原子类进行自增自减操作
- 3.5 volatile 与 synchronized 比较
3.1 线程同步机制简介
线程同步机制是一套用于协调线程之间的数据访问的机制，该机制可以保障线程安全。
Java 平台提供的线程同步机制包括：锁、volatile 关键字、final 关键字、static 关键字，以及相关的 API，如 Object.wait()、Object.notify()等。
3.2 锁概述
线程安全问题的产生前提是多个线程并发访问共享数据，将多个线程对共享数据的并发访问转换为串行访问，即一个共享数据一次只能被一个线程访问，锁就是复用这种思路来保障线程安全的。
锁(Lock)可以理解为对共享数据进行保护的一个许可证，对于同一个许可证保护的共享数据来说，任何线程想要访问这些共享数据必须先持有该许可证，一个线程只有在持有许可证的情况下才能对这些共享数据进行访问；并且一个许可证一次只能被一个线程持有，拥有许可证的线程在结束对共享数据的访问后必须释放其持有的许可证。
一个线程在访问共享数据前必须先获得锁，获得锁的线程称为锁的持有线程；一个锁一次只能被一个线程持有，锁的持有线程在获得锁之后，和释放锁之前这段时间所执行的代码称为临界区(CriticalSection)。
锁具有排他性(Exclusive)，即一个锁一次只能被一个线程持有，这种锁称为排它锁或互斥锁(Mutex)。
JVM 把锁分为内部锁和显示锁两种，内部锁通过 synchronized 关键字实现；显示锁通过 java.concurrent.locks.Lock 接口的实现类实现的。
3.2.1 锁的作用
锁可以实现对共享数据的安全访问，保障线程的原子性、可见性与有序性。
锁是通过互斥保障原子性，一个锁只能被一个线程持有，这就保证临界区的代码一次只能被一个线程执行，使得临界区代码所执行的操作自然而然的具有不可分割的特性，即具备了原子性。
可见性的保障是通过写线程冲刷处理器的缓存和读线程刷新处理器缓存这两个动作实现的，在 java 平台中，锁的获得隐含着刷新处理器缓存的动作，锁的释放隐含着冲刷处理器缓存的动作。
锁能够保障有序性，写线程在临界区所执行的，在读线程所执行的临界区看起来像是完全按照源码顺序执行的。
注意:
使用锁保障线程的安全性，必须满足以下条件：
这些线程在访问共享数据时必须使用同一个锁
即使是读取共享数据的线程也需要使用同步锁
3.2.2 锁相关的概念
1.可重入性
可重入性(Reentrancy)描述这样一个问题：一个线程持有该锁的时候能再次(多次)申请该锁。
void methodA() {
// 申请 a 锁
methodB();
// 释放 a 锁
}
void methodB() {
// 申请 a 锁
....
// 释放 a 锁
}
如果一个线程持有一个锁的时候还能够继续成功申请该锁，则称该锁是可重入的，否则就称该锁为不可重入的。
2.锁的争用与调度
Java 平台中内部锁属于非公平锁, 显示 Lock 锁既支持公平锁又支持非公平锁
3.锁的粒度
一个锁可以保护的共享数据的数量大小称为锁的粒度。锁保护共享数据量大，称该锁的粒度粗；否则就称该锁的粒度细。
锁的粒度过粗会导致线程在申请锁时会进行不必要的等待，锁的粒度过细会增加锁调度的开销。
3.3 synchronized 关键字
Java 中的每个对象都有一个与之关联的内部锁，这种锁也称为监视器(Monitor)。这种内部锁是一种排他锁，可以保障原子性、可见性与有序性。
内部锁是通过 synchronized 关键字实现的，synchronized 关键字修饰代码块，修饰实例方法。
关键字 synchronized 可以保证在同一时刻，只有一个线程可以执行某个方法或某个代码块，同时 synchronized 可以保证一个线程的变化可见（可见性），即可以代替 volatile
1.普通同步方法（实例方法），锁是当前实例对象 ，进入同步代码前要获得当前实例的锁
2.静态同步方法，锁是当前类的class对象 ，进入同步代码前要获得当前类对象的锁
3.同步代码块，锁是括号里面的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁
synchronized( 对象锁 ) {
// 同步代码块,可以在同步代码块中访问共享数据
}
3.3.1 synchronized 同步代码块
/**
* synchronized 同步代码块
* this 锁对象
*/
public class Test01 {
public static void main(String[] args) {
//创建两个线程,分别调用 mm()方法
//先创建 Test01 对象,通过对象名调用 mm()方法
Test01 obj = new Test01();
new Thread(new Runnable() {
@Override
public void run() {
// 使用的锁对象 this 就是 obj对象
obj.mm();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
// 使用的锁对象 this 也是 obj对象
obj.mm();
}
}).start();
}
/**
* 使用同步代码块
*/
public void mm() {
// 使用this当前对象作为锁对象
synchronized (this) {
for (int i = 1; i <= 10; i++) {
System.out.println(Thread.currentThread().getName() + " --> " + i);
}
}
}
}
运行结果：
使用不同锁对象：
/**
* synchronized 同步代码块
* 如果线程的锁不同, 不能实现同步；想要同步必须使用同一个锁对象
*/
public class Test02 {
public static void main(String[] args) {
//创建两个线程,分别调用 mm()方法
//创建Test02类的 obj 和 obj2 两个对象,通过对象名调用 mm()方法
Test02 obj = new Test02();
Test02 obj2 = new Test02();
new Thread(new Runnable() {
@Override
public void run() {
//使用的锁对象 this 就是 obj 对象
obj.mm();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
// 使用的锁对象 this 是 obj2对象
obj2.mm();
}
}).start();
}
public void mm() {
synchronized (this) {
for (int i = 1; i <= 100; i++) {
System.out.println(Thread.currentThread().getName() + " --> " + i);
}
}
}
}
使用同一个常量对象作为锁对象：
/**
* synchronized 同步代码块
*
* 使用一个常量对象作为锁对象
*/
public class Test03 {
public static void main(String[] args) {
Test03 obj = new Test03();
Test03 obj2 = new Test03();
new Thread(new Runnable() {
@Override
public void run() {
obj.mm(); //使用的锁对象 OBJ 常量
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
obj2.mm(); //使用的锁对象 OBJ 常量
}
}).start();
}
// 定义一个常量对象
public static final Object OBJ = new Object();
public void mm() {
synchronized (OBJ) {
// 使用一个常量对象作为锁对象
for (int i = 1; i <= 10; i++) {
System.out.println(Thread.currentThread().getName() + " --> " + i);
}
}
}
}
/**
* synchronized 同步代码块
*
* 使用一个常量对象作为锁对象,不同方法中的同步代码块也可以同步
*/
public class Test04 {
public static void main(String[] args) {
Test04 obj = new Test04();
Test04 obj2 = new Test04();
new Thread(new Runnable() {
@Override
public void run() {
obj.mm(); //使用的锁对象 OBJ 常量
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
obj2.mm(); //使用的锁对象 OBJ 常量
}
}).start();
// 第三个线程调用静态方法
new Thread(new Runnable() {
@Override
public void run() {
sm(); //使用的锁对象 OBJ 常量
}
}).start();
}
// 定义一个常量对象
public static final Object OBJ = new Object();
public void mm() {
synchronized (OBJ) { //使用一个常量对象作为锁对象
for (int i = 1; i <= 5; i++) {
System.out.println(Thread.currentThread().getName() + " --> " + i);
}
}
}
public static void sm() {
synchronized (OBJ) { //使用一个常量对象作为锁对象
for (int i = 1; i <= 5; i++) {
System.out.println(Thread.currentThread().getName() + " --> " + i);
}
}
}
}
运行结果：
3.3.2 同步方法
/**
* synchronized 同步实例方法
*
* 把整个方法体作为同步代码块
* 默认的锁对象是 this 对象
*/
public class Test05 {
public static void main(String[] args) {
//先创建 Test05 对象,通过对象名调用 mm()方法
Test05 obj = new Test05();
//一个线程调用 mm()方法
new Thread(new Runnable() {
@Override
public void run() {
obj.mm(); //使用的锁对象 this 就是 obj对象
}
}).start();
// 另一个线程调用 mm22()方法
new Thread(new Runnable() {
@Override
public void run() {
obj.mm22(); //使用的锁对象 this 也是 obj 对象, 可以同步
}
}).start();
}
public void mm() {
synchronized (this) { //使用 this当前对象作为锁对象
for (int i = 1; i <= 10; i++) {
System.out.println(Thread.currentThread().getName() + " --> " + i);
}
}
}
//使用 synchronized 修饰实例方法,同步实例方法,默认 this 作为 锁对象
public synchronized void mm22() {
for (int i = 1; i <= 10; i++) {
System.out.println(Thread.currentThread().getName() + " --> " + i);
}
}
}
运行结果：
3.3.3 同步静态方法
/**
* synchronized 同步静态方法
*
* 把整个方法体作为同步代码块
* 默认的锁对象是当前类的运行时类对象Test06.class, 有人称它为类锁
*/
public class Test06 {
public static void main(String[] args) {
Test06 obj = new Test06();
// 一个线程调用 m1()方法
new Thread(new Runnable() {
@Override
public void run() {
obj.m1(); //使用的锁对象是 Test06.class
}
}).start();
// 另一个线程调用 sm2()方法
new Thread(new Runnable() {
@Override
public void run() {
Test06.sm2(); //使用的锁对象是 Test06.class
}
}).start();
}
public void m1() {
//使用当前类的运行时类对象作为锁对象,可以简单的理解为把 Test06 类的字节码文件作为锁对象
synchronized (Test06.class) {
for (int i = 1; i <= 100; i++) {
System.out.println(Thread.currentThread().getName() + " --> " + i);
}
}
}
//使用 synchronized 修饰静态方法,同步静态方法, 默认运行时类Test06.class 作为锁对象
public synchronized static void sm2() {
for (int i = 1; i <= 100; i++) {
System.out.println(Thread.currentThread().getName() + " --> " + i);
}
}
}
运行结果：
3.3.4同步代码块与同步方法执行效率对比
/**
* 同步方法与同步代码块如何选择
*
* 同步方法锁的粒度粗, 执行效率低, 同步代码块执行效率高
*/
public class Test07 {
public static void main(String[] args) {
Test07 obj = new Test07();
new Thread(new Runnable() {
@Override
public void run() {
// obj.doLongTimeTask();
obj.doLongTimeTask2();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
// obj.doLongTimeTask();
obj.doLongTimeTask2();
}
}).start();
}
//同步方法, 粒度粗, 执行效率低
public synchronized void doLongTimeTask() {
try {
System.out.println("Task Begin");
Thread.sleep(3000); //模拟任务需要准备 3 秒钟
System.out.println("开始同步");
for (int i = 1; i <= 5; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
System.out.println("Task end");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//同步代码块,锁的粒度细, 执行效率高
public void doLongTimeTask2() {
try {
System.out.println("Task Begin");
Thread.sleep(3000); //模拟任务需要准备 3 秒钟
synchronized (this) {
System.out.println("开始同步");
for (int i = 1; i <= 5; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
System.out.println("Task end");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
3.3.5 死锁
/**
* 死锁
* 在多线程程序中,同步时可能需要使用多个锁,如果获得锁的顺序不一致,可能会导致死锁
* 如何避免死锁?
* 当需要获得多个锁时,所有线程获得锁的顺序保持一致即可
*/
public class Test10 {
public static void main(String[] args) {
SubThread t1 = new SubThread();
t1.setName("a");
t1.start();
SubThread t2 = new SubThread();
t2.setName("b");
t2.start();
}
static class SubThread extends Thread {
private static final Object lock1 = new Object();
private static final Object lock2 = new Object();
@Override
public void run() {
if ("a".equals(Thread.currentThread().getName())) {
synchronized (lock1) {
System.out.println("a 线程获得了 lock1 锁,还需要获得 lock2 锁");
synchronized (lock2) {
System.out.println("a 线程获得 lock1 后又获得了 lock2,可以想干任何想干的事");
}
}
}
if ("b".equals(Thread.currentThread().getName())) {
synchronized (lock2) {
System.out.println("b 线程获得了 lock2 锁,还需要获得 lock1 锁");
synchronized (lock1) {
System.out.println("b 线程获得 lock2后又获得了 lock1,可以想干任何想干的事");
}
}
}
}
}
}
3.3.5 线程出现异常会自动释放锁
/**
* 同步过程中线程出现异常, 会自动释放锁对象
*
*/
public class Test09 {
public static void main(String[] args) {
Test09 obj = new Test09();
//一个线程调用 m1()方法
new Thread(new Runnable() {
@Override
public void run() {
obj.m1(); //使用的锁对象是 Test06.class
}
}).start();
//另一个线程调用 sm2()方法
new Thread(new Runnable() {
@Override
public void run() {
Test09.sm2(); //使用的锁对象是 Test06.class
}
}).start();
}
public void m1() {
//使用当前类的运行时类对象作为锁对象,可以简单的理解为把 Test06 类的字节码文件作为锁对象
synchronized (Test09.class) {
for (int i = 1; i <= 10; i++) {
System.out.println(Thread.currentThread().getName() + " --> " + i);
if (i == 5) {
//把字符串转换为int 类型时,如果字符串不符合 数字格式会产生异常
Integer.parseInt("abc");
}
}
}
}
//使用 synchronized 修饰静态方法,同步静态方法, 默认运行时类Test06.class 作为锁对象
public synchronized static void sm2() {
for (int i = 1; i <= 10; i++) {
System.out.println(Thread.currentThread().getName() + " --> " + i);
}
}
}
3.3.6 工作原理
synchronized底层：
JVM 是通过进入、退出对象监视器( Monitor )来实现对方法、同步块的同步的。
具体实现是在编译之后在同步方法调用前加入一个 monitor.enter 指令，在退出方法和异常处插入 monitor.exit 的指令。
其本质就是对一个对象监视器( Monitor )进行获取，而这个获取过程具有排他性从而达到了同一时刻只能一个线程访问的目的。
而对于没有获取到锁的线程将会阻塞到方法入口处，直到获取锁的线程 monitor.exit 之后才能尝试继续获取锁。
static class A{
public static void main(String[] args) {
new A().fun1(); // this对象
A.fun2(); // A.class对象
}
//修饰 普通方法 this
public synchronized void fun1(){
// 同步代码
}
//修饰 静态方法
public synchronized static void fun2(){
// 同步静态代码块
}
}
注意:
对象如同锁，持有锁的线程可以在同步中执行
没持有锁的线程即使获取CPU的执行权，也进不去
同步的前提：
1.必须要有两个或者两个以上的线程
2.必须是多个线程使用同一个锁
优缺点：
好处：解决了多线程的安全问题
弊端：多个线程需要判断锁，较为消耗资源、抢锁的资源。
修饰方法注意点：
synchronized 修饰方法使用锁是当前this锁。
synchronized 修饰静态方法使用锁是当前类的字节码文件
3.4volative 关键字
3.4.1 volatile 的作用
volatile 关键字的作用是变量在多个线程之间可见。并且能够保证所修饰变量的有序性：
1、保证变量的可见性：当一个被 volatile 关键字修饰的变量被一个线程修改的时候，其他线程可以立刻得到修改之后的结果。当一个线程向被 volatile 关键字修饰的变量写入数据的时候，虚拟机会强制它被值刷新到主内存中。当一个线程用到被 volatile 关键字修饰的值的时候，虚拟机会强制要求它从主内存中读取。
2、屏蔽指令重排序：指令重排序是编译器和处理器为了高效对程序进行优化的手段，它只能保证程序执行的结果时正确的，但是无法保证程序的操作顺序与代码顺序一致。这在单线程中不会构成问题，但是在多线程中就会出现问题。非常经典的例子是在单例方法中同时对字段加入 volatile ，就是为了防止指令重排序。
3.4.2 volatile 非原子特性
volatile 关键字增加了实例变量在多个线程之间的可见性，但是不具备原子性。
/**
* volatile 不是具备原子性
*/
public class Test03 {
public static void main(String[] args) {
//在 main 线程中创建 10 个子线程
for (int i = 0; i < 10; i++) {
new MyThread().start();
}
}
static class MyThread extends Thread {
//volatile 关键仅仅是表示所有线程从主内存读取 count 变量的值
public static int count;
/*
这段代码运行后不是线程安全的,想要线程安全,
需要使用 synchronized 进行同步,
如果使用 synchronized 同时,也就不需要 volatile 关键字了
*/
// public static void addCount(){
// for (int i = 0; i < 1000; i++) {
// //count++不是原子操作
// count++;
// }
// System.out.println(Thread.currentThread().getName() + " count=" + count);
// }
public synchronized static void addCount() {
for (int i = 0; i < 1000; i++) {
//count++不是原子操作
count++;
}
System.out.println(Thread.currentThread().getName() + " count=" + count);
}
@Override
public void run() {
addCount();
}
}
}
3.4.3 常用原子类进行自增自减操作
我们知道 i++操作不是原子操作，除了使用 Synchronized 进行同步外，也可以使用 AtomicInteger、AtomicLong 原子类进行实现。
3.5 volatile 与 synchronized 比较
1.volatile 关键字是线程同步的轻量级实现，所以 volatile性能肯定比 synchronized 要好；volatile 只能修饰变量，而 synchronized 可以修饰方法、代码块，随着 JDK 新版本的发布，synchronized 的执行效率也有较大的提升，在开发中使用 sychronized 的比率还是很大的。
2.多线程访问 volatile 变量不会发生阻塞，而 synchronized 可能会阻塞。
3.volatile 能保证数据的可见性，但是不能保证原子性；而synchronized 可以保证原子性，也可以保证可见性。
4.关键字 volatile 解决的是变量在多个线程之间的可见性；synchronized 关键字解决多个线程之间访问公共资源的同步性。