前言
本章节介绍Java多线程安全与锁
1、Java多线程安全与锁
1.1、多线程安全问题
当多个线程同时操作同一个数据时，可能会出现数据不一样的情况，这就是线程安全问题。线程安全机制用于保证多个线程访问数据时的一致性.
1.2、线程安全问题三方面
- 原子性
一个线程对数据的操作对于其他的线程来说是原子的，要么操作完成,要么什么也没做;当一个线程在操作数据时,不允许其他的线程参与. - 可见性
线程对共享数据的访问是否对其他的线程可见 - 有序性
指令重排序与内存重排序指令重排序是指CPU执行指令的顺序与程序的顺序可能不一样; 内存重排序是指内存访问顺序与感知顺序可能不一样。
1.2.1、共享数据在jvm中的表现
- 每个线程都有独立的线程栈，不能相互访问线程栈的内容
- 所有线程都能访问堆中的数据
- 多个线程访问同事访问一个对象实例或者静态变量时，会出现安全问题。
1.2.2、内存抽象模型
- 每个线程都有自己独立的工作内存
- 线程1无法访问线程2的工作内存
- 线程在访问共享数据时,会把主内存中的共享变量复制到自己的工作内存中，线程操作的是工作内存中数据的副本
1.3、Java中的锁
（多线程并发操作同一个数据可能会引发线程安全问题）
锁就是把多个线程对数据的并发操作转换为串行操作。
1.3.1、同一个JVM内锁
1.3.1.1、synchronized 关键字
- 同步代码块
- 同步实例方法
- 同步类的静态方法
当线程释放锁时，JMM(java内存模型)会把该线程对应的工作内存中的共享变量刷新到主内存中。当线程获取锁时，JMM会把该线程对应的本地内存置为无效。从而使得被监视器保护的临界区代码必须从主内 存中读取共享变量。
**代码 使用synchronized **
package com.xxxx.reids.thread;
import lombok.AllArgsConstructor;
import lombok.Data;
/***
* @title Account
* @desctption 账户
* @author Kelvin
* @create 2023/5/29 11:43
**/
@Data
@AllArgsConstructor
public class Account {
/**
* 余额
*/
private Integer balance;
}
package com.xxxx.reids.thread;
import lombok.AllArgsConstructor;
import lombok.Data;
/***
* @title Person
* @desctption 人员信息
* @author Kelvin
* @create 2023/5/29 11:44
**/
@Data
@AllArgsConstructor
public class Person {
/**
* 姓名
*/
private String name;
/**
* 取款金额
*/
private Integer drawAccount;
}
package com.hqyj.reids.thread;
import java.util.concurrent.locks.Lock;
/***
* @title Draw
* @desctption 取款
* @author Kelvin
* @create 2023/5/29 11:49
**/
public class Draw implements Runnable{
private Account account;
private Person person;
public Draw(Account account,Person person){
this.account = account;
this.person = person;
}
@Override
public void run() {
synchronized (this.account){
while (true){
//余额
Integer balance = this.account.getBalance();
if(balance < this.person.getDrawAccount()){
//余额不足
System.out.println(this.person.getName() + ",账户余额不足");
break;
}else{
/* try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}*/
//取款，减余额
this.account.setBalance(balance - this.person.getDrawAccount());
System.out.println(this.person.getName() + "取了"+this.person.getDrawAccount()+"钱,账户余额：" + this.account.getBalance());
}
}
}
}
}
测试
package com.xxxx.redis;
import com.xxxx.reids.thread.Account;
import com.xxxx.reids.thread.Draw;
import com.xxxx.reids.thread.Person;
import org.junit.Test;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/***
* @title ThreadLockTest
* @desctption 测试类
* @author Kelvin
* @create 2023/5/29 11:50
**/
public class ThreadLockTest {
@Test
public void lock() {
Lock lock = new ReentrantLock();
Account account = new Account(100);
Person zhangSan = new Person("张三", 20);
Person liSi = new Person("李四", 15);
new Thread(new Draw(account,zhangSan)).start();
new Thread(new Draw(account,liSi)).start();
}
}
**代码2 使用Lock **
package com.hqyj.reids.thread;
import java.util.concurrent.locks.Lock;
/***
* @title Draw
* @desctption 取款
* @author Kelvin
* @create 2023/5/29 11:49
**/
public class Draw implements Runnable{
private Account account;
private Person person;
private Lock lock ;
public Draw(Account account,Person person,Lock lock){
this.account = account;
this.person = person;
this.lock = lock;
}
@Override
public void run() {
lock.lock();
//取款操作
Integer drawAccmount = this.person.getDrawAccount();
Integer balanceInit = this.account.getBalance();
//System.out.print("原始值：" + balanceInit + " | ");
if(balanceInit < drawAccmount){
//余额不足，不给取款
System.out.println("取款余额不足");
//break;
}else{
Integer balance = balanceInit - drawAccmount;
this.account.setBalance(balance);
System.out.println(this.person.getName() + "成功取款：" + drawAccmount + "，账户余额：" + balance);
}
lock.unlock();
}
}
import com.xxxx.reids.thread.Account;
import com.xxxx.reids.thread.Draw;
import com.xxxx.reids.thread.Person;
import org.junit.Test;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/***
* @title ThreadLockTest
* @desctption 测试类
* @author Kelvin
* @create 2023/5/29 11:50
**/
public class ThreadLockTest {
@Test
public void lock() {
Lock lock = new ReentrantLock();
Account account = new Account(110);
Person zhangSan = new Person("张三", 17);
Person liSi = new Person("李四", 12);
new Thread(new Draw(account,zhangSan,lock)).start();
new Thread(new Draw(account,liSi,lock)).start();
new Thread(new Draw(account,zhangSan,lock)).start();
new Thread(new Draw(account,liSi,lock)).start();
new Thread(new Draw(account,zhangSan,lock)).start();
new Thread(new Draw(account,liSi,lock)).start();
new Thread(new Draw(account,zhangSan,lock)).start();
new Thread(new Draw(account,liSi,lock)).start();
}
}
死锁的例子
Java 死锁产生的四个必要条件：
- 互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用
- 不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。
- 请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。
- 循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。
/***
* @title DieLock
* @desctption 死锁案例
* @author Kelvin
* @create 2023/5/29 15:36
**/
import java.util.concurrent.TimeUnit;
public class DieLock {
private static Object object1 = new Object();
private static Object object2 = new Object();
public static void main(String[] args) {
new Thread(){
@Override
public void run() {
synchronized (object1){
System.out.println("Thread1 get object1");
try {
TimeUnit.MILLISECONDS.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (object2){
System.out.println("thread1 get object2");
}
}
}
}.start();
new Thread(){
@Override
public void run() {
synchronized (object2){
System.out.println("Thread2 get object2");
try {
TimeUnit.MILLISECONDS.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (object1){
System.out.println("thread2 get object1");
}
}
}
}.start();
}
}
1.3.1.2、volatile关键字
volatile是java虚拟机提供的轻量级的同步机制
- 保证可见性
- 不保证原子性
- 保证有序性
什么时候去使⽤Volatile？
- 某个属性被多个线程共享，其中有⼀个线程修改了此属性，其他线程可以⽴即得到修改后的值，⽐如作为触发器，状态量标记，实现轻量级同步
- volatile可以在单例双重检查中实现可⻅性和禁⽌指令重排序，可以解决单例双重检查对象初始化代码执⾏乱序问题，从⽽保证安全性。
public class SingletonObject {
private static volatile SingletonObject singletonObject = new SingletonObject();
private SingletonObject(){
}
public static synchronized SingletonObject getInstance(){
if(singletonObject == null){
singletonObject = new SingletonObject();
}
return singletonObject;
}
}
1.3.1.3、volatile和synchronized区别
- volatile只能修饰实例变量和类变量，只能作⽤于属性，⽽synchronized可以修饰⽅法和代码块。
- volatile保证数据的可⻅性，⽤于禁⽌指令重排序，但是不保证原⼦性;⽽synchronized是⼀种互斥的机制。
- volatile属性的读写操作都是⽆锁的，不需要花费时间在获取锁和释放锁上，所以说它是低成本的
- volatile可以看做是轻量版的synchronized，volatile不保证原⼦性，但是如果是对⼀个共享变量进⾏多个线程的赋值，⽽没有其他的操作，那么就可以⽤volatile来代替synchronized，因为赋值本身是有原⼦性的，⽽volatile⼜保证了可⻅性，所以就可以保证线程安全了。
1.3.1.4、volatile能替代synchronized吗
- volatile属性的读写操作都是⽆锁的，
- 它没有提供原⼦性和互斥性，它不能替代synchronized
