Naar de inhoud
OneKitly

Unix-tijdstempels, schrikkelseconden en het probleem van 2038

Gepubliceerd op 20-5-2025 · 17 min leestijd · Ontwikkelaarstools

Daniel Okonkwo

Daniel Okonkwo — Front-enddeveloper en techredacteur bij OneKitly

Webprestaties · Bestandsformaten

Getoetst aan 7 bronnen

Profiel bekijken →
Kort gezegd

Unix-tijd is het aantal seconden sinds 1970-01-01T00:00:00Z, berekend alsof elke dag precies 86.400 seconden bevat. Schrikkelseconden zijn uitgesloten, dus is het geen telling van verstreken fysieke seconden: 86.400 Unix-seconden scheiden 2016-12-31T00:00:00Z van 2017-01-01T00:00:00Z, ook al zijn er werkelijk 86.401 SI-seconden verstreken, want UTC heeft er 23:59:60 tussen gelast. Dat is de bewuste ruil — de teller verliest zijn overeenstemming met de natuurkunde en krijgt de eigenschap dat delen door 86.400 altijd de juiste UTC-datum geeft, zonder dat er een tabel met schrikkelseconden nodig is. Sinds 1972 zijn er zevenentwintig schrikkelseconden ingelast, de laatste op 2016-12-31, en een POSIX-klok heeft geen manier om :60 weer te geven, dus herhaalt of bevriest hij in plaats daarvan een seconde. Het probleem van 2038 staat daar los van: een teller van 32 bits met teken loopt tot 2.147.483.647, en dat is 2038-01-19T03:14:07Z. Eén seconde later slaat hij om naar −2.147.483.648, ofwel 1901-12-13T20:45:52Z. Een time_t van 64 bits loopt tot 9.223.372.036.854.775.807 seconden, ruwweg 292 miljard jaar, en maakt een definitief einde aan het probleem. De meest voorkomende fout is niet 2038 maar seconden met milliseconden verwarren: voor 2026-08-15 geeft de waarde in seconden, gelezen als milliseconden, 1970-01-21, en de waarde in milliseconden, gelezen als seconden, het jaar 58589.

Advertentie

Unix-tijd telt seconden sinds 1970 en negeert daarbij met opzet de schrikkelseconden, en daarom is het geen telling van verstreken fysieke seconden. Hier is wat die ruil je oplevert, wat een schrikkelseconde met de teller doet, het exacte moment waarop een teller van 32 bits met teken overloopt, en de fout met een factor 1000 die je in 1970 of in het jaar 58589 laat belanden.

Wat de teller werkelijk telt

Unix-tijd, of POSIX-tijd, is gedefinieerd als het aantal seconden dat is verstreken sinds 1970-01-01T00:00:00Z, onder de aanname dat elke dag precies 86.400 seconden bevat. De definitie is rekenkundig en niet observationeel: de specificatie geeft een formule die is opgebouwd uit het jaar, de dag van het jaar, het uur, de minuut en de seconde, en in die formule staat geen term voor schrikkelseconden, want schrikkelseconden bestaan erbinnen niet.

Het gevolg is het waard om botweg te stellen, want daar begint de meeste verwarring: een Unix-tijdstempel is geen telling van fysieke seconden. Het is een samengeperste weergave van een UTC-datum en -tijd. Twee tijdstempels die 86.400 uiteenliggen, liggen per constructie precies één UTC-dag uiteen, altijd, ongeacht wat een cesiumklok over hetzelfde interval heeft gemeten.

Eén voorbehoud, want de eigenschap wordt vaak overdreven. Ze geldt in UTC, niet in lokale tijd. Gemeten op echte tijdzonegegevens was lokale middernacht tot lokale middernacht in Europe/Paris 82.800 Unix-seconden op 2026-03-29 en 90.000 op 2026-10-25, tegen 86.400 op een gewone dag; America/New_York gaf 82.800 op 2026-03-08. De zomertijd verandert de teller niet — ze verandert hoeveel tikken van de teller er in een lokale kalenderdag passen, en dat is precies de reden dat tijdstempels als UTC-momenten moeten worden opgeslagen en alleen bij het weergeven moeten worden omgezet.

Advertentie

