7

我只是 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();
        }
    }

}

播放器.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;
    }
}

输出：

由于我没有输入同步关键字，因此每次输出都会有所不同，看起来类似于以下内容：（输出正确，这正是我所期望的，我只是想澄清一下我在正确的道路上因为我不想使用同步，因为它会减慢进程，因为每个线程必须等待另一个线程完成才能调用静态方法）

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
4

2 回答 2

4

JVM会为多个线程的每次调用创建一个静态方法的新实例及其局部变量到堆栈中（不包括将在堆上的对象）？

是的，完全正确。

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

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

于 2012-05-18T06:23:47.507 回答
4

static方法不是问题，只有static变量会跨线程共享。

所以两个线程调用

public static int sum(int a, int b) {
  int tmp = a + b;
  return tmp;
}

不会遇到问题。

static int tmp;

public static int sum(int a, int b) {
  tmp = a + b;
  return tmp;
}

多线程会失败，因为一个线程可能会覆盖另一个tmp值。

局部变量，即使在static方法中，仍然是局部的，因此是安全的。

使用static方法是好的。它强调该方法不需要访问对象变量。使用static非常量变量容易出错，不惜一切代价避免这种情况（如果需要访问变量，请在常量上使用同步）。

于 2012-05-18T06:25:41.767 回答