1

我有一部分代码处理线程，我想详细了解它的功能。在我的示例中，该run方法为空，但假设它对全局变量有一些操作：

import java.io.File;

public class DigestThread extends Thread {
   private File input;

   public DigestThread(File input) {
      this.input = input;
   }

   public void run() {
   }

   public static void main(String[] args) {
      for (int i = 0; i < args.length; i++) {
         File f = new File(args[i]);
         Thread t = new DigestThread(f);
         t.start();
      }
   }
}

创建线程并启动它后，它会等待完成 run 方法中的任务，然后再创建/运行另一个线程吗？

第二个问题

如果变量已在run方法中声明，这意味着它将被声明多次，因为创建的每个线程都会在run方法中执行任务，是否每个线程都处理自己的变量，尽管每个线程中的变量是相同的？

4

4 回答 4

5

它会等待完成 run 方法中的任务来创建另一个方法吗？

不，这就是Multithreading. 每个线程都有自己的执行堆栈。因此，当您启动一个线程时，它会进入run()方法，并在不同的堆栈中执行它，同时main线程继续执行，在它自己的堆栈中。

之后，main线程可以产生另一个线程。因此，所有线程同时运行，但当然，一次一个，根据所使用的特定 CPU 分配算法在它们之间共享 CPU。

多线程的执行过程，这里不可能一一写下。我宁愿建议阅读一些教程或搜索一些在线资源，关于Multithreading. 一旦概念清晰，继续实施Java。

以下是您可以开始使用的一些教程链接：-

于 2013-01-18T20:42:37.110 回答
2

一旦你启动了一个线程，它将在一个单独的线程中运行并且 main() 线程将继续（它可能在子线程结束之前结束）。

如果您希望线程在 main 之前完成，那么您可以使用线程上的Thread.join方法来等待它。

于 2013-01-18T20:42:26.670 回答
2

首先，线程是程序中的单一顺序控制流。我们可以在一个程序中执行多个线程，但是有一个生命周期，您可以在其中了解线程是如何工作的......在此处输入图像描述

每当我们调用start()Thread 的方法时，它会自动调用被覆盖的方法public void run()并执行该run()方法的代码......

这是一个简单的 Java 线程示例，带有 ABC 和 XYZ 线程类

/* Write a program to print having two Thread Class 1) ABC with 1 second  2) XYZ 2 second. 10 times with Extend Constructor */
class ABCThreadConstructor extends Thread {
    ABCThreadConstructor(String name) {
        super(name);
    }
    public void run() {
        try {
            for(int i = 0; i < 10; i++) {
                System.out.println("ABC");
                Thread.sleep(1000);
            }
        } catch(InterruptedException ie) {
            System.out.println("Interrupted Exception : "+ie);
        }
    }
}

class XYZThreadConstructor extends Thread {
    XYZThreadConstructor(String name) {
        super(name);
    }
    public void run() {
        try{
            for(int i = 0; i < 10; i++) {
                System.out.println("XYZ");
                Thread.sleep(2000);
            }
        } catch(InterruptedException ie) {
            System.out.println("Interrupted Exception : "+ie);
        }
    }
}

class AbcXyzThreadConstructorDemo {
    public static void main(String args[]) {
        ABCThreadConstructor atc = new ABCThreadConstructor("ABCThreadConstructor");
        System.out.println("Thread Name : " + atc.getName());
        atc.start();
        XYZThreadConstructor xtc = new XYZThreadConstructor("XYZThreadConstructor");
        System.out.println("Thread Name : " + xtc.getName());
        xtc.start();
    }
}
于 2014-02-09T13:19:16.463 回答
1

假设您的问题是“在创建线程并启动它之后，程序会在创建另一个线程之前等待线程完成其运行方法吗？”

如果是这种情况，否程序将不会等待。t.start()启动线程并获得自己的内存块和线程优先级来运行。它将执行其操作，然后相应地存在。您的主线程将args在终止之前启动指定的线程数。

如果您需要应用程序在线程上等待，请使用t.join(). 这样，父线程（运行的线程main）将加入子线程并阻塞，直到其操作完成。在这种情况下，它有点违背了线程的目的，但是您可以将线程 ID 存储为您需要的任何逻辑，然后再加入（）。

于 2013-01-18T20:43:22.257 回答