De ruil: geen schrikkelseconden, geen opzoektabel

Schrikkelseconden uitsluiten lijkt een gebrek tot je het alternatief overweegt. Als de teller fysieke seconden volgde, zou een tijdstempel naar een datum omzetten vereisen dat je elke schrikkelseconde kent die tussen de epoch en dat tijdstempel is ingelast. Schrikkelseconden worden een paar maanden vooraf door de IERS aangekondigd, op basis van metingen van de rotatie van de aarde, dus die tabel kan niet worden berekend — alleen verspreid. Elk apparaat zou hem nodig hebben, bijgehouden, en elk apparaat met een verouderde tabel zou uit hetzelfde getal een andere kalenderdatum berekenen.

Het ontwerp koos bepaaldheid boven fysieke nauwkeurigheid, en de opbrengst is dat rekenen met tijdstempels overal werkt zonder gedeelde toestand. Een telefoon die nooit een netwerkverbinding heeft gehad, berekent uit 1786752000 precies dezelfde datum als een klok in een datacentrum. Delen door 86.400 is juist. Een dag erbij is 86.400 erbij. Sorteren op tijdstempel sorteert op tijd. Niets daarvan zou een definitie op fysieke seconden overleven.

De prijs wordt op precies één plek betaald: elke berekening van een fysieke duur over een schrikkelseconde heen zit ernaast met het aantal schrikkelseconden dat ze kruiste. Tussen 2016-12-31T00:00:00Z en 2017-01-01T00:00:00Z is het Unix-verschil 86.400, terwijl er werkelijk 86.401 SI-seconden zijn verstreken. Voor bijna elke toepassing is die fout irrelevant. Voor satellietafstandsmeting, het ordenen van financiële transacties onder de seconde en natuurkundige timing is ze dat niet, en die vakgebieden gebruiken in plaats daarvan TAI of GPS-tijd — monotone schalen zonder enige schrikkelseconde.

Wat een schrikkelseconde met de teller doet

UTC last een schrikkelseconde in door een minuut 61 seconden te laten bevatten, waarbij de extra seconde 23:59:60 wordt genoemd. Sinds 1972 zijn er zevenentwintig ingelast — TAI min UTC was 10 seconden op 1972-01-01 en is sinds 2017-01-01 37 seconden, en het verschil is precies dat aantal. Ze waren alle positief; een negatieve schrikkelseconde, die een seconde weghaalt, is door de norm toegestaan en is nooit gebruikt.

Een POSIX-klok heeft geen weergave voor de seconde met het label 60, dus moet er iets wijken. Het klassieke gedrag is herhalen: de teller geeft dezelfde waarde twee keer af, één seconde lang is hij niet monotoon, en elke code die strikt oplopende tijdstempels aanneemt, ziet een dubbele waarde. Sommige systemen bevriezen de teller in plaats daarvan een seconde. Beide zijn zichtbaar voor applicaties, en beide hebben echte storingen veroorzaakt in systemen die een tijdstempel als unieke sleutel of als strikt oplopend volgnummer behandelden.

Het pragmatische antwoord waarop grote partijen zijn uitgekomen, is uitsmeren: de extra seconde over een venster van uren spreiden zodat geen enkele klok ooit herhaalt of stilstaat, tegen de prijs dat elke klok in dat venster een beetje verkeerd staat. Dat doet elk jaar minder ter zake, want in november 2022 heeft de 27e Algemene Conferentie over Maten en Gewichten besloten uiterlijk in 2035 te stoppen met het inlassen van schrikkelseconden, waarmee UTC verder van de zonnetijd mag afdrijven dan de huidige grens toestaat. Het mechanisme is nog niet besloten, maar de richting staat vast: de schrikkelseconde wordt afgeschaft.

2038, precies doorgerekend

Een geheel getal van 32 bits met teken bevat waarden van −2.147.483.648 tot 2.147.483.647. Gelezen als seconden sinds de epoch is het maximum 2038-01-19T03:14:07Z. 2.147.483.648 in een echte 32-bitsslot met teken opslaan en terugzetten geeft −2.147.483.648, en dat is 1901-12-13T20:45:52Z. 2.147.483.649 opslaan geeft 1901-12-13T20:45:53Z. De storing is geen crash en geen foutmelding; het is een datum 136 jaar in het verleden, stil geleverd en gebruikt.

