Thread.sleep() in EJB Container wie lösen?

[beta20]

Hallo,

ich würde gerne folgendes realisieren:
1) User öffnet ein ChatWidget
2) Es wird auf gespeicherte Regeln geprüft. Die Regel ist, ob nachdem der User das ChatWidget aufgemacht hat, eine Nachricht gesendet werden soll
-> Bisher kein Problem

3) Die Regel wird gleich ausgeführt, aber die Nachricht soll erst nach zB 30 Sekunden abgeschickt werden

Wie löse ich Punkt 3) ? Ich könnte das in eine Queue reinschreiben, aber hier habe ich die Befürchtung, dass gerade noch andere Jobs laufen, sodass das nicht wirklich 30 Sekunden werden kann.

Daher habe ich 2 Fragen:
1) Wie lasse ich das Ausführen der Regel in einem eigenen Thread und im EJB Container laufen? (
2) Wie realisiere ich dann, dass der Thread schläft und dann erst nach 30 Sekunden die Nachricht in die DB erstellt ?

Ein kleines Beispiel würde mir sehr helfen...

 

[mihe7]

In einer EJB:

@Inject 
ManagedScheduledExecutorService mses;

// dann in einer Methode:
        mses.schedule(task, 30, TimeUnit.SECONDS);

Dürfte funktionieren.

 

[beta20]

würde auch das gehen:

@Resource
private ManagedExecutorService executor;

...
In der Methode dann:

            // Thread Sleep
            Runnable task = () -> {
                try {
                    // some long running task
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };
            executor.execute(task);

 

[mihe7]

würde auch das gehen:

Ja, der Thread steht aber dann die gesamte Zeit nicht mehr für andere zur Verfügung.

 

[beta20]

verstehe ich nicht so ganz "für andere"?
Das heißt die Methode kann nicht mehr von andere Usern gleichzeitig ausgeführt werden?

Wenn mein EJB Bean @Stateless ist:
und dann eben hier die Methode:

@Stateless
public class MyServiceBean {

public boolean sendChatMessage() {

            // Thread Sleep
            Runnable task = () -> {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };
            executor.execute(task);
        }

        return true;
    }
}

 

[mihe7]

verstehe ich nicht so ganz "für andere"?
Das heißt die Methode kann nicht mehr von andere Usern gleichzeitig ausgeführt werden?

Nicht die Methode - der Thread.

Stell Dir vor, Du hast eine Warteschlange (FIFO-Puffer), in der die Tasks eingereiht werden. Nehmen wir einfach an, die Warteschlange könnte unbegrenzt wachsen.

Der Server verwaltet nun einen Thread-Pool, dessen Größe in der Regel begrenzt ist. Die Threads holen sich einfach einen Task nach dem anderen aus der Warteschlange und rufen run() auf.

Wenn Du also in Deinem Runnable 30 Sekunden lang wartest, blockierst Du den Thread für 30 Sekunden. Dieser Thread kann also nicht für andere Aufgaben verwendet werden, so dass diese ggf. warten müssen.

Wenn Du Dir einen Thread-Pool der Größe 1 vorstellst, wird das offensichtlich: Du fügst 5 Tasks in die Warteschlange ein (execute) und es gibt einen Worker-Thread, der sich das erste Element aus der Warteschlange holt und abarbeitet. Jetzt dauert es 30 Sekunden, bis er fertig ist. Erst nach Ablauf der 30 Sekunden kann er den nächsten Task aus der Warteschlange behandeln.

Bei zwei Worker-Threads, holen sich beide fast zeitgleich einen Task aus der Warteschlange und arbeiten diese parallel ab. Du blockierst jetzt beide Threads für 30 Sekunden. Erst nach Ablauf der etwa 30 Sekunden können sich beide Threads wieder mit neuen Tasks versorgen.

 

[beta20]

ok, danke...
also müsste es dann so aussehen? Oder was ist in dem Fall dann "task" ?

@Inject

private ManagedScheduledExecutorService executor;

public boolean sendChatMessage() {

    // Thread Sleep

            Runnable task = () -> {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };
            executor.schedule(task, 5000, TimeUnit.MILLISECONDS);

}

 

[kneitzel]

ok, danke...
also müsste es dann so aussehen? Oder was ist in dem Fall dann "task" ?

@Inject

private ManagedScheduledExecutorService executor;

public boolean sendChatMessage() {

    // Thread Sleep

            Runnable task = () -> {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };
            executor.schedule(task, 5000, TimeUnit.MILLISECONDS);

}

Nein, Du brauchst kein Thread.sleep mehr. Der ManagedScheduledExecutorService sorgt dafür, dass der Task erst nach der angegebenen Zeit aufgerufen wird.

 

[beta20]

Ah, also quasi nur so:

Runnable task = () -> {
                LOGGER.info("Waiting...");
            };
executor.schedule(task, milliseconds, TimeUnit.MILLISECONDS);

 

[kneitzel]

Ja, wobei da dann nicht mehr gewartet wird sondern die Wartezeit ist rum, d.h. bei Deinem Beispiel würde in dem task die Email versendet.

 

[beta20]

Hm, das heißt innerhalb dem "Task" müsste dann der Code stehen, was nach den zB 5000 Milisekunden geschehen soll:

Runnable task = () -> {
               [B] // Hier der Code implementieren für "Nachricht senden"[/B]
            };
executor.schedule(task, 5000, TimeUnit.MILLISECONDS);

davor habe ich es so gehabt:

Runnable task = () -> {
                LOGGER.info("Waiting...");
            };
executor.schedule(task, milliseconds, TimeUnit.MILLISECONDS);

   sendeMessage();

 

[thecain]

Ja, aber schau dir doch mal selber die JavaDocs dazu an: https://docs.oracle.com/javaee/7/ap...ncurrent/ManagedScheduledExecutorService.html