System.currentTimeMillis vs System.nanoTime

Doğruluk Vs. Hassas

Bilmek istediğim, oyunumda nesnemin konumlarını güncellerken System.currentTimeMillis () veya System.nanoTime () kullanmalı mıyım ? Hareketteki değişimleri son çağrıdan bu yana geçen süre ile doğru orantılıdır ve ben mümkün olduğunca kesin olmak istiyorum.

Farklı işletim sistemleri arasında bazı ciddi zaman çözünürlüğü sorunları olduğunu okudum (yani Windows 50ms çözünürlüğe sahipken Mac / Linux neredeyse 1 ms çözünürlüğe sahip?). Öncelikle uygulamalarımı pencerelerde çalıştırıyorum ve 50 ms çözünürlük oldukça yanlış görünüyor.

Listelediğim ikisinden daha iyi seçenekler var mı?

Herhangi bir öneriniz / yorumunuz var mı?

Sadece geçen sürenin son derece hassas ölçümlerini arıyorsanız , kullanın System.nanoTime(). System.currentTimeMillis()dönemden bu yana milisaniye cinsinden mümkün olan en doğru süreyi System.nanoTime()size verir , ancak rastgele bir noktaya göre size nanosaniye-hassas bir süre verir.

Java Belgelerinden:

public static long nanoTime()

Mevcut en hassas sistem zamanlayıcısının nanosaniye cinsinden geçerli değerini döndürür.

Bu yöntem yalnızca geçen süreyi ölçmek için kullanılabilir ve başka herhangi bir sistem veya duvar saati zamanı kavramıyla ilgili değildir. Döndürülen değer, sabit ancak keyfi bir başlangıç zamanından beri nanosaniyeyi temsil eder (belki de gelecekte, bu nedenle değerler negatif olabilir). Bu yöntem nanosaniye hassasiyet sağlar, ancak mutlaka nanosaniye doğruluğu sağlamaz. Değerlerin ne sıklıkta değiştiği konusunda hiçbir garanti verilmez. Yaklaşık 292 yıldan (2 ⁶³ nanosaniye) daha uzun süren ardışık çağrılardaki farklılıklar, sayısal taşma nedeniyle geçen süreyi doğru bir şekilde hesaplamayacaktır.

Örneğin, bazı kodların ne kadar sürede yürütüleceğini ölçmek için:

long startTime = System.nanoTime();    
// ... the code being measured ...    
long estimatedTime = System.nanoTime() - startTime;

Ayrıca bkz: JavaDoc System.nanoTime () ve JavaDoc System.currentTimeMillis () .

Kimse bundan bahsetmediği için…

System.nanoTime()Farklı mesaj dizileri arasındaki aramaların sonuçlarını karşılaştırmak güvenli değildir . İpliklerin olayları öngörülebilir bir sırada gerçekleşse bile, nanosaniye fark pozitif veya negatif olabilir.

System.currentTimeMillis() dişler arasında güvenle kullanılabilir.

Arkadiy Güncellemesi : System.currentTimeMillis()Oracle Java 8'de Windows 7'de daha doğru davranış gözlemledim . Zaman 1 milisaniyelik bir hassasiyetle geri döndü. OpenJDK kaynak kodu değişmedi, bu yüzden daha iyi davranış neden ne bilmiyorum.

Sun'dan David Holmes, birkaç yıl önce Java zamanlama API'larına (özellikle System.currentTimeMillis()ve System.nanoTime()), hangisini ve nasıl dahili olarak çalıştıklarını kullanmak istediğinize çok ayrıntılı bir bakış sunan bir blog makalesi yayınladı .

Etkin Nokta VM'sinin İçinde: Saatler, Zamanlayıcılar ve Zamanlama Etkinlikleri - Bölüm I - Windows

Zamanlanmış bekleme parametresi olan API'ler için Windows tarafından Java tarafından kullanılan zamanlayıcının çok ilginç bir yönü, zamanlayıcının çözünürlüğünün diğer API çağrılarının yapılmış olabileceğine bağlı olarak değişebilmesidir - sistem çapında (sadece belirli bir süreçte değil) . Kullanmanın Thread.sleep()bu çözüm değişikliğine neden olacağı bir örnek gösteriyor .

System.nanoTime()eski JVM'lerde desteklenmez. Bu bir endişe ise,currentTimeMillis

Doğruluk konusunda neredeyse haklısınız. SOME Windows makinelerinde currentTimeMillis()yaklaşık 10ms (50ms değil) çözünürlüğe sahiptir. Neden olduğundan emin değilim, ancak bazı Windows makineleri Linux makineleri kadar doğrudur.

Ben kullandım GAGETimer ılımlı bir başarı ile geçmişte.

Diğerlerinin de söylediği gibi currentTimeMillis, yaz saati uygulaması, kullanıcıların saat ayarlarını değiştirmesi, artık saniye sayısı ve internet saati senkronizasyonu nedeniyle değişen saattir. Uygulamanız monoton olarak artan geçen zaman değerlerine bağlıysa bunun yerine nanoTime'ı tercih edebilirsiniz.

