设计一个模拟用户从银行取款的应用程序。设某银行账户存款额的初值是2000元，用线程同步的方法模拟两个用户分别从银行取款的情况。两个用户分4次从银行的同一账户取款，每次取100元。

设计一个模拟用户从银行取款的应用程序，我们可以使用Java的synchronized关键字和Thread类来实现线程同步。首先，我们需要创建一个BankAccount类，包含账户余额和一个临界区（使用synchronized）来保护对余额的操作：

public class BankAccount {
    private int balance = 2000;
    private Object lock = new Object();

    public synchronized void deposit(int amount) {
        balance += amount;
    }

    public synchronized boolean withdraw(int amount) {
        if (balance >= amount) {
            balance -= amount;
            return true; // 取款成功
        } else {
            return false; // 取款失败，余额不足
        }
    }

    // 其他方法...
}

接着，我们创建User类，每个User代表一个线程，负责取款操作：

public class User implements Runnable {
    private BankAccount account;
    private int id;

    public User(BankAccount account, int id) {
        this.account = account;
        this.id = id;
    }

    @Override
    public void run() {
        for (int i = 0; i < 4; i++) {
            int withdrawalAmount = 100;
            try {
                Thread.sleep(500); // 模拟用户等待时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("User " + id + ", Attempt " + (i+1) + ": Withdrawal result - " + account.withdraw(withdrawalAmount));
        }
    }
}

// 主函数
public static void main(String[] args) {
    BankAccount bank = new BankAccount();
    User user1 = new User(bank, 1);
    User user2 = new User(bank, 2);

    Thread thread1 = new Thread(user1);
    Thread thread2 = new Thread(user2);
    
    thread1.start();
    thread2.start();

    // 等待所有线程结束
    try {
        thread1.join();
        thread2.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

在这个例子中，通过`lock`对象，当一个线程进入`withdraw`方法时，其他线程会被阻塞，直到第一个线程完成。这样可以保证取款操作的原子性和一致性。