Wie schlecht ist new Thread().sleep im Vergleich zu Thread.sleep in Bezug auf die CPU- und Speichernutzung?

Question

Mir ist bewusst, dass der Zugriff auf sleep in einem statischen Kontext erfolgen sollte. Ich benötige jedoch mehr Informationen, damit ich dies gegenüber dem Management verteidigen kann. Der meiste Legacy-Code, den ich bearbeite, verwendet jetzt new Thread().sleep anstelle von Thread.sleep.

Wie schlimm ist das?

for (int c = 0; c < 5; c++) {
    new Thread().sleep(5000);
}

im Vergleich zu diesem?

for (int c = 0; c < 5; c++) {
    Thread.sleep(5000);
}

EDIT:

    final long start = System.currentTimeMillis();
    System.out.println("Total memory: " + Runtime.getRuntime().totalMemory());
    System.out.println("Free memory: " + Runtime.getRuntime().freeMemory());
    System.out.println("===========================");
    for (int c = 0; c < 5; c++) {
        new Thread().sleep(5000);
        System.out.println("Used memory: " + (Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()));
        System.out.println("===========================");
    }
    System.out.println("Total memory: " + Runtime.getRuntime().totalMemory());
    System.out.println("Free memory: " + Runtime.getRuntime().freeMemory());
    System.out.println("===========================");
    System.out.println("Time elapsed: " + (System.currentTimeMillis() - start) + " milliseconds");

Ergebnis (new Thread().sleep):

Total memory: 5177344
Free memory: 4990904
===========================
Used memory: 186440
===========================
Used memory: 205136
===========================
Used memory: 205136
===========================
Used memory: 205136
===========================
Used memory: 205136
===========================
Total memory: 5177344
Free memory: 4972208
===========================
Time elapsed: 24938 milliseconds

Ergebnis (Thread.sleep):

Total memory: 5177344
Free memory: 4990904
===========================
Used memory: 186440
===========================
Used memory: 186440
===========================
Used memory: 204848
===========================
Used memory: 204848
===========================
Used memory: 204848
===========================
Total memory: 5177344
Free memory: 4972496
===========================
Time elapsed: 24938 milliseconds

Answer 1

Sie tun dasselbe, und die Methode ist in beiden Fällen statisch.

Unter new Thread().sleep(5000); ist nicht klar, was eigentlich vor sich geht, denn die statische Methode wird von einer Instanz aus aufgerufen. Das heißt, sie ist funktional identisch mit Thread.sleep(5000); Das hat den Vorteil, dass es transparent ist.

Es ist auch nicht klar, dass es der aktuelle Thread ist, der in den Ruhezustand versetzt wird, so dass jemand berechtigterweise rätseln könnte, ob es der aktuelle Thread oder ein neu erstellter Thread ist, der in den Ruhezustand versetzt wird; es ist tatsächlich der aktuelle Thread.

Wenn der erste Stil erlaubt ist, könnten Sie so etwas haben wie:

Thread anotherThread = new Thread();

haben dann später

anotherThread.sleep(5000);

Auch dies ist identisch mit Thread.sleep(5000); und versetzt den aktuellen Thread tatsächlich in den Ruhezustand. Aber es ist überhaupt nicht offensichtlich, was da vor sich geht.

Der Stil im zweiten Fall ist vorzuziehen, da er diese Fallstricke und die mit der Erstellung einer neuen Instanz verbundenen Leistungseinbußen vermeidet. Er sollte daher immer verwendet werden.