Java并发性——这是有效的吗？

} }

---

所以基本上，我试着运行一个程序，其中运行的线程由变量runType决定。如果runType是一个值，则某个线程将运行，如果它是另一个，则另一个线程将运行。我的方法是最有效的吗？结果会出现错误吗？

您的代码中有几个错误。为了让您知道，您编写的代码根本不会产生新线程。需要注意的是：

sleep（）是一个静态方法。以下代码具有误导性：

System.out.println("Enter the number of what you would like to do");
System.out.println("1 = Manually enter Options");
System.out.println("2 = Use a text file to pick from pre-existing models");
System.out.println("3 = Exit ");


Scanner sc  = new Scanner(System.in);
try {
    runType = sc.nextInt();
    if(runType > 3) {
        throw new badValue(999, "Not the valid input");
    }
} catch (NullPointerException e) {
} catch (badValue e) {
    e.correctBadValue(runType);
} 

switch (runType) {
case 1:
    Thread a = new SelectCarOption();
    a.run();
case 2: 
    Thread a2 = new BuildCarModelOptions();
    a2.run();
case 3:
    System.exit(1); 

}

您已经在主线程中启动了thread1，然后使用新创建的线程调用了sleep方法。但这帮不了你。它使主线程睡眠而不是线程1。要使thread1休眠，需要在此thread1类的run（）中调用sleep方法。
此外，sleep（）是一个静态方法，不应使用线程实例调用，这会产生误导。

停止一个线程并不一定意味着它将调用另一个线程。只要记住，在线程方面，保证的很少。

还有一件事：

try {
  thread1.sleep(5000); //stops thread1 to run different thread 
} catch (InterruptedException e1) {
  e1.printStackTrace();
}

使用

thread1.start（）

---

直接调用run（）方法不会启动新线程。您需要调用start（）方法来启动新线程。直接调用run方法将在同一线程中执行run方法的内容（从调用它的位置）

总体而言，您的代码比较混乱。我建议，如果你还没有。如果你读过，就复习一下。也许自己做一些，然后回到这个问题上来

你说：

如果runType是一个值，则某个线程将运行，如果它是另一个，则另一个线程将运行

要做到这一点，你需要这样的东西

thread1.run(); // This is incorrect

---

长话短说，不，这不是你想做的事情

thread1.run（）

不会启动新线程，它只是在当前线程上调用

run（）

中的代码。您需要的是

thread1.start（）

thread1.sleep（5000）

不会使

thread1

睡眠，它会使主线程睡眠

Thread.sleep

是一种影响当前线程的静态方法，您使用实例变量来调用它（而不是更传统的

Thread.sleep（5000）

）的事实不会改变这一点

启动

thread2

然后立即加入它是没有意义的。您也可以直接在主线程上调用其代码。（这就是您现在正在做的，因为您正在调用

thread2.run（）

，而不是

thread2.start（）

）

我不确定你的最终目标是什么，但这听起来像是一个普通的多态性的例子。创建一个

Runnable

，并根据输入将其分配给两个具体实现之一；然后对其调用

run（）

。比如：

    if (runType == 2) {
        Thread thread1 = new SelectCarOption();
        thread1.run();
        try {
            //join blocks until thread 1 terminates. We don't know that it
            //ever will give your code
            thread1.join(); //stops thread1 to run different thread 
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        Thread thread2 = new CarModelOptionsIO();
        thread2.run();
        try {
            //blocks again, until thread 2 is done running.
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    } else {

        try {
            thread1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //start some other thread here since runType is different?
    }

如果您需要此操作的结果，您可以使用（不要让包名称迷惑您；该接口中没有并发固有的内容）或者甚至创建自己的接口，这样您就可以为方法提供更有意义的名称（

call

和

run

非常通用）

一个程序员遇到了一个问题。他心想，“我知道，我会用线程解决它的！”。现在有问题了。两个他

A）

你可以替换

Runnable selectStrategy = (runType == 2)
    ? new CarModelOptionsIO()
    : new SelectCarOption()

selectStrategy.run()

通过直接执行

run

所做的任何操作，因为启动线程的线程只是等待

    Thread thread1 = new SelectCarOption();
    thread1.start();
    thread1.join();

现在，我们可以将您的代码简化为：

   run()

你有一个更有效的方法

B）

---

不要在线程上调用

run（）

方法。直接调用的每个方法都在当前线程中就地执行

Thread

具有您调用的

start（）

方法，该方法然后从该新线程中调用

run（）

。

类中有许多错误。首先，您使用的是run（）方法，而不是start（）。第二，你应该启动两个线程，让你的sleep（）有意义。这是一个关于OracleJavaSE的在线教程，了解Java多线程模型的基础知识，这将有很大帮助

为什么要启动thread1，然后在发现它不是正确的线程时停止它？只需启动需要运行的线程。另外，您确定需要线程吗？

睡眠（

顾名思义是浪费时间。顺便说一句，您做错了。

.start（）

启动线程。不要调用

run（）

或者没有线程，

run

在任何线程中执行到位。即使存在此类问题，也应该使用锁，线程获取锁将运行，其他线程将等待。代码似乎很难实际并发执行，因此出现的问题是您是否真的需要并发代码和线程？如前所述，您可以用直接调用2个方法来替换代码，这将更加清晰。谢谢您，我很欣赏这个清晰的答案。我决定采用您的方法。您仍在使用

线程。运行
。这不会启动新线程。这只是一个普通的、普通的、标准的方法调用。而且，您真的应该不要抓住NPE而忽略它。
   run()

   if (runType == 2) {
       doCarModelOptionsIO();
   } else {
       doSelectCarOption()
   }