Twee aangrenzende feiten zijn het kennen waard. Een teller van 32 bits zonder teken reikt tot 4.294.967.295, en dat is 2106-02-07T06:28:15Z — een gebruikelijke noodgreep in ingebedde firmware, en een die het probleem alleen uitstelt terwijl hij data van vóór 1970 onweergeefbaar maakt. En een time_t van 64 bits met teken reikt tot 9.223.372.036.854.775.807 seconden, ongeveer 292 miljard jaar, en dat is ruwweg eenentwintig keer de huidige leeftijd van het heelal. Dat is geen uitstel; het is een definitieve oplossing.

De datum om je zorgen over te maken is niet 2038 maar vandaag, want de eerste systemen die breken zijn de systemen die momenten in de toekomst berekenen. Vanaf 2026-08-15 ligt de overloop 360.731.647 seconden weg — 4.175 dagen, ofwel 11,43 jaar. Een horizon van tien jaar vanaf die datum eindigt op 2036-08-14 en past nog. Een horizon van vijftien jaar eindigt op 2041-08-14 en past niet. Alles wat een vervaldatum, een aflossingsschema, een bewaartermijn of een geldigheidsduur van een certificaat van langer dan ongeveer elfenhalf jaar opslaat, brengt nu al waarden voort die een veld van 32 bits niet kan bevatten.

Wat in 2026 wel en niet gevaar loopt

Gangbare 64-bitsbesturingssystemen zijn in orde, en dat zijn ze al jaren. Op de machine die voor dit artikel is gebruikt, is sizeof(time_t) 8 bytes en drukt het shellcommando date -u -r 2147483648 Tue Jan 19 03:14:08 UTC 2038 af, zonder enige omslag. Hetzelfde geldt voor elke huidige 64-bitsbuild van Linux, macOS en Windows. JavaScript heeft nooit blootgestaan: een Date bevat een float64-telling van milliseconden en de specificatie begrenst het bereik tot plus of min 8.640.000.000.000.000 milliseconden, en dat loopt van −271821-04-20 tot +275760-09-13.

De blootstelling die overblijft is smal maar echt, en ze zit vooral in velden en niet in processoren. Kolomtypen met een gedocumenteerd bereik van 32 bits komen het meest voor: de TIMESTAMP van MySQL is gespecificeerd tot 2038-01-19 03:14:07 UTC, terwijl het type DATETIME niet is geraakt. Transport- en bestandsformaten die een veld van 32 bits voorschrijven, kunnen niet worden verbreed zonder een nieuwe versie. Firmware op ingebedde 32-bitsmicrocontrollers gebruikt vaak met opzet een teller van 32 bits, om geheugenredenen. En elke codebasis die een epochseconde in een expliciet 32-bitstype opslaat — een int32-kolom, een binair record met vaste breedte, een C-struct gecompileerd voor een 32-bitsdoel — draagt die grens, ongeacht het besturingssysteem eronder.

De praktische audit is kort. Zoek met grep naar int32 en naar INTEGER-kolommen die epochseconden bevatten; controleer het gedocumenteerde bereik van elk tijdstempelkolomtype dat je gebruikt; kijk naar binaire records met vaste breedte en naar elke struct die voor een 32-bitsdoel is gecompileerd; en test met de waarde 2147483648 in plaats van te wachten. Kan een veld niet worden verbreed, dan zijn een ISO 8601-tekenreeks of een telling van 64 bits in milliseconden beide prima alternatieven, en beide kosten meer bytes dan ze aan discussies besparen.

Seconden of milliseconden: de fout met een factor 1000

Dit is met grote afstand de meest voorkomende fout met tijdstempels, en het is volledig een kwestie van eenheden. Unix-tools, de meeste API's en de POSIX-definitie gebruiken seconden. JavaScript, Java en heel veel web-API's gebruiken milliseconden. De twee zijn hetzelfde getal met een factor 1000, en geen van beide is in het transportformaat gelabeld, dus is een verschil onzichtbaar tot er een datum wordt weergegeven.

