java如何重载run（）方法

Question

我有这样的代码，如何让两个run（）方法与start（）方法在不同的线程中运行？

 public class Test extends Thread{
   @override
   public void run(){
        //do something

   }
   public void run(int i){
        //do something

   }

  public static void main(String[] args) {
     Test test=new Test();
     // test.start()
     // How Can I let the two run() methods run in different thread?

 }

}

Answer 1

您需要两个单独的线程，并且只需要实现Runnable 。 扩展线程意味着您想要更改Thread行为中的某些内容，而无需更改。

每个线程都会做其他事情，所以有两个Runnable实现， Task1和Task2 ：

class Task1 implements Runnable (){
    public run(){
        System.out.println("Runnable 1");
    }
}

class Task2 implements Runnable (){
    public run(){
        System.out.println("Runnable 2");
    }
}

// create two threads, one for each task
Thread t1 = new Thread(new Task1());
Thread t2 = new Thread(new Task2());

// start the threads (should print the two messages)
t1.start();
t2.start();

要为不同的Runnable实现使用不同的参数，请使用如下构造函数：

class ParamTask implements Runnable (){
    String someArg;
    public ParamTask(String someArg){
        this.someArg = someArg;
    }    

    public run(){
        System.out.println("Runnable argument was: " + this.someArg);
    }
}

Thread argThread = new Thread(new ParamTask("this is a message"));

argThread.start();

Answer 2

请记住，您可以随意在Thread子类中重载run（）方法。

public class FirstThread extends Thread{

    public static void main(String[] args) {
        FirstThread ft1= new FirstThread();
        ft1.start(); // Seperate call stack
        ft1.run("With parameter"); // same call stack
    }
    public void run(){
        System.out.println("Thread is running");
    }
    public void run(String s){
        System.out.println("Overloaded Thread is running " +s );
    }
}

除非您自己调用，否则Thread类将忽略重载的run（String s）方法。 Thread类需要一个不带参数的run（）方法，并且在线程启动后，它将在单独的调用堆栈中为您执行此方法。 使用run（String s）方法，Thread类不会为您调用该方法，即使您自己直接调用该方法，也不会在具有单独调用堆栈的新执行线程中执行该操作。 它将与您进行调用的代码在同一调用堆栈中发生，就像其他常规方法调用一样。

来源：SCJP 1.6 Kathy Siera（第9章：线程，部分：定义线程）

现在，根据您的需求，使用两个类实现Runnable接口，并在单独的调用堆栈上调用2个线程。 使用任何一个线程调用run（String）方法，它将在不同的调用堆栈上执行您的方法。

public class SeacondThreadRunnable {

public static void main(String[] a){

    Thread myThread1= new Thread(new MyRunnable());
    Thread myThread2= new Thread(new MyRunnable2());
    myThread1.start();
    myThread2.start();
 }
}
class MyRunnable implements Runnable{

@Override
public void run() {
    System.out.println("Runnable run method called " +Thread.currentThread().getName());

    run(" Overloaded Thread is running " );  // calling overloaded run method
}
public void run(String s){
    System.out.println( Thread.currentThread().getName() + s);
 } 
}
class MyRunnable2 implements Runnable{

@Override
public void run() {
    System.out.println("Runnable run method called " +Thread.currentThread().getName());
 }
}