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

2023-06-19 255

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： 《微服务实战》第二十五章 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());
                }
            }
        }
    }
}

测试

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

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

前言

1、Java多线程安全与锁

1.1、多线程安全问题

1.2、线程安全问题三方面

1.2.1、共享数据在jvm中的表现

1.2.2、内存抽象模型

1.3、Java中的锁

1.3.1、同一个JVM内锁

1.3.1.1、synchronized 关键字

1.3.1.2、volatile关键字

1.3.1.3、volatile和synchronized区别

1.3.1.4、volatile能替代synchronized吗

热门文章

最新文章

相关课程

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

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

前言

1、Java多线程安全与锁

1.1、多线程安全问题

1.2、线程安全问题三方面

1.2.1、共享数据在jvm中的表现

1.2.2、内存抽象模型

1.3、Java中的锁

1.3.1、同一个JVM内锁

1.3.1.1、synchronized 关键字

1.3.1.2、volatile关键字

1.3.1.3、volatile和synchronized区别

1.3.1.4、volatile能替代synchronized吗

热门文章

最新文章

相关课程

相关电子书

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