Oyuncuların oyun oynarken zaman ayarlarıyla uğraşmayacaklarını ve belki de haklı olacağını düşünebilirsiniz. Ancak internet saati senkronizasyonu veya uzak masaüstü kullanıcıları nedeniyle meydana gelen aksaklıkları hafife almayın. NanoTime API'si bu tür kesintilere karşı bağışıktır.

Saat zamanını kullanmak istiyor ancak internet zaman senkronizasyonu nedeniyle süreksizliklerden kaçınmak istiyorsanız, Meinberg gibi bir NTP istemcisini düşünebilirsiniz; bu, saati periyodik olarak sıfırlamak yerine saat hızını sıfıra "ayarlayan" olabilir.

Ben kişisel deneyimlerime dayanarak söylüyorum. Geliştirdiğim bir hava uygulamasında, rastgele gerçekleşen rüzgar hızı ani yükseliyordum. Benim zaman tabanımın tipik bir PC'deki saat zamanının davranışıyla bozulduğunu fark etmem biraz zaman aldı. NanoTime'ı kullanmaya başladığımda tüm sorunlarım kayboldu. Tutarlılık (monotonluk) benim uygulama için ham hassasiyet veya mutlak doğruluktan daha önemliydi.

Evet, bu tür bir hassasiyet gerekiyorsa kullanın System.nanoTime(), ancak Java 5+ JVM'ye ihtiyacınız olduğunu unutmayın.

XP sistemlerimde, aşağıdaki kodu kullanarak sistem süresinin en az 100 mikrosaniye 278 nanosaniye olarak bildirildiğini görüyorum :

private void test() {
    System.out.println("currentTimeMillis: "+System.currentTimeMillis());
    System.out.println("nanoTime         : "+System.nanoTime());
    System.out.println();

    testNano(false);                                                            // to sync with currentTimeMillis() timer tick
    for(int xa=0; xa<10; xa++) {
        testNano(true);
        }
    }

private void testNano(boolean shw) {
    long strMS=System.currentTimeMillis();
    long strNS=System.nanoTime();
    long curMS;
    while((curMS=System.currentTimeMillis()) == strMS) {
        if(shw) { System.out.println("Nano: "+(System.nanoTime()-strNS)); }
        }
    if(shw) { System.out.println("Nano: "+(System.nanoTime()-strNS)+", Milli: "+(curMS-strMS)); }
    }

Oyun grafikleri ve sorunsuz konum güncellemeleri için, System.nanoTime()yerine kullanın System.currentTimeMillis(). Bir oyunda currentTimeMillis () 'den nanoTime ()' a geçtim ve hareket düzgünlüğünde önemli bir görsel gelişme elde ettim.

Bir milisaniye zaten kesin olması gerektiği gibi görünse de, görsel olarak değildir. Gelişebilecek faktörler nanoTime()şunları içerir:

• duvar saati çözünürlüğünün altında doğru piksel konumlandırma
• isterseniz pikseller arasında kenar yumuşatma yeteneği
• Windows duvar saati yanlışlığı
• saat titremesi (duvar saatinin gerçekten ileri gittiğinde tutarsızlık)

Diğer cevapların önerdiği gibi, nanoTime tekrar tekrar çağrıldığında bir performans maliyetine sahiptir - bunu çerçeve başına sadece bir kez aramak ve tüm çerçeveyi hesaplamak için aynı değeri kullanmak en iyisidir.

Nanotime konusunda iyi bir deneyim yaşadım . Bir JNI kütüphanesi kullanarak, duvar saati süresini iki uzun (o saniyeden bu yana geçen saniye ve nanosaniye saniye) sağlar. Hem Windows hem de Linux için önceden derlenmiş JNI parçası ile kullanılabilir.

System.currentTimeMillis()bu yöntem sistemin gerçek zamanlı saat değişikliklerine duyarlı olduğundan, geçen süre için güvenli değildir. Kullanmalısınız System.nanoTime. Lütfen Java Sistemi yardımına bakın:

NanoTime yöntemi hakkında:

.. Bu yöntem nanosaniye hassasiyet sağlar, ancak mutlaka nanosaniye çözünürlük (yani değer ne sıklıkta değişir) - çözünürlüğün en azından currentTimeMillis () kadar iyi olması dışında hiçbir garanti verilmez.

System.currentTimeMillis()Geçen sürenizi kullanırsanız negatif olabilir (Geri <- geleceğe)

burada bir şey nanoTime yönteminin tutarsızlığıdır. aynı giriş için çok tutarlı değerler vermez. currentTimeMillis performans ve tutarlılık açısından çok daha iyi yapar ve ayrıca nanoTime kadar kesin olmasa da daha düşük bir hata payına sahiptir. ve dolayısıyla değerinde daha fazla doğruluk. bu nedenle currentTimeMillis kullanmanızı öneririm