我只是 Java 的初学者，偶然发现了多线程应用程序。我知道这个问题与此处的某些帖子类似，但我找不到更好的查询答案。基本上，我想将一个对象传递给一个静态方法，该方法将只返回一个基于对象的值/属性的输出。对于每次调用，我都会创建一个对象的新实例，并且我不可能以任何方式修改方法内部的对象。现在，我的问题是，JVM 是否会为多个线程的每次调用创建静态方法的新实例及其局部变量到堆栈中(不包括将在堆上的对象)？为了清楚地了解我想要实现的目标，这是我的代码:

TestConcurrent.java

import classes.Player;

public class TestConcurrent
{
    private static int method(Player player)
    {
        int y = (player.getPoints() * 10) + 1;

            try {
                    Thread.sleep(1000);
            } catch (InterruptedException e) {}

            return ++y;
    }

    public static void main(String[] args) throws Exception
    {
        // Create 100 threads
        for(int i=1;i<=100;i++)
        {
            final int j = i;
            // Create a new Thread
            new Thread()
            {
                public void run()
                {
                    // Create a new instance of the Player class
                    Player player = new Player(j,j,"FirstName" + j, "LastName" + j);
                    // Call static method() and pass a new instance of Player class
                    System.out.println("Thread " + j + ": " + TestConcurrent.method(player));
                    // Check the values of the Player class after the call to the static method()
                    System.out.println("Player" + player.getAcctId() + " : Points=" + player.getPoints() + " Name=" + player.getFirstName() + " " + player.getLastName());
                }
            }.start();
        }
    }

}

Player.java

package classes;

public class Player
{
    private int acctId, points;
    String firstName, lastName;

    public Player(int acctId, int points, String firstName, String lastName)
    {
        this.acctId = acctId;
        this.points = points;
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public int getAcctId() {
        return acctId;
    }
    public void setAcctId(int acctId) {
        this.acctId = acctId;
    }
    public int getPoints() {
        return points;
    }
    public void setPoints(int points) {
        this.points = points;
    }
    public String getFirstName() {
        return firstName;
    }
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
}

输出:

因为我没有放synchronized关键字，所以每次输出都会不一样，看起来类似于下面这样:(输出是正确的，这正是我所期待的，我只是想澄清一下，我在正确的路径，因为我不想使用同步，因为它会减慢进程，因为每个线程都必须等待另一个线程完成才能调用静态方法)

Thread 2: 22
Player8 : Points=8 Name=FirstName8 LastName8
Thread 22: 222
Thread 26: 262
Thread 23: 232
Player23 : Points=23 Name=FirstName23 LastName23
Thread 21: 212
Player21 : Points=21 Name=FirstName21 LastName21
Thread 25: 252
Player25 : Points=25 Name=FirstName25 LastName25
Thread 20: 202
Thread 19: 192
Thread 24: 242
Player24 : Points=24 Name=FirstName24 LastName24
Player9 : Points=9 Name=FirstName9 LastName9
Thread 28: 282

最佳答案

will JVM create a new instance of the static method and its local variables into the Stack (excluding the object as it will be on the Heap) for every call by multiple threads?

是的，完全正确。

如果一个静态方法只引用局部变量，它自动是线程安全的。 (事实上​​，这也适用于非静态方法。)

不过一般来说，我会说你应该尽可能避免 static。一般来说，由于静态成员在某种意义上是全局的，因此它使代码更难测试和推理。

关于java - 多个线程将对象引用传递给静态辅助方法，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/10647683/