CODEWITHSUNDEEP
javamultithreading
Ahmad 阿德
Ahmad 阿德

Reputation: 155

call more than one methode by current thread

suppose we have these classes and read the comments

class Work {
void doWork(){  }
void commit(){}       
}
class MyRunable implements Runnable {
run(){
   Work  work=new Work();
   work.doWork();
//i can't write work.commit() here, because sometimes i want Thread runs both methods       
 //and sometimes runs only doWork()
 }
}
class Tasks{
main(){
MyRunable myRunable=new MyRunable();
Thread t=new Thread(myRunable);
t.start();
//suppose now i need to call commit() method by the same thread (t)
//how can i do that 
}
}

also i don't want to use constructor to determine if i want to call both method or not

Upvotes: 1

Views: 138

Answers (3)

Peter Lawrey
Peter Lawrey

Reputation: 533880

You could use an anonymous class.

final boolean condition = ...
Thread t = new Thread(new Runnable() {
  public void run() {
    Work work=new Work();
    work.doWork();
    if(condition)
       work.commit();
}});
t.start();

Upvotes: 0

AlexR
AlexR

Reputation: 115398

Add parameter to your class MyRunnable. Call this parameter "runingMode". It could be an enum:

enum RunningMode {
    DO_WORK {
        public void work(Work work) {
             work.doWork();
        }
    },
    COMMIT {
        public void work(Work work) {
             work.commit();
        }
    };
    public abstract void work();
}

Now your class MyRunnable should have list of modes:

class MyRunable implements Runnable {
    private Collection<RunningMode> modes;
    MyRunable(Collection<RunningMode> modes) {
         this.modes = modes;
    }
}

Implement run() method as following:

  Work  work=new Work();
  for (RunningMode mode : modes) {
        mode.work(work);
  }
  work.doWork();

Create instance of your class passing to it the mode you currently need:

MyRunable myRunable=new MyRunable(Arrays.asList(RunningMode.DO_WORK, RunningMode.COMMIT));

Upvotes: 0

Tudor
Tudor

Reputation: 62469

You could try using a thread pool with a single thread and keep enqueuing methods as needed:

class Tasks {
    public static void main(String[] args) {            

        ExecutorService exec = Executors.newSingleThreadExecutor();
        final Work work = new Work();
        exec.submit(new Runnable() {
                public void run() {
                    work.doWork();
                }
            });
        // later
        exec.submit(new Runnable() {
                public void run() {
                    work.commit();
                }
            });

    }
}

This way, both methods will be executed in a sequence by the same thread, but separately.

Upvotes: 1

Related Questions