创建操作作业的队列

Question

I want to build a thread listens a queue and perform a job whenever i add a item to queue.

But i don't much idea about how to develop it. I have already tried some Flowable examples from RxJava2 but not recognized how to do it.

I am open for all examples in Android and Java, Maybe message handler or executors would be an easy solution. Sadly no know-how. Esspecally RxJava2 would be great.

UPDATE

In other words i want to build a queue mechanism on it because long logs are displaying as seperated and timing making them mixed whenever 2 of them called in near time.

public final class Logcat {

   private static final String TAG = "HOWDY";

   public static void v(String message) {
       Log.v(TAG, message);
   }

   public static void d(String message) {
       Log.d(TAG, message); 
       //TODO I will add a for-loop later for long messages to make sure to show all of them for each method.
   }

   public static void e(Throwable throwable) {
       Log.e(TAG, throwable.getMessage());
   }

   public static void e(String message) {
       Log.e(TAG, message);
   }

   public static void e(ApiError error) {
       Log.e(TAG, error.message);
   }
}

Answer 1

Ok here is how I would do it..

import java.util.Queue;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;

import io.reactivex.Observable;
import io.reactivex.schedulers.Schedulers;
import io.reactivex.subjects.PublishSubject;

public class DemoRxJava2 {

    public static void testWithQueue() {

        CompletableFuture<String> allDone = new CompletableFuture<>();
        AtomicBoolean submitDone = new AtomicBoolean(Boolean.FALSE);
        final Queue<Long> queue = new ConcurrentLinkedQueue<>();

        Observable.interval(2, TimeUnit.SECONDS)
        .takeWhile(tick -> !queue.isEmpty() || !submitDone.get())
        .flatMap(tick -> {
            return Observable.create(sub -> {
                while (!queue.isEmpty()) {
                    sub.onNext(queue.poll());
                }
                sub.onComplete();
            });
        })
        .subscribeOn(Schedulers.single())
        .doOnSubscribe(dis -> System.out.println("Queue processing active"))
        .doOnComplete(() -> {
            System.out.println("Queue processing done");
            allDone.complete("DONE");
        })
        .subscribe(nextTs -> System.out.printf("[%s] : Processing tx : %d\n", Thread.currentThread().getName(), nextTs));

        Observable.interval(1,TimeUnit.SECONDS)
        .take(10)
        .doOnSubscribe(dis -> System.out.println("Job submitter start"))
        .doOnNext(tick -> {
            long ms = System.currentTimeMillis() / 1000;
            System.out.printf("[%s] : Submitting tx : %d\n", Thread.currentThread().getName(), ms);
            queue.add(ms);
        })
        .doOnComplete(() -> submitDone.set(Boolean.TRUE))
        .blockingSubscribe();

        try {
            allDone.get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }

    public static void testWithSubject() {

        CompletableFuture<String> allDone = new CompletableFuture<>();

        PublishSubject<Long> queue = PublishSubject.create();

        queue.observeOn(Schedulers.single())
        .flatMap(tx -> Observable.just(tx).delay(2, TimeUnit.SECONDS))
        .doOnSubscribe(dis -> System.out.println("Queue processing active"))
        .doOnComplete(() -> allDone.complete("DONE"))
        .subscribe(nextTs -> System.out.printf("[%s] : Processing tx : %d\n", Thread.currentThread().getName(), nextTs));

        Observable.interval(1, TimeUnit.SECONDS)
        .take(10)
        .doOnSubscribe(dis -> System.out.println("Job submitter start"))
        .doOnNext(tick -> {
            long ms = System.currentTimeMillis() / 1000;
            System.out.printf("[%s] : Submitting tx : %d\n", Thread.currentThread().getName(), ms);
            queue.onNext(ms);
        })
        .doOnComplete(() -> queue.onComplete())
        .blockingSubscribe();

        //wait until all done
        try {
            allDone.get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        testWithQueue();
        testWithSubject();
    }
}

This is just a demonstration of how to process a queue of objects in a seperate thread using RxJava, adapt it to your need

Answer 2

This is the way i do.

interface ILog {

   String TAG = "HOWDY";

   void display();
}

And my abstract class;

abstract class AbstractLog implements ILog {

   String mLog;

   AbstractLog(@NonNull String log) {
       mLog = log;
   }
}

Here is my concrete classes; There are also another class like Verbose and etc.

public class ErrorLog extends AbstractLog {

   ErrorLog(@NonNull String log) {
       super(log);
   }

   ErrorLog(@NonNull Throwable throwable) {
       super(throwable.getMessage());
   }

   ErrorLog(@NonNull ApiError error) {
       super(error.message);
   }

   @Override
   public void display() {
      Log.e(TAG, mLog);
   }
}

This is class developer going to interaction with.

public final class Logcat {

   private static LogQueue sQueue = new LogQueue();

   public static void v(String log) {
       Message message = new Message();
       message.obj = new VerboseLog(log);

       sQueue.sendMessage(message);
   }

   public static void d(String log) {
       Message message = new Message();
       message.obj = new DebugLog(log);

       sQueue.sendMessage(message);
   }

   public static void e(Throwable throwable) {
       Message message = new Message();
       message.obj = new ErrorLog(throwable);

       sQueue.sendMessage(message);
   }

   public static void e(String log) {
       Message message = new Message();
       message.obj = new ErrorLog(log);

       sQueue.sendMessage(message);
   }

   public static void e(ApiError error) {
       Message message = new Message();
       message.obj = new ErrorLog(error);

       sQueue.sendMessage(message);
   }

   private static class LogQueue extends Handler {

       @Override
       public void handleMessage(Message msg) {
           super.handleMessage(msg);

           ILog log = (ILog) msg.obj;
           log.display();
       }
   }
}

Hope it helps to others.