實現可運行的抽象類 - 多線程

Question

我想調用兩個具有不同參數的構造函數，它們依次運行它們各自的線程，但問題是它只允許一個run()方法，是否有我可以在一個方法中運行兩個run()方法類？？或任何其他解決這種情況？

class Threading implements Runnable { 

    Thread t; 
    Thread t1; 
    String name; 

    Threading(String s) { 
     name = s; 
     t = new Thread(this, name); 
     System.out.println("Constructor 1: " + t); 
     t.start(); 
    } 

    public void run() { 
     try { 
      for (int i = 5; i > 0; i--) { 
       System.out.println("Constructor 1: " + i); 
       Thread.sleep(2000); 
      } 
     } catch (Exception e) { 
     } 
     System.out.println("Constructor1 exiting"); 
    } 

    Threading(int a, int b) { 
     t1 = new Thread(this, "java2 Thread"); 
     System.out.println("Constructor 2: " + t1); 
     t1.start(); 
    } 

    public void run() { 
     try { 
      for (int i = 5; i > 0; i++) { 
       System.out.println("Constructor 2: " + i); 
       Thread.sleep(3000); 
      } 
     } catch (Exception e) { 
     } 
     System.out.println("Constructor2 exiting"); 
    } 
} 

MultipleThread

class MultipleThread { 
    public static void main(String[] args) { 
     new Threading("java thread"); // Constructor 1 
     new Threading(1, 2); // Constructor 2 

     try { 
      for (int i = 5; i > 0; i--) { 
       System.out.println("Print: " + i); 
       Thread.sleep(1000); 
      } 
     } catch (Exception e) { 
     } 
     System.out.println("Exit Main"); 
    } 
} 

Answer 1

沒有理由具有相同Threading類來實現你的Runnable。您可以在每個構造函數中以匿名方式實現它們：

Threading(String s) { 
    name=s; 
    t=new Thread(new Runnable() { 
     @Override 
     public void run() { 
      // ... 
     } 
    , name); 
    System.out.println("Constructor 1: "+t); 
    t.start(); 
} 

Answer 2

你可以有第三類叫MyThread其實現Runnable接口，並有一個構造函數的參數，保存其構造函數創建它：

public class MyThread implements Runnable{ 
    private String calledFrom; 
    public MyThread(String calledFrom){ 
     this.calledFrom = calledFrom; 
    } 
    public void run(){ 
     try { 
      for (int i = 5; i > 0; i++) { 
       System.out.println(calledFrom + ": " + i); 
       Thread.sleep(3000); 
      } 
     } catch (Exception e) { 
     } 
     System.out.println(calledFrom+" exiting");    
    } 
} 

然後以不實現Runnable接口的方式更改Threading類。現在，在你的兩個構造，你可以有MyThread類不同參數的不同實例：「構造1」和「構造2」：

class Threading{ 
    ... 
    Threading(String s) { 
     name = s; 
     //t = new Thread(this, name); 
     MyThread mt = new MyThread("Constructor 1"); 
     System.out.println("Constructor 1: " + t); 
     //t.start(); 
     mt.start(); 
    } 

    Threading(int a, int b) { 
     //t1 = new Thread(this, "java2 Thread"); 
     MyThread mt = new MyThread("Constructor 2"); 
     System.out.println("Constructor 2: " + t1); 
     //t1.start(); 
     mt.start(); 
    } 
} 

薪火「構造2」或「構造函數1「到MyThread的構造函數只是一個例子。您可以將一些真實有用的參數傳遞給MyThread，這可以幫助您通過參數的類型或值來分離實現。

例如，你可以在MyThread類兩個邏輯方法：logicMethodA()和logicMethodB()，以及基於所述構造函數的參數（一個或多個）的值，決定要調用哪個一個在run()方法。

希望這會有所幫助。