Java多线程 - 线程安全和线程同步解决线程安全问题

秒速五厘米 2023-09-23 13:29 86阅读 0赞

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

*   *  线程安全问题
     *  线程同步
     *   *  方式一: 同步代码块
         *  方式二: 同步方法
         *  方式三: Lock锁

### 线程安全问题 ###

> 线程安全问题指的是: 多个线程同时操作同一个共享资源的时候可能会出现业务安全问题，称为线程安全问题。

**举例: 取钱模型演示**

> 需求：小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元。
> 
> 如果小明和小红同时来取钱，而且2人都要取钱10万元，可能出现什么问题呢？

![在这里插入图片描述][34e610cd28f44667947249b761b114d6.png_pic_center]

> 在取钱之前都需要判断余额是否足够, 例如两个线程同时执行, 两个线程都进行了余额判断, 发现余额充足;
> 
> 此时小明线程取走10万, 账户余额为0; 小红线程由于此时已经判断过余额, 继续取钱的时候就不会继续判断余额, 直接将余额取出来; 那么两个人都取走了10万, 银行就亏了10万, 这就是多线程带来的安全问题

**线程安全问题模拟, 我们将上面的例子用代码模拟出来多线程的安全隐患**:

**需求**:

> 小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元，模拟2人同时去取钱10万。

**分析**:

> 1.  需要提供一个账户类，创建一个账户对象代表2个人的共享账户。
> 2.  需要定义一个线程类，线程类可以处理账户对象。
> 3.  创建2个线程对象，传入同一个账户对象。
> 4.  启动2个线程，去同一个账户对象中取钱10万。

**实现步骤**:

> 模拟一个账户类给小明线程和小红线程, 我们模拟关键信息即可

public class Account {
        
        private double money;
    
        public  Account() {
        }
    
        public Account(double money) {
        
            this.money = money;
        }
    
        /**
            取钱方法
         */
        public void drawMoney(double money) {
        
            // 获取取钱人的名字
            String name = Thread.currentThread().getName();
            if (this.money >= money) {
         // 判断余额是否充足
                System.out.println(name + "取走了" + money + "元");
                this.money -= money;
            } else {
        
                System.out.println("余额不足");
            }
        }
    
        public double getMoney() {
        
            return money;
        }
    
        public void setMoney(double money) {
        
            this.money = money;
        }
    }

> 定义一个线程类用来处理账户对象

public class DrawThread extends Thread {
        
        private Account acc;
    
        public DrawThread(Account acc, String name) {
        
            super(name);
            this.acc = acc;
        }
    
        @Override
        public void run() {
        
            acc.drawMoney(100000);
        }
    }

> 在主类中, 创建2个线程对象，传入同一个账户对象; 启动2个线程，去同一个账户对象中取钱10万

public class ThreadDemo {
        
        public static void main(String[] args) throws Exception {
        
            // 创建账户对象
            Account acc = new Account(100000);
    
            // 创建两个子线程, 并启动线程
            new DrawThread(acc, "小明").start(); // 小明取走了100000.0元
            new DrawThread(acc, "小红").start(); // 小红取走了100000.0元
    
            // 主线程睡眠两秒后, 查看余额
            Thread.sleep(2000);
            System.out.println(acc.getMoney()); // -100000.0
        }
    }

### 线程同步 ###

> 为了解决上面线程安全的问题。

**取钱案例出现问题的原因**？

> 多个线程同时执行，发现账户都是够钱的。

**如何才能保证线程安全呢**？

> 让多个线程实现先后依次排队访问共享资源，这样就解决了安全问题

**线程同步的核心**:

> **线程同步的核心是加锁**，把共享资源进行上锁，每次只能一个线程进入访问完毕以后解锁，然后其他线程才能进来。
> 
> 加锁的方式有三种方式: 同步代码块, 同步方法和Lock锁, 下面我们来分别学习加锁的方法

#### 方式一: 同步代码块 ####

> 作用：将出现线程安全问题的**核心代码给上锁**。
> 
> 原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行。

**同步代码块上锁的格式**:

synchronized(同步锁对象) {
        
      	// 操作共享资源的代码(核心代码)
    }

**例如我们给上面模拟的线程安全例子中的核心代码进行加锁操作**:

> 进行加锁操作就解决了线程安全问题

public class Account {
        
        private double money;
    
        public  Account() {
        }
    
        public Account(double money) {
        
            this.money = money;
        }
    
