So erhalten und verwenden Sie die Zeit im Linux-System

Es gibt zwei Arten von Linux-Systemzeiten.

(1) Kalenderzeit. Der Wert ist die kumulative Anzahl von Sekunden, die seit der angegebenen Zeit, 00:00:00, 1. Januar 1970, Koordinierte Weltzeit (UTC), vergangen sind. Grundlegende Datentypen werden mit time_t gespeichert. Schließlich können wir durch Umrechnung die 24-Stunden- oder 12-Stunden-Zeit erhalten, die wir normalerweise sehen.

(2) Bearbeitungszeit. Wird auch als CPU-Zeit bezeichnet und misst die von einem Prozess genutzten Ressourcen der Zentraleinheit. Die Prozesszeit wird in Taktimpulsen gemessen.

Dieser Artikel gibt Ihnen eine detaillierte Einführung zum Abrufen und Verwenden der Linux-Zeit. Werfen wir einen Blick auf die detaillierte Einführung.

Zeitstempel abrufen

Zeit()

#include <zeit.h>
Zeit_t Zeit(Zeit_t *calptr)

• time gibt den aktuellen Zeitstempel zurück, also die Anzahl der Sekunden von der Weltzeit bis jetzt;
• time_t ist eigentlich ein uint64_t;
• Wenn calptr nicht leer ist, wird der Zeitstempel auch in den Zeiger geschrieben;

Aufrufbeispiel:

#include <zeit.h>
#include <iostream>
#include <stdlib.h>

Namespace std verwenden;

int main()
{
Zeit_t aktuelle Zeit;
aktuelleZeit = Zeit(NULL);
cout << aktuelle Zeit << endl;
gebe 0 zurück;
}

Ergebnis:

Gibt eine Wertefolge zurück, beispielsweise 1533287924


gettimeofday() und clock_gettime()

Die Zeitfunktion kann die Zeit nur sekundengenau ermitteln. Um einen Zeitstempel mit höherer Genauigkeit zu erhalten, sind andere Funktionen erforderlich. Die Funktion gettimeofday kann einen Zeitstempel mit Mikrosekundenpräzision abrufen und in der Struktur timeval speichern; die Funktion clock_gettime kann einen Zeitstempel mit Nanosekundenpräzision abrufen und in der Struktur timespec speichern.

#include <sys/time.h>

int gettimeofday(Struktur timeval *tp, void *tzp);
Aus historischen Gründen ist der einzige gültige Wert für tzp NULL. Schreiben Sie beim Aufruf also einfach NULL.

int clock_gettime(clockid_t Uhr-ID, strcut Zeitspezifikation *tsp);
clock_id hat mehrere Optionen. Wenn CLOCK_REALTIME ausgewählt ist, ist die Funktion ähnlich wie bei time, aber die Zeitgenauigkeit ist höher.

Die von den beiden Funktionen verwendeten Strukturen sind wie folgt definiert:

Struktur timeval
{
long tv_sec; /*Sekunden*/
long tv_usec; ​​​​/*Mikrosekunden*/
};

