Wie suspendiere ich einen Java-Thread für eine kurze Zeit, zB 100 Nanosekunden?

Ich weiß Thread.sleep() kann ein java-thread anhalten für eine Weile, wie einige Millisekunden und bestimmte Nanosekunden. Aber das problem ist der Aufruf dieser Funktion bewirkt auch, dass overhead.

Zum Beispiel, wenn ich will, einen thread zu sperren für 100 Nanosekunden, und ich nenne Thread.sleep(0, 100). Die gesamten Kosten für diesen Prozess ist invocation_cost + 100 nanosceonds, die viel größer ist das, was ich will. Wie könnte ich dieses problem vermeiden, und erreichen mein Ziel?

Den Grund brauche ich dies, die ich tun möchte-simulation offline. Ich profiliert die Ausführungszeit einer Aufgabe; Nun möchte ich, um dies zu simulieren Ausführungszeit durch das Aufhängen einen Faden in der gleichen Zeit.

Dank!

Kommentar zu dem Problem

Hast du einen bestimmten Grund, warum Sie dies tun wollen? Wenn dem so ist, kann es gelöst werden, eine andere Art und Weise... Kommentarautor: g t

Dies ist eine sehr ungewöhnliche Anforderung. Es klingt wie Sie brauchen eine back off Strategie oder ähnlich. Kommentarautor: Bohemian♦

@gt FYI, es ärgerlich zu Fragen auf stackoverflow und Antworten, Frage Sie, anstatt eine Antwort. Es gibt viele Gründe für den Wunsch, das zu tun, sich in Projekten über die Jahre. Ein praktischer Grund wäre für die Aufrechterhaltung Echtzeit-Verhalten bei Anwendungen, die Aufzeichnung von audio-hardware, da die hardware inkonsistent Verhalten, oder Sie können die Simulation von hardware-Verhalten für Testzwecke . Kommentarautor: EntangledLoops

@EntangledLoops Dank für die Bereitstellung ein Beispiel. Ich zweifle nicht, es gibt gute Gründe, dies zu tun. Ich finde die besten Antworten werden oft zu berücksichtigen, in welchem Kontext die Frage gestellt wurde. Blick auf Peter Lawrey die Antwort von unten zu sehen, ein Beispiel, einmal-OP-vorausgesetzt, ein paar hintergrund-info. Kommentarautor: g t

InformationsquelleAutor der Frage JackWM | 2012-07-16

19

Die Granularität der schläft, ist in der Regel gebunden durch den thread-scheduler interrupt-Periode. Unter Linux wird dieser interrupt Zeitraum ist in der Regel 1ms in neuere Kernel. In Windows den scheduler-interrupt-Periode ist in der Regel etwa 10 oder 15 Millisekunden

Wenn ich halt die threads für die Dauer weniger, als diese, die ich normalerweise verwenden ein busy wait

BEARBEITEN: ich vermute, Sie werden bekommen die besten Ergebnisse auf jrockit + solaris. Die zahlen auf einem windows-Rechner sind schrecklich.
```
@Test
public void testWait(){
    final long INTERVAL = 100;
    long start = System.nanoTime();
    long end=0;
    do{
        end = System.nanoTime();
    }while(start + INTERVAL >= end);
    System.out.println(end - start);
}
```
InformationsquelleAutor der Antwort qwerty
12

Für die simulation würde ich nicht versuchen zu simulieren, in Echtzeit, während diese doesn ' T geben Sie reproduzierbare Ergebnisse. d.h. Sie können nicht testen Sie Ihre simulation.

Stattdessen würde ich eine Daten-getrieben, simulierten Uhr und alles so schnell wie möglich. Diese erhalten Sie reproduzierbare Ergebnisse und erlaubt die Simulation schneller als in Echtzeit (z.B. 2x bis 100x schneller)

Ahnend einen thread dauert etwa 10 Mikro-Sekunden. Es gibt keine Stelle versuchen zu sperren thread für weniger Zeit.

Besetzt-warten Sie eine kurze Zeit, können Sie versuchen.
```
long start = System.nanotime();
while(start + delay >= System.nanoTime());
```
Hinweis: als @EugeneBeresovsky Kommentare, nachdem Sie Ihre Maschine läuft schon seit 292 Jahren dieses überlaufen konnten, so dass Sie können wählen, dies zu schreiben, als
```
while(System.nanoTime() - start < delay);
```
Diese wird gut für Verspätungen von weniger als 292 Jahre statt. Sie können mit System.currentTimeMillis() für viel längere Verzögerungen.

Aber selbst das ist nicht zuverlässig als System.nanoTime() kann bis zu 300 ns auf Centos 5.x so ruft es zweimal auf sich nehmen, viel mehr als 100 ns. Auch viele OS haben nur eine Auflösung von 1000 ns (1 Mikro-Sekunde), damit diese Schleife wartet bis zu 1 micro Sekunde, unabhängig von der Verzögerung, die Sie suchen.

Stattdessen, was Sie tun können, ist zu busy wait in einer kurzen Schleife, die nicht optimierte Weise.

Für eine Verzögerung von 100 ns, vermute ich, dass es besser wäre zu warten beschäftigt, auf was Sie warten darauf, statt der Schaffung einer separaten busy-loop.

InformationsquelleAutor der Antwort Peter Lawrey

public static void busySleep(long nanos)
{
  long elapsed;
  final long startTime = System.nanoTime();
  do {
    elapsed = System.nanoTime() - startTime;
  } while (elapsed < nanos);
}

InformationsquelleAutor der Antwort EntangledLoops

1

Ein problem mit Thread.sleep() ist, dass es ist nicht garantiert, wakeup nach der angegebenen Zeit. Ein schlafender thread wird garantiert, um zu schlafen für die angegebene nano/Mikro-Sekunden, aber nicht garantiert wakeup sofort nach, dass. Da sprichst du interms von Nanosekunden, möchten Sie vielleicht versuchen Object.wait(long, int).

Ich ve gewesen, ganz im Einklang mit der Bestellung von 10s von Nanosekunden mit der oben beschriebenen Methode.

InformationsquelleAutor der Antwort Mohan
1

Tun ein busy wait ( dh eine while Schleife Durchlaufen und so viele zahlen nichts zu tun ). Ein start des Programms können Sie die Zeit die Zeit an, die es ausführen dieser geschäftigen warten, und erhöhen oder verringern Sie es, um zu nano 5 Sekunden

Habe ich gefunden Objekt.warten bekommt haarige mit dieser Frequenz auch beachten, dass ein busy wait Lösung würde höchstwahrscheinlich Maschine abhängig Also warum sollten Sie über eine Kalibrierung beim start des Programms

InformationsquelleAutor der Antwort Frank Visaggio

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.