Akka - dodawanie dokolejki

Witam uczę się ostatnio akka actor.
Próbuje dodać obiekty do kolejki w aktorze (dane pochodzą z innego aktora a te z kolei pochodzą z listenera) przy dodawaniu do kolejki dzieje się taka rzecz że kolejka sie zapełnie jednak tymi samymi danymi np.
[1]
[2,2]
[3,3,3] itd.
co może być problemem?
poniżej aktor w którym to robie

package service.actors.xtb;

import akka.actor.typed.Behavior;
import akka.actor.typed.javadsl.AbstractBehavior;
import akka.actor.typed.javadsl.ActorContext;
import akka.actor.typed.javadsl.Behaviors;
import akka.actor.typed.javadsl.Receive;
import model.Candle;
import model.Tick;

import java.util.Deque;
import java.util.concurrent.LinkedBlockingDeque;

public class CandleActor extends AbstractBehavior<Tick> {
    private final Deque<Tick> tickDeque;
    private final Candle candle;

    static Behavior<Tick> create() {
        return Behaviors.setup(CandleActor::new);
    }

    public CandleActor(ActorContext<Tick> context) {
        super(context);
        tickDeque = new LinkedBlockingDeque<>();
        candle = new Candle();
        context.getLog().info("candle actor started");
    }

    @Override
    public Receive<Tick> createReceive() {
        return newReceiveBuilder()
                .onMessage(Tick.class, this::toCandleHandler).build();
    }

    private Behavior<Tick> toCandleHandler(Tick tick) {
        tickDeque.addLast(tick);
        getContext().getLog().info("First -> " + tickDeque.getFirst().getBid() + " | " + " First -> " + tickDeque.getFirst().getBid());
        return this;
    }
}

A jak wygląda ten Tick? i jak wysyłasz?
Co to za dziwactwo?

 getContext().getLog().info("First -> " + tickDeque.getFirst().getBid() + " | " + " First -> " + tickDeque.getFirst().getBid());

@jarekr000000: log to oczywiście babol:
powinno być getContext().getLog().info("First -> " + tickDeque.getFirst().getBid() + " | " + " Last -> " + tickDeque.getLast().getBid() + " | " + "Size -> " + tickDeque.size());
chciałem sprawdzić czy po serii ticków początek będzie inny niż koniec.
ticki pobieram z listenera ( zewnętrzne api) do pierwszego aktora tam go zmieniam na mój model ticka:

package model;

import lombok.ToString;

@ToString
public class Tick {
    private String symbol;
    private long timestamp;
    private Double ask;
    private Double bid;
    private Long askVolume;
    private Long bidVolume;
    private double spreadRaw;
    private double spreadTable;
    private int digits;

    public Tick() {
    }

    public Tick(String symbol, long timestamp, Double ask, Double bid, Long askVolume, Long bidVolume,
                double spreadRaw, double spreadTable, int digits) {
        this.symbol = symbol;
        this.timestamp = timestamp;
        this.ask = ask;
        this.bid = bid;
        this.askVolume = askVolume;
        this.bidVolume = bidVolume;
        this.spreadRaw = spreadRaw;
        this.spreadTable = spreadTable;
        this.digits = digits;
    }

    public String getSymbol() {
        return symbol;
    }

    public void setSymbol(String symbol) {
        this.symbol = symbol;
    }

    public long getTimestamp() {
        return timestamp;
    }

    public void setTimestamp(long timestamp) {
        this.timestamp = timestamp;
    }

    public Double getAsk() {
        return ask;
    }

    public void setAsk(Double ask) {
        this.ask = ask;
    }

    public Double getBid() {
        return bid;
    }

    public void setBid(Double bid) {
        this.bid = bid;
    }

    public Long getAskVolume() {
        return askVolume;
    }

    public void setAskVolume(Long askVolume) {
        this.askVolume = askVolume;
    }

    public Long getBidVolume() {
        return bidVolume;
    }

    public void setBidVolume(Long bidVolume) {
        this.bidVolume = bidVolume;
    }

    public double getSpreadRaw() {
        return spreadRaw;
    }

    public void setSpreadRaw(double spreadRaw) {
        this.spreadRaw = spreadRaw;
    }

    public double getSpreadTable() {
        return spreadTable;
    }

    public void setSpreadTable(double spreadTable) {
        this.spreadTable = spreadTable;
    }

    public int getDigits() {
        return digits;
    }

    public void setDigits(int digits) {
        this.digits = digits;
    }
}

potem ticka przesyłąm do docelowego aktora i chce dodać do kolejki(w debugu widać że wartości przesyłają sie prawidłowo)

@i1010011010: Wysyłam go z aktora:

package service.actors.xtb;

import akka.actor.typed.ActorRef;
import akka.actor.typed.Behavior;
import akka.actor.typed.javadsl.AbstractBehavior;
import akka.actor.typed.javadsl.ActorContext;
import akka.actor.typed.javadsl.Behaviors;
import akka.actor.typed.javadsl.Receive;
import model.Tick;
import pro.xstore.api.message.records.STickRecord;

public class TickActor extends AbstractBehavior<STickRecord> {
    private final Tick tick;
    private final ActorRef<Tick> ref;


    public static Behavior<STickRecord> create() {
        return Behaviors.setup(TickActor::new);
    }

    private TickActor(ActorContext<STickRecord> context) {
        super(context);
        tick = new Tick();
        ref = context.spawn(CandleActor.create(), "candle-actor");
        context.getLog().info("xtb-tick started");
    }

    @Override
    public Receive<STickRecord> createReceive() {
        return newReceiveBuilder()
                .onMessage(STickRecord.class, this::xtbTickToTick).build();
    }

    private Behavior<STickRecord> xtbTickToTick(STickRecord record) {
        tick.setSymbol(record.getSymbol());
        tick.setTimestamp(record.getTimestamp());
        tick.setAsk(record.getAsk());
        tick.setBid(record.getBid());
        tick.setAskVolume(record.getAskVolume());
        tick.setBidVolume(record.getBidVolume());
        tick.setSpreadRaw(record.getSpreadRaw());
        tick.setSpreadTable(record.getSpreadTable());
        ref.tell(tick);
        return this;
    }
}

No to wszystko jasne. Jestes ofiara mutacji - za kązdym razem wysyłasz ten sam obiekt Tick. Tylko mutujesz go, ale to ten sam obiekt.
Wywal pole private final Tick tick;
I twórz za każdym razem nowy Tick w metodzie xtbTickToTick.

Skąd w ogóle taki pomysł był, żeby Tick wrzucać do stanu tego drugiego aktora?
W ogóle zrób ten Tick niemutowalny i nie rób sobie więcej problemów.

@jarekr000000: Dzięki teraz działa.
Generalnie to chce w drugim aktorze zrobić z ticka candle(czyli świeczkę np minutową zbudowaną z wielu ticków).
Moja apka to jest automatyczny trading (na razie z api xtb ale z mozliwościa rozszeżenia) i myślałem że model aktora się tu przyda(przy okazji naucze sie nowej technologii).
W każdym razie dzięki za pomoc.

@jarekr000000: A czy da sie przesłąć 2 obiekty pomiędzy aktorami (np Tick i Long)?

Tak, da się. Możesz przesłać pomiędzy aktorami praktycznie wszystko. Pamiętaj tylko o tym, że stan wewnątrz aktora powinien być mutowalny, ale same obiekty już nie - czyli dokładnie odwrotnie niż masz