WebFlux issue when creating a global publisher subscription - spring-webflux

Question

I have written to the publisher and it works if they subscribe to it every time. The problem arises when I try to make it global so that all subscribers receive the same messages.
Here is my code :
public class MyPublisherDemo {
private final ArrayBlockingQueue<SavedEvent> myBlockingQueue = new ArrayBlockingQueue<>(100, true);
private final Flux<SavedEvent> fx = Flux.create(event -> {
try{
while(true){
Thread.sleep(5000);
if(myBlockingQueue.isEmpty()){
System.out.println("back");
break;
}
event.next(myBlockingQueue.poll());
System.out.println("next");
}
event.complete();
System.out.println("complete");
}catch (Exception e) {
event.error(new RuntimeException(e));
}
});
private final ConnectableFlux<SavedEvent> cf = fx.publish();
public Flux<String> getFluxTest(SavedEvent savedEvent){
myBlockingQueue.add(savedEvent);
cf.connect();
return cf.map(SavedEvent::getOccurredEvent);
}
public int getQueueSize(){
return myBlockingQueue.size();
}
}
And I wrote the following test to check:
#Test
public void test5(){
try {
MyPublisherDemo myPublisherDemo = new MyPublisherDemo();
Runnable task = () -> {
System.out.println(Thread.currentThread().getName() + " Run");
myPublisherDemo.getFluxTest(new SavedEvent().builder()
.id(1L)
.occurredEvent("(" + Thread.currentThread().getName() + ")" + " Coffee Machine start")
.eventTime(LocalDateTime.now())
.fillTheWaterTank(1000)
.fillCoffeeTank(1000)
.build())
.subscribe(
event -> System.out.println(Thread.currentThread().getName() + " " + event),
System.out::println,
() -> System.out.println(Thread.currentThread().getName() + " end")
);
};
Thread th1 = new Thread(task, "thread-1");
th1.start();
Thread.sleep(2000);
Thread th2 = new Thread(task, "thread-2");
th2.start();
Thread.sleep(20000);
System.out.println("Queue size = " + myPublisherDemo.getQueueSize());
System.out.println("Basic thread run. End program.");
}catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
The structure of SavedEvent I think is clear from builder().
The point of the publisher is to wait for the event for 5 seconds if the current event is still being processed.
The version I used before:
private final ArrayBlockingQueue<SavedEvent> myBlockingQueue = new ArrayBlockingQueue<>(100, true);
private final AtomicInteger counterRequest = new AtomicInteger(100);
private final Flux<SavedEvent> fx = Flux.fromIterable(myBlockingQueue)
.delayElements(Duration.ofSeconds(7))
.map(data ->{
myBlockingQueue.poll();
counterRequest.decrementAndGet();
return data;
})
.repeat(counterRequest.get());
private final ConnectableFlux<SavedEvent> cf = fx.publish();
Problem when working with two subscribers they don't receive all messages.
thread-1 Run
thread-2 Run
thread-1 (thread-1) Coffee Machine start
next
thread-1 (thread-2) Coffee Machine start
next
back
thread-1 end
complete
Queue size = 0
Basic thread run. End program.
The result I'm expecting:
thread-1 Run
thread-2 Run
thread-1 (thread-1) Coffee Machine start
thread-2 (thread-1) Coffee Machine start
next
thread-2 (thread-2) Coffee Machine start
thread-1 (thread-2) Coffee Machine start
next
back
thread-1 end
complete
back
thread-2 end
complete
Queue size = 0
Basic thread run. End program.
If the error is in how I'm trying to implement the publisher, please write how it should be done correctly. Thank you in advance.

Answer 1

While experimenting with RxJava I found a solution on the net:
let myObservable = Observable.just(1).publish()
print("Subscribing")
myObservable.subscribe(onNext: {
print("first = \($0)")
})
myObservable.subscribe(onNext: {
print("second = \($0)")
})
DispatchQueue.main.asyncAfter(deadline: .now() + 3) {
print("Calling connect after 3 seconds")
myObservable.connect()
}
It's not obvious, but for the first subscriber, you first need to have a subscription to the publisher and then you need to start the publisher.I did not understand why this is so. It works.
public class MyPublisherDemo {
private final ArrayBlockingQueue<SavedEvent> myBlockingQueue = new ArrayBlockingQueue<>(100, true);
private final AtomicBoolean connectFlag = new AtomicBoolean(false);
private final ConnectableFlux<String> myEventGenerator = Flux.create(event ->{
try{
while(true){
Thread.sleep(5000);
if(myBlockingQueue.isEmpty()){
break;
}
event.next(myBlockingQueue.poll());
}
connectFlag.getAndSet(false);
event.complete();
}catch (Exception e) {
event.error(new RuntimeException(e));
}
}).map(event -> {
SavedEvent se = (SavedEvent) event;
return se.getOccurredEvent();
}).publish();
public Flux<String> getFluxTest(SavedEvent savedEvent){
myBlockingQueue.add(savedEvent);
delayedStart();
return myEventGenerator;
}
public int getQueueSize(){
return myBlockingQueue.size();
}
private void delayedStart(){
if (!connectFlag.getAndSet(true)) {
Runnable task = () -> {
try {
Thread.sleep(500);
myEventGenerator.connect();
} catch (Exception e) {
System.err.println(e);
}
};
Thread th1 = new Thread(task);
th1.start();
}
}
}