实现可运行抽象类-多线程

Question

I want to call two constructors with different parameters, which in turn run their individual thread but the issue is it only allows one run() method, is there anyway i can run two run() method in one class?? or any other solution to such situation?

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

There's no reason to implement your Runnable with the same Threading class. You can implement them anonymously within each constructor:

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

You can have a third class called MyThread which implement the Runnable interface and have a constructor with an argument, to save which constructor has created it:

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");            
    }
}

Then change your Threading class in a way not to implement Runnable interface. Now in your both constructors, you can have different instances of MyThread class with different arguments: "Constructor 1" and "Constructor 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();
    }
}

Passing the "Constructor 2" or "Constructor 1" to the MyThread 's constructor is just an example. You can pass some real and useful arguments to MyThread which helps you to separate the implementation by the type or the value of the arguments.

For example you can have two logic method in the MyThread class: logicMethodA() and logicMethodB() , and based on the value of the argument(s) of the constructor, decide to call which one in the run() method.

Hope this would be helpful.