How to run the methods of a class on a defined thread(pool)?

Question

I'm writing a family of classes, all using the Camera. Each class has 4 basic methods to init, start, stop or release the camera.

I would like to run these methods in a background thread. But I'm struggling to find an easy way to do that.

The only way I found out is to use a common ExecutorService defined as

ExecutorService backgroundThread = Executors.newSingleThreadExecutor();

Then, I have to wrap the code of each single method around something like this:

public void start(){
    AbstractLight.backgroundThread.execute(new Runnable(){
        public void run(){
            //write "start method" code here
        }
    });
}

I guess there is a smarter way to do that but I don't know any. Has someone a trick to do that ?

Thank you

Answer 1

You could create an abstract parent class that contains the 'async' versions of these methods.

Start off with an abstract parent class, and wrap each of these in their own runnable async version of themselves. Now, whenever you inherit from the abstract parent, each will automatically have their own runnable. You can then put them into an executor or whatever you need from the parent.

public abstract class CameraParent
{
    public abstract void init();
    public abstract void start();
    public abstract void stop();
    public abstract void release();

    public virtual Runnable initAsync()
    {
        Runnable r = new Runnable()
        {
            @Override
            public void Run()
            {
                init();
            }
        }
        return r;
    }

    public virtual Runnable startAsync()
    {
        Runnable r = new Runnable()
        {
            @Override
            public void Run()
            {
                start();
            }
        }
        return r;
    }

    public virtual Runnable stopAsync()
    {
        Runnable r = new Runnable()
        {
            @Override
            public void Run()
            {
                stop();
            }
        }
        return r;
    }

    public virtual Runnable releaseAsync()
    {
        Runnable r = new Runnable()
        {
            @Override
            public void Run()
            {
                release();
            }
        }
        return r;
    }
}

This will give you a good base for the entire family of classes you are writing, without placing Runnables everywhere.

If you are wanting to force all of these to run on the background thread, make the abstract methods protected. Then place your executor service in the parent class, and instead of returning the Runnable, kick it off in the executor service.

Each of your child classes now have all of the async operations automatically, but you only have to implement the four methods to achieve that.

Answer 2

You can use a Queue of method invocations as well as a Router to determine which class's methods to invoke:

public interface Camera {
  public void init();
  public void start();
  public void stop();
  public void release();
}

public class Router implements Runnable {
  private final EnumMap<CameraType, Camera> cameras = new EnumMap<>(CameraType.class);
  private final BlockingQueue<RouterInvocation> queue = new LinkedBlockingQueue<>();

  public enum CameraType {
    CAMERA1, CAMERA2, //etc
  }

  private enum CameraMethod {
    INIT, START, STOP, RELEASE
  }

  private class RouterInvocation {
    public final Camera camera;
    public final CameraMethod cameraMethod;
    public RouterInvocation(Camera c, CameraMethod cm) {
      this.camera = c;
      this.cameraMethod = cm;
    }
  }

  // similar methods for start, stop, release
  public void init(CameraType cameraType) {
    queue.offer(new RouterInvocation(cameras.get(cameraType), INIT);
  }

  public void run() {
    try {
      while(true) {
        // wait for next RouterInvocation
        RouterInvocation i = queue.take();
        if(i.cameraType == INIT) {
          i.camera.init();
        } else if // same for remaining methods
      }
    } catch(InterruptedException ex) {
      return;
    }
  }
}

The benefit is that you only need to submit one Runnable (the Router) to the ExecutorService - the Router is then responsible for invoking the appropriate method from the appropriate Camera implementation.

If you decide that you want multiple threads processing the queue then you can either share the queue among multiple Routers, or my recommendation would be to move the ExecutorService inside of the Router (so Router no longer implements Runnable but instead creates internal Runnables to process the queue).