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

港控/mmm° 2023-10-11 22:23 18阅读 0赞

## 系列文章目录 ##

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

![在这里插入图片描述][c4a10b8eea164c2195103ea3819a3f81.png]

--------------------

#### 文章目录 ####

*  系列文章目录
 *  前言
 *  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、线程安全问题三方面 ###

*  原子性  
    一个线程对数据的操作对于其他的线程来说是原子的，要么操作完成,要么什么也没做;当一个线程在操作数据时,不允许其他的线程参与.
 *  可见性  
    线程对共享数据的访问是否对其他的线程可见
 *  有序性  
    指令重排序与内存重排序指令重排序是指CPU执行指令的顺序与程序的顺序可能不一样; 内存重排序是指内存访问顺序与感知顺序可能不一样。

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

![在这里插入图片描述][51b391b9f0f64aad8920fb6d33cc2287.png]

*  每个线程都有独立的线程栈，不能相互访问线程栈的内容
 *  所有线程都能访问堆中的数据
 *  多个线程访问同事访问一个对象实例或者静态变量时，会出现安全问题。

#### 1.2.2、内存抽象模型 ####

![在这里插入图片描述][5f22befad1084d19af6fea9d201905c1.png]

*  每个线程都有自己独立的工作内存
 *  线程1无法访问线程2的工作内存
 *  线程在访问共享数据时,会把主内存中的共享变量复制到自己的工作内存中，线程操作的是工作内存中数据的副本

### 1.3、Java中的锁 ###

**（多线程并发操作同一个数据可能会引发线程安全问题）**  
锁就是把多个线程对数据的并发操作转换为串行操作。  
![在这里插入图片描述][f5909aed0ba04384b5271dfb078cfbed.png]

#### 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();
    
        }
    
    }

![在这里插入图片描述][61e42a8963da49c3ada83c897fe67f35.png]

\*\*代码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();
    
        }
    
    }

![在这里插入图片描述][379adb6531a84691a3836c1169d984cb.png]

**死锁的例子**  
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();
        }
    }

![在这里插入图片描述][dd691b02d11b42b3b6e4953c013c1988.png]

##### 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

[_-Redisson]: https://blog.csdn.net/s445320/article/details/131132334
[CAS]: https://blog.csdn.net/s445320/article/details/130951405
[Java]: https://blog.csdn.net/s445320/article/details/130930596
[Java 1]: https://blog.csdn.net/s445320/article/details/130928675
[CountDownLatch_Semaphone]: https://blog.csdn.net/s445320/article/details/130555328
[Java 2]: https://blog.csdn.net/s445320/article/details/130520734
[c4a10b8eea164c2195103ea3819a3f81.png]: https://img-blog.csdnimg.cn/c4a10b8eea164c2195103ea3819a3f81.png
[51b391b9f0f64aad8920fb6d33cc2287.png]: https://img-blog.csdnimg.cn/51b391b9f0f64aad8920fb6d33cc2287.png
[5f22befad1084d19af6fea9d201905c1.png]: https://img-blog.csdnimg.cn/5f22befad1084d19af6fea9d201905c1.png
[f5909aed0ba04384b5271dfb078cfbed.png]: https://img-blog.csdnimg.cn/f5909aed0ba04384b5271dfb078cfbed.png
[61e42a8963da49c3ada83c897fe67f35.png]: https://img-blog.csdnimg.cn/61e42a8963da49c3ada83c897fe67f35.png
[379adb6531a84691a3836c1169d984cb.png]: https://img-blog.csdnimg.cn/379adb6531a84691a3836c1169d984cb.png
[dd691b02d11b42b3b6e4953c013c1988.png]: https://img-blog.csdnimg.cn/dd691b02d11b42b3b6e4953c013c1988.png