Java 执行多线程的另一种方法，而不是使用静态方法和变量

我正在编写一个启动1000个线程的程序，每个线程向一个变量和加1。代码如下：

public class Test1 implements Runnable{
    public Test1( ) {

    }
    public void run() {
        Sum.sum++;
    }
    public static void main(String[] args) {
        //Sum s = new Sum();

        for (int i = 0; i < 1000; i++) {
            Thread t = new Thread(new Test1());
            try {
                t.start();
                t.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }   
        System.out.println(Sum.getSum());
    }
}


public class Sum {
    static int sum;

    public Sum() {
        sum = 0;
    }

    public static int getSum() {
        return sum;
    }

    public static void setSum(int sum) {
        sum = sum;
    }


}

public类Test1实现可运行{
公共测试1（）{
}
公开募捐{
Sum.Sum++；
}
公共静态void main（字符串[]args）{
//Sum s=新的Sum（）；
对于（int i=0；i<1000；i++）{
线程t=新线程（新Test1（））；
试一试{
t、 start（）；
t、 睡眠（1）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}   
System.out.println（Sum.getSum（））；
}
}
公共类金额{
静态整数和；
公帑（）{
总和=0；
}
公共静态int getSum（）{
回报金额；
}
公共静态无效设置总和（整数和）{
总和=总和；
}
}

有没有一种方法可以创建Sum类的实例，然后每个线程向Sum类的同一实例添加1？我的意思是不使用静态方法或变量。

公共类Test1实现Runnable{
public class Test1 implements Runnable{
Sum s = null;
public Test1(Sum s) {
this.s = s;
}
public void run() {
    s.sum++;
    try {
        Thread.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
public static void main(String[] args) {
    Sum s = new Sum();

    for (int i = 0; i < 1000; i++) {
        Thread t = new Thread(new Test1(s));
            t.start();
    }   
    System.out.println(s.getSum());
}
}


class Sum {
int sum;

public Sum() {
    sum = 0;
}

public int getSum() {
    return sum;
}

public void setSum(int sum) {
    sum = sum;
}

总和s=零；
公共测试1（总和s）{
这个.s=s；
}
公开募捐{
s、 sum++；
试一试{
睡眠（1）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
公共静态void main（字符串[]args）{
Sum s=新的Sum（）；
对于（int i=0；i<1000；i++）{
线程t=新线程（新测试1）；
t、 start（）；
}   
System.out.println（s.getSum（））；
}
}
班级总数{
整数和；
公帑（）{
总和=0；
}
公共整数getSum（）{
回报金额；
}
公共无效设置总和（整数和）{
总和=总和；
}

}

重要注意事项：

1-sleep（）是静态的，因此它作用于当前正在运行的线程，因此，如果您想使线程t休眠，正确的方法如下所示

2-System.out.println（s.getSum（））；不保证在所有线程完成后运行。。。。如果要这样做，请使用ExecutorService

---

3-执行synchronized add（）方法，而不是直接访问变量。。。。在这里，这并不重要，但在现实生活中的例子中，您可能会遇到竞争条件

事实上我以前也做过同样的事情，但它不会为每个线程创建一个新的Sum实例吗？或者我搞错了？不，因为所有人都在处理同一个对象的。。。。。。。。如果你说public void run（）{Sum s=new Sum（）；s.Sum++；}，它会在每个线程中创建一个新实例，这个答案是错误的。如果没有你提到的同步，行为是不可预测的。我只是做了最小的更改来满足需要，但肯定。。。。同步应该像我提到的那样使用。。。但是由于逻辑“here”非常简单，没有并发读写，甚至没有处理，只有单个变量的简单增量。。。。我无法想象你将

s

声明为局部变量的不可预测结果的逻辑。它超出了

运行

的范围。2） 如果您想让它成为一个实例字段，那么您没有回答要求所有线程共享一个

和的问题。3） 如果您让所有线程共享一个
Sum
，那么如果没有同步，一切都会失败。