【Java 基础】Java 线程的安全性

小灰灰 2024-05-04 08:04 63阅读 0赞

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

> ?**博主介绍**： 博主从事应用安全和大数据领域，有8年研发经验，5年面试官经验，Java技术专家，WEB架构师，阿里云专家博主，华为云云享专家，51CTO 专家博主

⛪️ 个人社区：[个人社区][Link 1]  
? 个人主页：[个人主页][Link 2]  
? 专栏地址： ✅ [Java 进阶之路][Java]  
?八股文专题：[剑指大厂，手撕 Java 八股文][Java 1]

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

*   *   *  一、为什么会有线程安全问题
         *  二、同步代码块
         *  三、同步方法
         *  四、Lock锁

#### 一、为什么会有线程安全问题 ####

Java中存在线程安全问题的原因主要有以下几点：

1.  **多线程共享数据**。当多个线程同时访问同一个数据时，如果没有采取适当的措施来保护数据，就会出现线程安全问题。
2.  **竞态条件**。当多个线程在执行某个操作时，它们的执行顺序会影响最终的结果，从而导致线程安全问题。
3.  **缺乏同步控制**。如果多个线程同时执行某个操作，而没有采取适当的同步控制，就会出现线程安全问题。
4.  **死锁**。当多个线程互相等待对方释放锁时，就会出现死锁问题，导致线程无法继续执行。

为了解决线程安全问题，Java提供了多种同步机制，如synchronized关键字、Lock接口、volatile关键字等。开发人员可以根据具体的情况选择适合的同步机制来保证线程安全。

#### 二、同步代码块 ####

Java中的同步代码块是一种用于保护共享资源的机制。同步代码块使用synchronized关键字来标识，只有一个线程可以进入同步代码块执行，其他线程需要等待该线程执行完毕后才能进入。

同步代码块的语法如下：

synchronized (锁对象) {
        
        // 需要同步的代码块
    }

在同步代码块中，锁对象可以是任意对象，但是多个线程访问同一个同步代码块时，必须使用相同的锁对象。

当一个线程进入同步代码块时，它会尝试获取锁对象的锁，如果锁对象的锁已经被其他线程获取，则该线程会进入阻塞状态，直到锁被释放。只有获取到锁的线程才能执行同步代码块中的代码，其他线程需要等待。

同步代码块的作用是确保多个线程对共享资源的访问是有序的，避免出现竞态条件和线程安全问题。通过合理地使用同步代码块，可以有效地保护共享资源的完整性和一致性。

下面是一个使用同步代码块的实际案例：

public class BankAccount {
        
        private double balance;
        
        public BankAccount(double initialBalance) {
        
            this.balance = initialBalance;
        }
        
        public void deposit(double amount) {
        
            synchronized (this) {
         // 同步代码块
                balance += amount;
                System.out.println("Deposit successful. New balance: " + balance);
            }
        }
        
        public void withdraw(double amount) {
        
            synchronized (this) {
         // 同步代码块
                if (balance >= amount) {
        
                    balance -= amount;
                    System.out.println("Withdrawal successful. New balance: " + balance);
                } else {
        
                    System.out.println("Insufficient funds. Withdrawal failed.");
                }
            }
        }
    }

在上面的例子中，BankAccount类表示银行账户。deposit方法用于存款，withdraw方法用于取款。为了保证对balance变量的访问是线程安全的，我们使用了同步代码块。在deposit和withdraw方法中，使用synchronized关键字标识同步代码块，并传入this作为锁对象。这样，在同一时刻只有一个线程可以执行deposit或withdraw方法，其他线程需要等待。这样可以避免多个线程同时修改balance导致的竞态条件和数据不一致性问题。

以下是一个使用BankAccount类的示例：

public class Main {
        
        public static void main(String[] args) {
        
            BankAccount account = new BankAccount(1000.0);
            Thread depositThread = new Thread(() -> {
        
                for (int i = 0; i < 5; i++) {
        
                    account.deposit(100.0);
                }
            });
            Thread withdrawThread = new Thread(() -> {
        
                for (int i = 0; i < 5; i++) {
        
                    account.withdraw(200.0);
                }
            });
            depositThread.start();
            withdrawThread.start();
        }
    }

在上面的例子中，我们创建了一个BankAccount对象，并创建了两个线程分别执行存款和取款操作。由于存款和取款方法使用了同步代码块，所以在同一时刻只有一个线程可以执行这些方法。这样可以确保对balance的访问是有序的，避免了多线程并发修改balance导致的问题。

注意：这只是一个简单的示例，实际应用中可能需要更复杂的同步机制来保护共享资源的完整性和一致性。

#### 三、同步方法 ####

Java中的同步方法是一种简化了同步代码块的方式，它使用synchronized关键字修饰方法，从而实现对方法的同步访问。

下面是一个使用同步方法的实际案例：

public class BankAccount {
        
        private double balance;
        public BankAccount(double initialBalance) {
        
            this.balance = initialBalance;
        }
        
        public synchronized void deposit(double amount) {
        
            balance += amount;
            System.out.println("Deposit successful. New balance: " + balance);
        }
        
        public synchronized void withdraw(double amount) {
        
            if (balance >= amount) {
        
                balance -= amount;
                System.out.println("Withdrawal successful. New balance: " + balance);
            } else {
        
                System.out.println("Insufficient funds. Withdrawal failed.");
            }
        }
    }

在上面的例子中，BankAccount类表示银行账户。deposit方法用于存款，withdraw方法用于取款。为了保证对balance变量的访问是线程安全的，我们使用了synchronized关键字修饰这两个方法。这样，在同一时刻只有一个线程可以执行deposit或withdraw方法，其他线程需要等待。这样可以避免多个线程同时修改balance导致的竞态条件和数据不一致性问题。

