Question

我正在尝试创建5个不同的线程，并尝试在每次将静态变量的计数增加一个时在其run方法中打印静态对象

以下是程序的示例输出

pool-1-thread-1 Static Value before update 19
Thread going to sleep pool-1-thread-1
pool-1-thread-4 Static Value before update 19
Thread going to sleep pool-1-thread-4
pool-1-thread-3 Static Value before update 19
Thread going to sleep pool-1-thread-3
pool-1-thread-2 Static Value before update 19
Thread going to sleep pool-1-thread-2
pool-1-thread-5 Static Value before update 19
Thread going to sleep pool-1-thread-5
Thread coming out of sleep pool-1-thread-3  StaticTest.sInt 19
Thread coming out of sleep pool-1-thread-4  StaticTest.sInt 19
Thread coming out of sleep pool-1-thread-1  StaticTest.sInt 19
Thread coming out of sleep pool-1-thread-5  StaticTest.sInt 19
Thread coming out of sleep pool-1-thread-2  StaticTest.sInt 19

**pool-1-thread-5  OLD value 22 Static Value after update 23**
pool-1-thread-1  OLD value 21 Static Value after update 22
pool-1-thread-4  OLD value 20 Static Value after update 21
pool-1-thread-3  OLD value 19 Static Value after update 20
pool-1-thread-2  OLD value 23 Static Value after update 24

现在我的问题是，因为线程3首先从睡眠中出来，它必须首先被打印，然而它的线程5首先被打印，而且值22也就是静态变量在线程5获得之前增加了三倍抓住它，但为什么我看到一个随机顺序，而我打印增量值给我，它应该按照他们从睡眠中出来的顺序打印，即线程3/4/1/5/2

请注意一下？我错过了为什么线程在睡眠后恢复运行状态时的随机行为

package com.test.concurrency;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class StaticTest {

    public static Integer sInt = new Integer(19);

    public static void main(String[] args) {

        ExecutorService es = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++) {
            es.execute(new StaticTask());
        }

    }

}

class StaticTask implements Runnable {

    public void run() {

        String name = Thread.currentThread().getName();
        System.out.println(name + " Static Value before update "
                + StaticTest.sInt);
        try {
            System.out.println("Thread going to sleep " + name);
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Thread coming out of sleep " + name + "  StaticTest.sInt " + StaticTest.sInt);

        int local = StaticTest.sInt;
        StaticTest.sInt = new Integer(local + 1);

        System.out.println(name + "  OLD value " + local +" Static Value after update "
                + StaticTest.sInt);

    }
}

Answer 1

你没有控制或确定性的方法来知道哪一个会先执行，只是因为你先启动线程并不意味着它会先运行...

你正在循环中执行5个线程，但不保证第一个将首先运行，第二个运行第二个，依此类推......

如果您希望线程以特定顺序运行，则必须执行一些连接或等待/通知逻辑。

Answer 2

Java Language Specification 7中的章节17.4.3-5处理发生在规则之前的操作类型，并且通常可以预期多线程应用程序的执行情况顺序。

一旦阅读了这些章节，您就会发现执行序列的保证相当少。在多线程应用程序中，我们认为自然而且理所当然的通常是无效的。

此外，还有内存模型 - 您可以在不同步的情况下访问变量sInt 。这样，您无法保证不同的线程会注意到对象引用已被更改。您必须在修改变量的对象/线程之间使用公共锁定，以确保它的更改甚至可见。

您可以使用synchronized块和静态对象锁来执行此操作：

// in class:
static Object lock = new Object();


// in run():
synchronized(lock) {
    int local =StaticTest.sInt;
    StaticTest.sInt = new Integer(local + 1);
    System.out.println(name + "  OLD value " + local +" Static Value after update "
        + StaticTest.sInt);
}

这样，synchronized中的印刷品将被正确订购。

Answer 3

您应该阅读Java中的并发性。您永远不应该期望线程以任何特定顺序运行 - 尤其是在没有围绕共享资源同步代码的情况下。可能想要start here。

Answer 4

计划的线程取决于操作系统，这些线程有时间片

Answer 5

从输出中可以清楚地看出thread-3是首先醒来的那个（是的，你是对的）然后增加静态int

pool-1-thread-5  OLD value 22 Static Value after update 23
pool-1-thread-1  OLD value 21 Static Value after update 22
pool-1-thread-4  OLD value 20 Static Value after update 21
pool-1-thread-3  OLD value 19 Static Value after update 20  --> static counter incr. from 19 to 20
pool-1-thread-2  OLD value 23 Static Value after update 24

在上面的打印语句中，从打印的值可以清楚地看出，首先醒来的线程正在增量并打印该值。

不可预测的是打印顺序。

如果您认为较低级别，System.out.print语句 Asynchronous ，那么输出

Answer 6

现在我的问题是，因为线程3首先出现在睡眠状态，所以它必须首先打印，但是它的第5个线程首先被打印，而且它的值也是22

由于有5个线程同时运行，因此执行给定语句集的顺序是不可预测的。即使线程以3/4/1/5/2的顺序出现，也不能保证在执行其余语句时将保留相同的顺序。这就是为什么它被称为Asynchronous执行。

可能发生threads 3, 4, 1执行了语句

int local =StaticTest.sInt;
StaticTest.sInt = new Integer(local + 1);

一个接一个（以任何顺序），然后thread 5有机会一次执行语句：

int local =StaticTest.sInt;
StaticTest.sInt = new Integer(local + 1);
System.out.println(name + "  OLD value " + local +" Static Value after update "
                + StaticTest.sInt);

你已经在控制台上打印了这个：

pool-1-thread-5  OLD value 22 Static Value after update 23

因为StaticTest.sInt可能已将静态变量22的值更新为threads 3, 4, 1。

并且您应该始终使用对共享变量的同步访问，以便一个线程所做的更改对其他人可见，并且对于同步访问，对共享变量的操作是原子的：

public static synchronized Integer incrementSInt() {
    return StaticTest.sInt++;
}

Java线程和输出流打印问题

6 个答案: