Java 锁和同步方法之间的区别

我知道同步允许隐式锁，但这些锁不会产生相同的结果吗

以下两段代码之间的区别是什么？为什么程序员会选择使用每一个呢

代码块#1

class PiggyBank {    
    private int balance = 0; 
    public int getBalance() {
        return balance; 
    }
    public synchronized void deposit(int amount) { 
        int newBalance = balance + amount;
        try {
            Thread.sleep(1);
        } catch (InterruptedException ie) {
            System.out.println("IE: " + ie.getMessage());
        }
        balance = newBalance;
    }
}

class PiggyBank {
    private int balance = 0;
    private Lock lock = new ReentrantLock(); 

    public int getBalance() {
        return balance; 
    }
    public void deposit(int amount) { 
        lock.lock();
        try {
            int newBalance = balance + amount; 
            Thread.sleep(1);
            balance = newBalance;
        } catch (InterruptedException ie) { System.out.println("IE: " + ie.getMessage());
        } finally { 
            lock.unlock();
        } 
    }
}

代码块#2

class PiggyBank {    
    private int balance = 0; 
    public int getBalance() {
        return balance; 
    }
    public synchronized void deposit(int amount) { 
        int newBalance = balance + amount;
        try {
            Thread.sleep(1);
        } catch (InterruptedException ie) {
            System.out.println("IE: " + ie.getMessage());
        }
        balance = newBalance;
    }
}

class PiggyBank {
    private int balance = 0;
    private Lock lock = new ReentrantLock(); 

    public int getBalance() {
        return balance; 
    }
    public void deposit(int amount) { 
        lock.lock();
        try {
            int newBalance = balance + amount; 
            Thread.sleep(1);
            balance = newBalance;
        } catch (InterruptedException ie) { System.out.println("IE: " + ie.getMessage());
        } finally { 
            lock.unlock();
        } 
    }
}

---

您提供的两个示例都有相同的用途，并且它们在线程安全方面是相同的（我也希望您保持平衡）。ReentrantLock更“非结构化”，这意味着您可以在一个方法中锁定关键部分，并在另一个方法中解锁它；无法使用synchronized执行某些操作，因为它是块上的结构

---

还有一个性能问题，您希望在同步上使用ReentrantLock，但只有在涉及多个线程时才是这样

是的，这些看起来相当。在这种情况下，大多数程序员会选择选项1，但在需要更多控制的更复杂的上下文中，您可能需要锁。两者都很容易出错，因为对

余额的读取应该是不稳定的或处于锁下。
synchronized
版本会泄漏锁，这是一个糟糕的做法。