Java 多个线程到同一实例的同步方法

当1000个请求（每个Httprequest作为一个线程）到达调用Trust对象的deposit方法的服务器时会发生什么

我已经编写了这样的代码，工作得很好，但是如果存款金额有很长的逻辑，使得其他线程处于等待状态，情况会怎样呢

class Trust {
    private int amount;
    public synchronized void deposit(int amount) {
        this.amount += amount;
        System.out.println(Thread.currentThread().getName() + "; Amount " +this.amount);
    }
}

class DepositAmount implements Runnable {
    Trust obj;
    private int amount;

    DepositAmount(Trust obj, int amount) {
        this.obj = obj;
        this.amount += amount;
    }
    public void run() {
        obj.deposit(amount);
    }
}

public class Bank {//CustomerToTrust {
    public static void main(String args[]) {
        System.out.println("Naga");
        //amt.nextInt(5000)
        Trust obj = new Trust();
        for(int i =0; i< 100 ; i++) {
            Random amt = new Random();
            new Thread(new DepositAmount(obj, 100)).start();
        }
    }
}

类信任{
私人整数金额；
公共同步作废存款（整笔金额）{
此项。金额+=金额；
System.out.println（Thread.currentThread（）.getName（）+“Amount”+this.Amount）；
}
}
类DepositAmount实现Runnable{
信托obj；
私人整数金额；
存款金额（信托对象，整笔金额）{
this.obj=obj；
此项。金额+=金额；
}
公开募捐{
目标存款（金额）；
}
}
公共类银行{//CustomerToTrust{
公共静态void main（字符串参数[]）{
System.out.println（“Naga”）；
//nextInt金额（5000）
信任对象=新信任（）；
对于（int i=0；i<100；i++）{
随机金额=新随机（）；
新线程（新存款金额（obj，100））.start（）；
}
}
}

在存款金额法逻辑较长的情况下， 请告诉我，假设一次有1000个请求将金额存入信托。 剩余的999个线程是否将被阻止，直到第一个线程的除臭量。最后一个线程如何，用户需要等到该时间才能响应。

“剩余的999个线程是否将被阻止，直到第一个线程的除臭量”

是。第一个线程将进入存款方式。 要执行相同操作的任何其他线程都将进入阻塞状态，直到资源变为可用状态。

“剩余的999个线程将被阻塞，直到第一个线程的deopists数量”

是。第一个线程将进入存款方式。 要执行相同操作的任何其他线程都将进入阻塞状态，直到资源变为可用状态。

“剩余的999个线程将被阻塞，直到第一个线程的deopists数量”

是。第一个线程将进入存款方式。 要执行相同操作的任何其他线程都将进入阻塞状态，直到资源变为可用状态。

“剩余的999个线程将被阻塞，直到第一个线程的deopists数量”

是。第一个线程将进入存款方式。

---

任何其他想要执行相同操作的线程都将进入阻塞状态，直到资源变为空闲状态。

是的，所有其他使用信任同步“存款”方法的线程都必须等待第一个调用方在存款时完成其方法调用。 这对你的共享状态“信任”有点棘手

---

你应该有一个单独的线程…这个线程a.）让其他线程有机会添加“工作请求”（一个同步的方法，它只是把请求放在一个队列中）和一个在这个线程中处理这个队列的方法…这样你就可以将需要等待整个处理完成的过程解耦（因为线程只需要等待请求被放入队列中即可）。

是的，所有其他使用信任同步“存款”方法的线程都必须等待第一个调用方在存款时完成其方法调用。 这对你的共享状态“信任”有点棘手

---

你应该有一个单独的线程…这个线程a.）让其他线程有机会添加“工作请求”（一个同步的方法，它只是把请求放在一个队列中）和一个在这个线程中处理这个队列的方法…这样你就可以将需要等待整个处理完成的过程解耦（因为线程只需要等待请求被放入队列中即可）。

是的，所有其他使用信任同步“存款”方法的线程都必须等待第一个调用方在存款时完成其方法调用。 这对你的共享状态“信任”有点棘手

---

你应该有一个单独的线程…这个线程a.）让其他线程有机会添加“工作请求”（一个同步的方法，它只是把请求放在一个队列中）和一个在这个线程中处理这个队列的方法…这样你就可以将需要等待整个处理完成的过程解耦（因为线程只需要等待请求被放入队列中即可）。

是的，所有其他使用信任同步“存款”方法的线程都必须等待第一个调用方在存款时完成其方法调用。 这对你的共享状态“信任”有点棘手

---

你应该有一个单独的线程…这个线程a.）让其他线程有机会添加“工作请求”（一个同步的方法，它只是把请求放在一个队列中）和一个在这个线程中处理这个队列的方法…这样你就可以将需要等待整个处理完成的过程解耦（因为线程只需等待请求被放入队列即可）。

线程将一次调用一个

deposit（）

。因此，第1000个请求将被阻止，直到其他999个请求完成为止

有两种方法可以提高性能：

使

同步块内执行的操作尽可能快

使用一个

后者可通过以下方式实施：

请注意，尽管此实现在更新帐户方面是正确的，但输出字符串可能会按顺序打印

---

另请参见。

线程将一次调用一个

存款（）

。因此，第1000个请求将被阻止，直到其他999个请求完成

有两种方法可以提高性能：

使

同步块内执行的操作尽可能快

使用一个

后者可通过以下方式实施：

请注意，即使此实现

class Trust {
    private AtomicInteger balance = new AtomicInteger(0);
    public void deposit(int amount) {
        int newBalance = this.balance.addAndGet(amount);
        System.out.println(Thread.currentThread().getName() +
                           "; Balance " + newBalance);
    }
}