        /**
            取钱方法
         */
        public void drawMoney(double money) {
        
            String name = Thread.currentThread().getName();
    
            // 对核心代码进行加锁, 这里锁对象随便使用了一个字符串模拟(无实际代表意义)
            synchronized ("chen") {
        
                if (this.money >= money) {
        
                    System.out.println(name + "取走了" + money + "元");
                    this.money -= money;
                } else {
        
                    System.out.println("余额不足");
                }
            }
        }
    
        public double getMoney() {
        
            return money;
        }
    
        public void setMoney(double money) {
        
            this.money = money;
        }
    }

**锁对象注意**:

> 理论上：锁对象只要对于当前同时执行的线程来说是唯一的一个对象即可。
> 
> 但是实际上使用任意唯一的锁对象并不好, 会影响其他无关线程的执行, 例如上面例子中, 会将其他无关的账户也锁起来。

**锁对象的规范要求**:

> 规范上：建议使用共享资源作为锁对象。
> 
>  *  对于实例方法中, 建议使用this作为锁对象。
> 
>     // 加锁, 使用共享资源作为锁对象
>     synchronized (this) {
>          
>     }
> 
>  *  对于静态方法中, 建议使用字节码（类名.class）对象作为锁对象。
> 
>     // 加锁, 使用共享资源作为锁对象
>     synchronized (类名.class) {
>          
>     }

#### 方式二: 同步方法 ####

> 作用: 将出现线程安全问题的**核心方法给上锁**。
> 
> 原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。

**同步方法的上锁格式**:

修饰符 synchronized 返回值类型 方法名称(形参列表) {
        
    	  // 操作共享资源的代码
    }

**同步方法上锁演示代码**:

// 给核心方法上锁
    public synchronized void drawMoney(double money) {
        
        String name = Thread.currentThread().getName();
    
        if (this.money >= money) {
        
            System.out.println(name + "取走了" + money + "元");
            this.money -= money;
        } else {
        
            System.out.println("余额不足");
        }
    }

**同步方法底层原理**:

> 同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。
> 
> 如果方法是实例方法：同步方法默认用this作为的锁对象。但是代码要高度面向对象！
> 
> 如果方法是静态方法：同步方法默认用类名.class作为的锁对象。

#### 方式三: Lock锁 ####

**Lock锁**

> 为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，更加灵活、方便。
> 
> Lock实现提供比使用synchronized方法和语句可以获得更广泛灵活的锁定操作。
> 
> Lock是接口不能直接实例化，这里采用它的`实现类ReentrantLock`来构建Lock锁对象。

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ReentrantLock()</td> 
   <td>获得Lock锁的实现类对象</td> 
  </tr> 
 </tbody> 
</table>

**Lock的API**:

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>lock()</td> 
   <td>获得锁</td> 
  </tr> 
  <tr> 
   <td>unlock()</td> 
   <td>释放锁</td> 
  </tr> 
 </tbody> 
</table>

**Lock使用演示代码**:

> 基本使用如下, 我们可以看出Lock使用是非常灵活的

public class Account {
        
        private double money;
        // 定义一个示例变量锁对象, 每创建一个类就会创建一个锁对象, 加final修饰, 表示不可替换
        private final Lock lock = new ReentrantLock();
    
        public  Account() {
        }
        public Account(double money) {
        
            this.money = money;
        }
        
        public synchronized void drawMoney(double money) {
        
            String name = Thread.currentThread().getName();
    
            // 调用锁对象上锁
            lock.lock();
            if (this.money >= money) {
        
                System.out.println(name + "取走了" + money + "元");
                this.money -= money;
            } else {
        
                System.out.println("余额不足");
            }
            // 调用锁对象解锁
            lock.unlock();
        }
    
        public double getMoney() {
        
            return money;
        }
    
        public void setMoney(double money) {
        
            this.money = money;
        }
    }

> 但是如果我们上锁和解锁之间的代码出现了异常, 永远都不会执行解锁操作, 所以更严谨的写法是将解锁的操作放到try…finally中, 保证会执行解锁的操作

public synchronized void drawMoney(double money) {
        
        String name = Thread.currentThread().getName();
    
        // 调用锁对象上锁
        try {
        
            lock.lock();
            if (this.money >= money) {
        
                System.out.println(name + "取走了" + money + "元");
                this.money -= money;
            } else {
        
                System.out.println("余额不足");
            }
        } finally {
        
            // 调用锁对象解锁
            lock.unlock();
        }
    }

[34e610cd28f44667947249b761b114d6.png_pic_center]: https://img-blog.csdnimg.cn/34e610cd28f44667947249b761b114d6.png#pic_center