Struktur Zeitspezifikation
{
time_t tv_sec; //Sekunden long tv_nsec; //Nanosekunden};

Aufrufbeispiel:

#include <zeit.h>
#include <sys/time.h>
#include <iostream>
#include <stdlib.h>

Namespace std verwenden;

int main()
{
Zeit_t dwCurTime1;
dwCurTime1 = Zeit(NULL);

Struktur timeval stCurTime2;
gettimeofday(&stCurTime2, NULL);

Struktur Zeitspezifikation stCurTime3;
clock_gettime(CLOCK_REALTIME, &stCurTime3);

cout << "Zeit1: " << dwCurTime1 << "s" << endl;
cout << "Zeit2: " << stCurTime2.tv_sec << "s, " << stCurTime2.tv_usec << "us" << endl;
cout << "Zeit3: " << stCurTime3.tv_sec << "s, " << stCurTime3.tv_nsec << "ns" << endl;

gebe 0 zurück;
}

Ergebnis:

Fügen Sie beim Kompilieren am Ende des Kompilierbefehls -lrt hinzu, um die dynamische Echtzeitbibliothek zu verknüpfen, z. B.
g++ -o time2 test_time_linux_2.cpp -lrt

Zeit1: 1533289490s
Zeit2: 1533289490s, 133547us
Zeit 3: 1533289490s, 133550060ns

Zeit visualisieren

TM-Struktur

Der erhaltene Zeitstempel kann die aktuelle Zeit nicht intuitiv anzeigen. Daher müssen wir die tm-Struktur verwenden, um die Zeit darzustellen, die wir im täglichen Leben sehen. Die Struktur ist wie folgt definiert:

Struktur tm
{
int tm_sec; /*Sekunden, normaler Bereich 0-59, aber bis zu 61 ist zulässig*/
int tm_min; /*Minute, 0-59*/
int tm_hour; /*Stunde, 0-23*/
int tm_mday; /*Tag, d. h. der Tag des Monats, 1-31*/
int tm_mon; /*Monat, beginnend im Januar, 0-11*/ 1+p->tm_mon;
int tm_year; /*Jahr, wie viele Jahre sind seit 1900 vergangen*/ 1900＋ p->tm_year;
int tm_wday; /*Woche, Wochentag, beginnend mit Sonntag, 0-6*/
int tm_yday; /*Die Anzahl der Tage vom 1. Januar dieses Jahres bis heute, im Bereich von 0 bis 365*/
int tm_isdst; /*Sommerzeit-Flag*/
};

Zeit_t in tm

gmtime und localtime können Zeitstempel vom Typ time_t in tm-Strukturen umwandeln. Die Verwendung ist wie folgt:

Struktur tm*gmtime(const time_t*timep);
//Konvertieren Sie die durch time_t dargestellte Zeit in UTC-Zeit ohne Zeitzonenkonvertierung. Dies ist ein Strukturzeiger vom Typ struct tm stuct tm* localtime(const time_t *timep);
//Ähnlich wie gmtime, aber es ist die Zeit nach der Zeitzonenumrechnung, d. h. sie kann in die Pekinger Zeit umgerechnet werden.

Druckzeit für festes Format

Nachdem Sie die tm-Struktur erhalten haben, können Sie sie für den täglichen Gebrauch in ein Zeichenfolgenformat konvertieren oder direkt von time_t konvertieren. Zu diesem Zweck können Sie die folgenden beiden Funktionen verwenden. Diese beiden Funktionen können die Uhrzeit jedoch nur in einem festen Format drucken.

//Diese beiden Funktionen wurden als veraltet markiert. Versuchen Sie, die Funktionen zu verwenden, die später eingeführt werden. char *asctime(const struct tm* timeptr);
char *ctime(const time_t *timep);

Aufrufbeispiel:

#include <zeit.h>
#include <sys/time.h>
#include <iostream>
#include <stdlib.h>

Namespace std verwenden;

int main()
{
Zeit_t dwCurTime1;
dwCurTime1 = Zeit(NULL);

Struktur tm* pTime;
pTime = Ortszeit(&dwCurTime1);

char*strTime1;
char*strTime2;
strTime1 = asctime(pTime);
strTime2 = ctime(&dwCurTime1);

cout << strZeit1 << endl;
cout << strTime2 << endl;

gebe 0 zurück;
}

Ergebnis:

Fr., 3. August 2018, 18:24:29 Uhr
Fr., 3. August 2018, 18:24:29 Uhr

Flexible und sichere Zeitumrechnungsfunktion strftime()

Die beiden oben genannten Funktionen sind aufgrund möglicher Pufferüberlaufprobleme als veraltet gekennzeichnet. Daher ist die Verwendung der strftime-Methode eine sicherere Methode.

/*
** @buf: Ausgabezeit speichern ** @maxsize: Maximale Bytelänge des Puffers ** @format: Das Format der Ausgabezeit angeben ** @tmptr: Zeiger auf Struktur tm*/
size_t strftime(char*puffer, size_t maxgröße, const char*format, const struct tm*tmptr);

Wir können die in timeptr gespeicherten Zeitinformationen gemäß dem durch format angegebenen Format in buf ausgeben, entsprechend dem Format in der durch format gezeigten Zeichenfolge, und im Puffer buf höchstens Zeichen der maximalen Zeichengröße speichern. Diese Funktion gibt die Anzahl der Zeichen zurück, die in der Zeichenfolge eingefügt wurden, auf die buf zeigt.

Die Funktion strftime() funktioniert ähnlich wie sprintf(): Sie erkennt eine Reihe von Formatbefehlen, die mit einem Prozentzeichen (%) beginnen, und formatiert die Ausgabe in eine Zeichenfolge. Der Formatbefehl gibt die genaue Darstellung verschiedener Datums- und Zeitinformationen in der Zeichenfolge strDest an. Die anderen Zeichen des Formatstrings werden unverändert in den String eingefügt. Die Formatbefehle sind unten aufgeführt und beachten die Groß-/Kleinschreibung.

%a Abkürzung für den Wochentag
%A Vollständiger Name des Wochentags
%b Abkürzung für Monat
%B Vollständiger Name des Monats
%c Standard-Datums- und Uhrzeitzeichenfolge
%C Die letzten beiden Ziffern des Jahres
%d Der Tag des Monats in Dezimalschreibweise
%D Monat/Tag/Jahr
%e Tag des Monats als Dezimalzahl in einem zweistelligen Feld
%F Jahr-Monat-Tag
%g Letzte zwei Ziffern des Jahres, wobei das Jahr auf Wochenbasis
%G Jahr, mit wochenbasierten Jahren
%h abgekürzter Monatsname
%H Stunde im 24-Stunden-Format
%I Stunde im 12-Stunden-Format
%j Der Tag des Jahres in Dezimalschreibweise
%m Monat in Dezimalschreibweise
%M Minuten im Zehn-Stunden-Format
%n Zeilenumbruchzeichen
%p Das lokale Äquivalent von AM oder PM
%r 12 Stunden Zeit
%R zeigt Stunden und Minuten an: hh:mm
%S Dezimalsekunden
%t horizontales Tabulatorzeichen
%T zeigt Stunden, Minuten und Sekunden an: hh:mm:ss
%u Der Wochentag, wobei Montag der erste Tag ist (Werte von 0 bis 6, wobei Montag 0 ist)
%U Wochennummer des Jahres, mit Sonntag als erstem Tag (Werte von 0 bis 53)
%V Woche des Jahres, mit wochenbasiertem Jahr
%w Der Wochentag als Dezimalzahl (Werte von 0 bis 6, mit Sonntag als 0)
%W Wochennummer des Jahres, mit Montag als erstem Tag (Werte von 0 bis 53)
%x Standarddatumszeichenfolge
%X Standardzeitzeichenfolge
%y Dezimaljahr ohne Jahrhundert (Werte von 0 bis 99)
%Y Dezimaljahr mit Jahrhundert
%z, %Z Zeitzonenname. Wenn der Zeitzonenname nicht abgerufen werden kann, wird ein leeres Zeichen zurückgegeben.
%% Prozentzeichen

Aufrufbeispiel:

#include <zeit.h>
#include <sys/time.h>
#include <iostream>
#include <stdlib.h>

Namespace std verwenden;

int main()
{
Zeit_t dwCurTime1;
dwCurTime1 = Zeit(NULL);

Struktur tm* pTime;
pTime = Ortszeit(&dwCurTime1);

char Puffer[100];

strftime(buf, 100, "Zeit: %r, %a %b %d, %Y", pTime);

cout << Puffer << endl;

gebe 0 zurück;
}

Ergebnis:

Uhrzeit: 20:18:12 Uhr, Freitag, 3. August 2018

Graph der Beziehung zwischen Zeitfunktionen

Prozesszeit

Die Prozesszeit ist die Zeit, in der der Prozess die CPU nutzt, nachdem er erstellt wurde. Die Prozesszeit ist in die folgenden zwei Teile unterteilt:

• Benutzer-CPU-Zeit: Die Zeit, die die CPU im Benutzermodus verwendet.
• Kernel-CPU-Zeit: Die Zeit, die die CPU im Kernelmodus verwendet. Dies ist die Zeit, die zum Ausführen von Kernel-Aufrufen oder anderen speziellen Aufgaben benötigt wird.

Uhrfunktion

Die Uhrfunktion bietet eine einfache Schnittstelle zum Abrufen der Prozesszeit. Sie gibt einen Wert zurück, der die gesamte vom Prozess verwendete CPU-Zeit (einschließlich Benutzerzeit und Kernelzeit) beschreibt. Die Funktion ist wie folgt definiert:

#include <zeit.h>
clock_t Uhr (leer)
//wenn ein Fehler auftritt, returniere -1

Die Uhrfunktion gibt einen Wert in CLOCKS_PER_SEC-Einheiten zurück. Dividiert man den Rückgabewert durch diese Einheit, erhält man die Anzahl der Sekunden der Prozesszeit.

mal Funktion

Die times-Funktion ist ebenfalls eine Prozesszeitfunktion, die eine spezifischere Prozesszeitdarstellung hat. Die Funktionsdefinition lautet wie folgt:

#include <sys/times.h>
clock_t Zeiten (Struktur tms* buf);

Struktur tms{
Uhr_t tms_utime;
Uhr_t tms_stime;
Uhr_t tms_cutime;
Uhr_t tms_cstime;
};

Obwohl der Rückgabetyp der Times-Funktion immer noch clock_t ist, unterscheidet sich die Maßeinheit des Rückgabewerts von der der Clock-Funktion. Die Maßeinheit des Rückgabewertes der Times-Funktion kann über sysconf (SC_CLK_TCK) ermittelt werden.

Ein vollständiger Anwendungsfall im Linux System Programming Manual lautet wie folgt:

#include <zeit.h>
#include <sys/times.h>
#include <unistd.h>
#include <stdio.h>

statische void AnzeigeProzesszeit(const char*msg)
{
Struktur tms t;
clock_t Uhrzeit;
statischer langer ClockTick = 0;

wenn (Nachricht != NULL) 
{
printf("%s\n", msg);
}

wenn (clockTick == 0)
{
clockTick = sysconf(_SC_CLK_TCK);
wenn (UhrzeitTick < 0) return;
}

UhrZeit = Uhr();
printf("Uhr gibt %ld CLOCKS_PER_SEC (%.2f Sekunden)\n zurück", (lang)Uhrzeit, (doppelt)Uhrzeit/CLOCKS_PER_SEC);

mal(&t);
printf("Zeiten geben Benutzer-CPU zurück = %.2f; System-CPU = %.2f\n", (double)t.tms_utime / clockTick, (double)t.tms_stime / clockTick);
}

int main()
{
printf("CLOCKS_PER_SEC = %ld, sysconf(_SC_CLK_TCK) = %ld\n", (lang)CLOCKS_PER_SEC, sysconf(_SC_CLK_TCK));

AnzeigeProzessZeit("start:");
für (int i = 0; i < 1000000000; ++i)
{
getpid();
}
printf("\n");
AnzeigeProzessZeit("Ende:");

gebe 0 zurück;
}

siehe

[1] http://www.runoob.com/w3cnote/cpp-time_t.html

[2] Advanced Unix Programming Environment (3. Auflage)

[3] Unix System Programmierhandbuch

Zusammenfassen

Das Obige ist der vollständige Inhalt dieses Artikels. Ich hoffe, dass der Inhalt dieses Artikels einen gewissen Lernwert für Ihr Studium oder Ihre Arbeit hat. Wenn Sie Fragen haben, können Sie eine Nachricht hinterlassen. Vielen Dank für Ihre Unterstützung von 123WORDPRESS.COM.