以下是一个使用BankAccount类的示例：

public class Main {
        
        public static void main(String[] args) {
        
            BankAccount account = new BankAccount(1000.0);
            Thread depositThread = new Thread(() -> {
        
                for (int i = 0; i < 5; i++) {
        
                    account.deposit(100.0);
                }
            });
            
            Thread withdrawThread = new Thread(() -> {
        
                for (int i = 0; i < 5; i++) {
        
                    account.withdraw(200.0);
                }
            });
            depositThread.start();
            withdrawThread.start();
        }
    }

在上面的例子中，我们创建了一个BankAccount对象，并创建了两个线程分别执行存款和取款操作。由于deposit和withdraw方法都是同步方法，所以在同一时刻只有一个线程可以执行这些方法。这样可以确保对balance的访问是有序的，避免了多线程并发修改balance导致的问题。  
需要注意的是，同步方法是以对象为单位进行同步的，即每个对象的同步方法是互斥的，不同对象的同步方法是并行的。如果多个线程同时访问同一个对象的同步方法，它们会按照顺序依次执行。

#### 四、Lock锁 ####

Java中的Lock锁是一种更加灵活和可控的同步机制，它可以替代synchronized关键字来实现线程的同步访问。Lock锁提供了更多的功能和特性，比如可重入性、公平性和超时等待。

下面是一个使用Lock锁的实际案例：

import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class BankAccount {
        
        private double balance;
        private Lock lock;
        
        public BankAccount(double initialBalance) {
        
            this.balance = initialBalance;
            this.lock = new ReentrantLock();
        }
        
        public void deposit(double amount) {
        
            lock.lock();
            try {
        
                balance += amount;
                System.out.println("Deposit successful. New balance: " + balance);
            } finally {
        
                lock.unlock();
            }
        }
        
        public void withdraw(double amount) {
        
            lock.lock();
            try {
        
                if (balance >= amount) {
        
                    balance -= amount;
                    System.out.println("Withdrawal successful. New balance: " + balance);
                } else {
        
                    System.out.println("Insufficient funds. Withdrawal failed.");
                }
            } finally {
        
                lock.unlock();
            }
        }
    }

在上面的例子中，BankAccount类使用了Lock锁来实现对balance变量的同步访问。我们使用ReentrantLock类来创建一个Lock对象，并在deposit和withdraw方法中使用lock()方法获取锁，使用unlock()方法释放锁。通过这种方式，我们可以控制对balance的访问，确保同一时刻只有一个线程可以执行deposit或withdraw方法。

以下是一个使用BankAccount类的示例：

public class Main {
        
        public static void main(String[] args) {
        
            BankAccount account = new BankAccount(1000.0);
             Thread depositThread = new Thread(() -> {
        
                for (int i = 0; i < 5; i++) {
        
                    account.deposit(100.0);
                }
            });
            
            Thread withdrawThread = new Thread(() -> {
        
                for (int i = 0; i < 5; i++) {
        
                    account.withdraw(200.0);
                }
            });
            
            depositThread.start();
            withdrawThread.start();
        }
    }

在上面的例子中，我们创建了一个BankAccount对象，并创建了两个线程分别执行存款和取款操作。由于使用了Lock锁来实现对balance的同步访问，所以在同一时刻只有一个线程可以执行deposit或withdraw方法。这样可以确保对balance的访问是有序的，避免了多线程并发修改balance导致的问题。

需要注意的是，与synchronized关键字不同，Lock锁需要手动获取和释放，因此在使用Lock锁时需要确保在finally块中释放锁，以免发生死锁的情况。此外，Lock锁还提供了更多的特性，比如可重入性（一个线程可以多次获取同一个锁）、公平性（按照线程的请求顺序获取锁）和超时等待（尝试获取锁的时候可以设置最长等待时间）。这使得Lock锁在一些特殊的场景下更加灵活和可控。

>  精彩专栏推荐订阅：在下方专栏??  
>  ✅ [2023年华为OD机试真题（A卷&B卷）+ 面试指导 ][2023_OD_A_B_ _]  
>  ✅ [ 精选100套 Java 项目案例 ][_100_ Java _]  
>  ✅ [面试需要避开的坑（活动）][Link 3]  
>  ✅ [你找不到的核心代码][Link 4]  
>  ✅ [带你手撕 Spring][Spring]

> ?? 本文由激流原创，原创不易，希望大家关注、点赞、收藏，给博主一点鼓励，感谢！！！

![在这里插入图片描述][7b7478e55aa24a948b358051ef941b6a.webp_pic_center]

[6b441bed3e2d4dd8aad12d77f78eeb56.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/04/8f5d063afeac44f48047f0358a47c68a.png
[Link 1]: https://bbs.csdn.net/forums/45c04d3f41cc4dadaf312be1d1379b45?category=10003
[Link 2]: https://jiliu.blog.csdn.net/
[Java]: https://blog.csdn.net/qq_37967783/category_9902143.html
[Java 1]: https://blog.csdn.net/qq_37967783/article/details/130940512
[2023_OD_A_B_ _]: https://blog.csdn.net/qq_37967783/category_12389634.html
[_100_ Java _]: https://blog.csdn.net/qq_37967783/category_12388267.html
[Link 3]: https://blog.csdn.net/qq_37967783/category_12380337.html
[Link 4]: https://blog.csdn.net/qq_37967783/category_12391346.html
[Spring]: https://blog.csdn.net/qq_37967783/category_12391987.html
[7b7478e55aa24a948b358051ef941b6a.webp_pic_center]: https://img-blog.csdnimg.cn/7b7478e55aa24a948b358051ef941b6a.webp#pic_center