Beide richtingen leveren een absurd resultaat op, en dat is het goede nieuws. Neem 2026-08-15T00:00:00Z: als seconden is het 1786752000, als milliseconden 1786752000000. Geef de waarde in seconden aan iets dat milliseconden verwacht en je krijgt 1970-01-21T16:19:12Z — drie weken na de epoch, want 1,79 miljard milliseconden is maar ongeveer twintig dagen. Geef de waarde in milliseconden aan iets dat seconden verwacht en je krijgt het jaar 58589, preciezer +058589-12-01T00:00:00Z. Beide liggen zo ver van het plausibele dat één steekproef ze betrapt.

De vuistregel die werkt: een huidig tijdstempel in seconden heeft tien cijfers, en in milliseconden dertien. Tien cijfers blijven juist tot 2286. Beter dan een vuistregel is het veld zo noemen dat de eenheid niet verkeerd te lezen is — expiresAtSeconds in plaats van expiresAt — of een RFC 3339-tekenreeks over de grens dragen en die bij aankomst parseren, wat zelfbeschrijvend is en een paar tientallen bytes kost.

Tijd opslaan zodat ze het overleeft

Sla het moment op, niet de weergave. Een moment is een punt op de tijdlijn en is volledig bepaald door een UTC-tijdstempel met genoeg breedte — een epochseconde van 64 bits, een telling van 64 bits in milliseconden, of een RFC 3339-tekenreeks die op Z eindigt. Een weergave is wat iemand op een bepaalde plek zou zien, en die hangt af van tijdzoneregels die overheden met een paar weken aankondiging veranderen. De weergave opslaan betekent een antwoord opslaan dat met terugwerkende kracht verkeerd kan worden.

Eén uitzondering verdient het benoemd te worden, want UTC opslaan wordt vaak als universeel advies verkocht. Een toekomstige afspraak op een genoemde plek is geen moment — het is een wandkloktijd in een rechtsgebied, en verzet dat rechtsgebied zijn klokken, dan verandert het juiste moment. Een vergadering om 09:00 in Berlijn volgende november hoort te worden opgeslagen als de lokale datum, de lokale tijd en de IANA-zonenaam, en pas tot een moment te worden herleid als dat nodig is. Sla UTC op voor dingen die gebeurd zijn, en lokale tijd plus een zonenaam voor dingen die gepland zijn.

Daarnaast nemen drie gewoonten de meeste resterende pijn weg. Geef elk tijdstempelveld een eenheid in zijn naam, zodat een lezer nooit tussen seconden en milliseconden hoeft te gokken. Gebruik overal een type van 64 bits, ook in de databasekolom, zodat 2038 een historische curiositeit is en geen deadline. En behandel een tijdstempel nooit als een unieke identificatie of als een monotoon volgnummer, want de behandeling van schrikkelseconden, klokcorrecties en migraties van virtuele machines kunnen alle dezelfde waarde twee keer laten verschijnen of de tijd even achteruit laten lopen.

Tijdweergaven en hun grenzen, elk grensmoment doorgerekend in plaats van aangehaald
WeergaveEenheidVroegsteLaatsteWaar je hem nog tegenkomt
time_t van 32 bits met tekenSeconden1901-12-13T20:45:52Z2038-01-19T03:14:07ZIngebedde 32-bitsdoelen, int32-kolommen, binaire records met vaste breedte
Teller van 32 bits zonder tekenSeconden1970-01-01T00:00:00Z2106-02-07T06:28:15ZNoodgrepen in firmware; data van vóór 1970 onmogelijk
time_t van 64 bits met tekenSecondenOngeveer 292 miljard jaar voor 1970Jaar 292.277.026.596 (2^63 − 1 seconden)Elke huidige 64-bitsbuild van Linux, macOS en Windows
Date van JavaScriptMilliseconden (float64)−271821-04-20+275760-09-13 (±8.640.000.000.000.000 ms)Browsers en Node; hebben nooit een probleem met 2038 gehad
TIMESTAMP van MySQLSeconden1970-01-01 00:00:01 UTC2038-01-19 03:14:07 UTCZeer breed uitgerold; DATETIME is het alternatief dat niet is geraakt
RFC 3339-tekenreeksTekst, zelfbeschrijvendGeen ondergrens in het formaatGeen bovengrens in het formaatAPI's en logs; kost bytes, haalt de dubbelzinnigheid tussen seconden en milliseconden weg
Unix-tijdomzetterReken een Unix-tijdstempel (seconden of milliseconden) om naar een leesbare datum en terug, met het huidige tijdstempel live.Probeer de tool →
Advertentie

