Java 创建操作作业的队列

我想构建一个线程侦听队列，并在向队列添加项目时执行作业

但我不知道如何开发它。我已经尝试了一些来自RxJava2的可流动示例，但没有认识到如何做到这一点

我对Android和Java中的所有示例都持开放态度，也许消息处理程序或执行器将是一个简单的解决方案。遗憾的是，没有专门知识。特别是RxJava2将非常棒

更新

换句话说，我想在它上面建立一个队列机制，因为长日志显示为分离的，并且计时使它们在最近的时间内被调用时混合在一起

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

我就是这样做的

interface ILog {

   String TAG = "HOWDY";

   void display();
}

和我的抽象类

abstract class AbstractLog implements ILog {

   String mLog;

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

这是我的具体课程；还有另一个类，如Verbose等

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

这是类开发人员要与之交互的

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

---

希望这对其他人有帮助。

好的，下面是我将如何做的

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

import java.util.Queue；
导入java.util.concurrent.CompletableFuture；
导入java.util.concurrent.ConcurrentLinkedQueue；
导入java.util.concurrent.ExecutionException；
导入java.util.concurrent.TimeUnit；
导入java.util.concurrent.AtomicBoolean；
导入io.reactivex.Observable；
导入io.reactivex.schedulers.schedulers；
导入io.reactivex.subjects.PublishSubject；
公共类DemoRxJava2{
publicstaticvoidtestwithqueue（）{
CompletableFuture allDone=新的CompletableFuture（）；
AtomicBoolean submitDone=新的AtomicBoolean（Boolean.FALSE）；
最终队列=新ConcurrentLinkedQueue（）；
可观测间隔（2，时间单位秒）
.takeWhile（勾选->！queue.isEmpty（）| |！submitDone.get（））
.flatMap（勾选->{
返回可观察。创建（子->{
而（！queue.isEmpty（））{
sub.onNext（queue.poll（））；
}
sub.onComplete（）；
});
})
.subscribeOn（Schedulers.single（））
.doOnSubscribe（dis->System.out.println（“队列处理活动”））
.doOnComplete（（）->{
System.out.println（“队列处理完成”）；
全部完成。完成（“完成”）；
})
.subscribe（nextTs->System.out.printf（“[%s]：处理发送：%d\n”，Thread.currentThread（）.getName（），nextTs））；
可观测间隔（1，时间单位。秒）
.take（10）
.doOnSubscribe（dis->System.out.println（“作业提交者启动”））
.doOnNext（勾选->{
长毫秒=System.currentTimeMillis（）/1000；
System.out.printf（“[%s]：提交发送：%d\n”，Thread.currentThread（）.getName（），ms）；
队列添加（ms）；
})
.doOnComplete（（）->submitDone.set（Boolean.TRUE））
.阻止订阅（）；
试一试{
全部完成。获取（）；
}捕获（中断异常|执行异常e）{
e、 printStackTrace（）；
}
}
公共静态void testWithSubject（）{
CompletableFuture allDone=新的CompletableFuture（）；
PublishSubject队列=PublishSubject.create（）；
queue.observeOn（Schedulers.single（））
.flatMap（tx->Observable.just（tx）.延迟（2，时间单位.秒））
.doOnSubscribe（dis->System.out.println（“队列处理活动”））
.doOnComplete（（）->allDone.complete（“完成”））
.subscribe（nextTs->System.out.printf（“[%s]：处理发送：%d\n”，Thread.currentThread（）.getName（），nextTs））；
可观测间隔（1，时间单位。秒）
.take（10）
.doOnSubscribe（dis->System.out.println（“作业提交者启动”））
.doOnNext（勾选->{
长毫秒=System.currentTimeMillis（）/1000；
System.out.printf（“[%s]：提交发送：%d\n”，Thread.currentThread（）.getName（），ms）；
queue.onNext（ms）；
})
.doOnComplete（（）->queue.onComplete（））
.阻止订阅（）；
//等到一切都做完
试一试{
全部完成。获取（）；
}捕获（中断异常|执行异常e）{
e、 printStackTrace（）；
}
}
公共静态void main（字符串[]args）{
testWithQueue（）；
testWithSubject（）；
}
}

---

这只是一个演示，演示如何使用RxJava在一个单独的线程中处理对象队列，并根据您的需要调整它

这就是

java.util.concurrent.Executors

的用途。为什么要用RxJava来做呢？很好。我忘了加上。但是，我从未经历过。我只对RxJava2感兴趣。这些项目是什么？您想执行什么工作？项目可以并行处理。是否为每个项目生成结果？是否要等待处理每个或所有项目？项目的数量是有限的吗？我只需要一个io线程。每个工作都需要互相等待。没有并行处理。我已经更新了问题的更多细节。我在你的答案中没有看到任何RxJava2。看起来您并不是在寻找消息的异步处理。我以为您正在寻找一种方法，通过专用的独立线程处理队列中的对象（由其他线程提交）？是的。这就是我想要的；每个日志必须等待以完成队列中的当前日志。否则（如果是并行的），它们将分离输出。我希望RxJava2使用Flowable实现此功能，但不知道如何实现。请参阅我的答案，希望对您有所帮助