《微服务实战》 第二十五章 Java多线程安全与锁

系列文章目录

第二十八章 分布式锁框架-Redisson
第二十七章 CAS
第二十六章 Java锁的分类
第二十五章 Java多线程安全与锁
第二章 CountDownLatch和Semaphone的应用
第一章 Java线程池技术应用

---

---

前言

本章节介绍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());
                }
            }
        }
        
    }
}

测试

扫描二维码关注公众号，回复： 15788957 查看本文章

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