Veelgestelde vragen

Staat een Unix-tijdstempel in UTC, of in mijn lokale tijdzone?
Strikt genomen in geen van beide, en dat is de nuttige manier om erover te denken. Een Unix-tijdstempel duidt een punt op de tijdlijn aan. Het draagt helemaal geen tijdzone, want dat is niet nodig — het getal 1786752000 verwijst overal op aarde naar hetzelfde moment. Wat wel waar is, is dat het omzetten naar een leesbare datum een zone vraagt, en dat de epoch zelf op 1970-01-01T00:00:00 UTC is vastgelegd, dus geeft omzetten zonder opgegeven zone je UTC. Daarom is een tijdstempel het juiste ding om op te slaan en te versturen en het verkeerde ding om weer te geven: de opslaglaag heeft een ondubbelzinnig moment nodig, en de weergavelaag een zone, een taalregio en een kalender. De gebruikelijke fout is ergens midden in een pijplijn naar lokale tijd omzetten en het resultaat dan opslaan, waarmee de zone van één machine wordt ingebakken en elke waarde stilletjes met haar verschuiving opschuift. Zet één keer om, op het laatst mogelijke moment, in de gebruikersinterface.
Wat gebeurt er precies op 19 januari 2038 om 03:14:07?
In elk systeem dat het tijdstempel in een geheel getal van 32 bits met teken bewaart, bereikt de teller 2.147.483.647 en loopt de volgende verhoging over. Nagedaan in een echt 32-bitsslot met teken: 2.147.483.648 opslaan leest terug als −2.147.483.648, wat omzet naar 1901-12-13T20:45:52Z. Het gedrag is geen uitzondering en geen crash; de waarde wordt simpelweg een datum 136 jaar in het verleden en wordt gebruikt. Wat dat veroorzaakt, hangt af van de code erboven. Sorteringen keren om. Berekeningen van leeftijd en duur worden enorm negatief. Certificaten en sessies lijken lang geleden te zijn verlopen, of nooit te verlopen. Planners in cron-stijl gaan of continu af of stoppen. Records landen in de verkeerde partitie. De reden dat het gevaarlijk is, is juist dat niets een foutmelding geeft: elke laag krijgt een goed gevormd getal en gedraagt zich correct voor het getal dat ze kreeg. Dat is ook de reden dat testen eenvoudig is — zet vandaag een veld op 2147483648 en lees het terug, in plaats van op de datum te wachten.
Mijn servers zijn 64 bits. Ben ik veilig voor het probleem van 2038?
Je besturingssysteem is dat, en je applicatie misschien niet. Op een moderne 64-bitsmachine is sizeof(time_t) 8 bytes — hier nagekeken — en drukt de shell voor de waarde 2147483648 Tue Jan 19 03:14:08 UTC 2038 af, zonder omslag. Maar de kernel is zelden waar de grens woont. De blootstelling zit in velden die jij hebt gekozen: een INTEGER- of int32-databasekolom met epochseconden, een protocol- of bestandsformaat met een vast tijdstempelveld van 32 bits, een struct gecompileerd voor een ingebed 32-bitsdoel, een binair record met vaste breedte dat jaren geleden is geschreven. Het kolomtype TIMESTAMP van MySQL is een gedocumenteerd voorbeeld, gespecificeerd tot 2038-01-19 03:14:07 UTC, ongeacht hoeveel bits de server heeft, terwijl het type DATETIME niet is geraakt. Een tweede, minder duidelijke blootstelling is elk apparaat van derden in het machinepark — printers, camera's, regelaars, sensoren — waarvan de firmware met opzet 32 bits is en misschien nooit meer wordt bijgewerkt. De audit is het nu waard en niet in 2037, want de storingen beginnen bij waarden met een datum in de toekomst, en 2026 zit al binnen het venster van elfenhalf jaar.
Hoe weet ik of een getal seconden of milliseconden is?
Tel de cijfers. Een tijdstempel van vandaag in seconden heeft tien cijfers en houdt er tien tot 2286; hetzelfde moment in milliseconden heeft dertien. Voor 2026-08-15T00:00:00Z zijn de twee waarden 1786752000 en 1786752000000. Weet je het niet zeker, zet dan om en kijk naar het resultaat, want beide fouten leveren iets duidelijk absurds op: de waarde in seconden als milliseconden lezen geeft 1970-01-21T16:19:12Z, drie weken na de epoch, en de waarde in milliseconden als seconden lezen geeft het jaar 58589. Een datum in januari 1970 of in de verre toekomst is bijna altijd deze fout en geen slechte data. De duurzame oplossing is niet opsporen maar benoemen. Noem het veld expiresAtSeconds of createdAtMillis zodat de eenheid met de waarde meereist, of stuur een RFC 3339-tekenreeks als 2026-08-15T00:00:00Z over servicegrenzen — die is zelfbeschrijvend, sorteert als tekst correct, overleeft het in een log te worden geplakt, en kost ongeveer twintig bytes.
Betekenen schrikkelseconden dat mijn berekeningen van duur verkeerd zijn?
Technisch ja, en in de praktijk bijna nooit genoeg om ter zake te doen. Twee Unix-tijdstempels van elkaar aftrekken geeft het verschil in de teller, en dat laat elke schrikkelseconde ertussen weg. Over de schrikkelseconde van 2016 heen zegt de teller dat er tussen 2016-12-31T00:00:00Z en 2017-01-01T00:00:00Z 86.400 seconden zijn verstreken, terwijl er werkelijk 86.401 SI-seconden zijn verstreken. Omdat er ooit maar zevenentwintig schrikkelseconden zijn ingelast, is de grootst mogelijke fout op een duur die de hele periode sinds 1972 overspant zevenentwintig seconden — irrelevant voor facturatie, sessieduur, cacheverval, responslatentie op het niveau van milliseconden, of wat een bedrijf ook maar meet. Ze wordt relevant bij satellietafstandsmeting, natuurkunde met hoge precisie en financiële ordening onder de seconde, en die vakgebieden gebruiken TAI of GPS-tijd, die helemaal geen schrikkelseconden kennen. Er is wel een veel groter praktisch gevaar dan schrikkelseconden: verstreken tijd met de wandklok meten. NTP-correcties, migraties van virtuele machines en handmatige klokwijzigingen kunnen een wandklok veel meer dan een seconde vooruit of achteruit zetten. Gebruik voor het meten van duur een monotone klok — die je taal blootstelt als iets als performance.now of een steady clock — en houd tijdstempels van de wandklok voor het vastleggen van wanneer iets gebeurde.
Moet ik tijdstempels in UTC opslaan, of met een tijdzone?
Dat hangt ervan af of je iets vastlegt wat is gebeurd of iets plant wat gaat gebeuren. Voor alles in het verleden — een logregel, een order, een betaling, een auditrecord — sla het moment in UTC op en zet alleen bij het weergeven om. Het moment is een feit en verandert nooit; hoe het in de lokale tijd van een gebruiker wordt weergegeven, is een weergavekwestie die op elk moment opnieuw kan worden berekend. Voor alles wat in de toekomst is gepland, is UTC de verkeerde keuze, en dit is het geval dat het vaakst verkeerd gaat. Een vergadering om 09:00 in Berlijn volgende november is geen moment — het is een wandkloktijd in een rechtsgebied. Verandert Duitsland tussen nu en dan zijn klokregels, dan verschuift het juiste moment, en een UTC-waarde die je vandaag hebt opgeslagen zou een afspraak op het verkeerde lokale uur worden. Sla de lokale datum, de lokale tijd en de IANA-zonenaam als Europe/Berlin op, en herleid pas tot een moment wanneer je er een nodig hebt. Overheden veranderen zoneregels wel degelijk, meestal met een paar weken aankondiging, en de tz-database wordt een paar keer per jaar bijgewerkt om ze te volgen.

Artikelen die je misschien interesseren

Alle gidsen →

Vergelijkbare tools

Bronnen

Een fout in dit artikel gezien?