任何与时间戳一起使用的高性能java库？

Question

我正在寻找高性能的 Java 库，它提供的方法可以让我获得：

1. 当前时间 (0-24)
2. 当天 (1-31)
3. 本周 (1-52)
4. 当月 (1-12)
5. 当前赛季 (1-4)
6. 当年（YYYY 或 YY）

性能对我来说是最重要的问题。这就是为什么我不能使用标准日历类。最好的解决方案是在不创建新对象的情况下完成所有计算。

添加：为了澄清，我再提一次：每秒超过 100000 次操作。

Answer 1

您实际上可以使用出色的 joda-time 库来执行此操作。 joda 中的 Chronology 实现提供了 DateTime getHour getDay 类型方法背后的逻辑。如果您想跳过创建DateTime 瞬间，直接使用它没有问题。

long msSinceEpoch = System.currentTimeMillis();

Chronology chronology = ISOChronology.getInstanceUTC() // This can be static

chronology.hourOfDay().get(msSinceEpoch);
chronology.dayOfMonth().get(msSinceEpoch);
chronology.weekOfWeek().get(msSinceEpoch);
chronology.monthOfYear().get(msSinceEpoch);
chronology.years().get(msSinceEpoch);

会话不是 joda 的概念。根据您自己的规则，您必须从该月开始计算。

见joda-time documentation on Chronology

Answer 2

您确定Calendar 太慢还是您只是相信？您测量了吗？

在 Java 中创建新对象非常便宜。保留它们很昂贵。

也就是说，要么尝试 Joda Time，要么将 Java 代码中的算法复制到静态辅助方法中。

Answer 3

您可以获取当前时间并通过除法和余数计算当前小时、分钟、秒、毫秒。日、月、年每天只变化一次，所以你只需要在变化时计算。

您可以使用缓存的日/月/年并在亚微秒时间内计算其余部分，而无需创建对象（每天超过一次）

import java.util.Calendar;
import java.util.TimeZone;

public class Daytime {
    private static final long HOUR_MS = 3600*1000;

    public short year;
    public byte month, day;
    public byte hour, min, sec;
    public short millis;

    private long lastMillis = Integer.MIN_VALUE;
    private final TimeZone timeZone;
    private long timeOffset;

    public Daytime() {
        timeZone = TimeZone.getTimeZone("UTC");
        now();
    }

    public Daytime(TimeZone timeZone) {
        this.timeZone = timeZone;
        now();
    }

    public void now() {
        long now = System.currentTimeMillis() + timeOffset;
        if (now == lastMillis) return;
        long cachePeriod = now/HOUR_MS;
        // could the day have changed?
        if (cachePeriod != lastMillis/HOUR_MS) {
            timeOffset = timeZone.getOffset(now);
            Calendar cal = Calendar.getInstance(timeZone);
            year = (short) cal.get(Calendar.YEAR);
            month = (byte) cal.get(Calendar.MONTH);
            day = (byte) cal.get(Calendar.DAY_OF_MONTH);
            hour = (byte) cal.get(Calendar.HOUR);
        }
        millis = (short) (now % 1000);
        now /= 1000;
        sec = (byte) (now % 60);
        now /= 60;
        min = (byte) (now % 60);
    }

    public static void main(String... args) {
        Daytime dt = new Daytime();
        long start = System.nanoTime();
        final int runs = 10 * 1000 * 1000;
        for(int i=0;i< runs;i++)
            dt.now();
        long time = System.nanoTime() - start;
        System.out.printf("Daytime.now() took %.3f micro-seconds on average%n", time/1e3/runs);
    }
}

打印

Daytime.now() took 0.287 micro-seconds on average

关于夏令时更改的发生方式有多种假设。您可能需要更改检查周期以满足您的需要。

Answer 4

只使用一个对象并像这样更新它：

Date d = new Date();
...
d.setTime(System.currentTimeMillis());

Answer 5

您可以使用java.util.Calander，如果对此不满意，您可以使用Joda Time。

这可以帮助你。

Answer 6

您可以使用Joda Time，因为它比日历快得多，然后这样做：

LocalDateTime now = new LocalDateTime(); // automatically points to current datetime.
int hour = now.getHourOfDay();
int day = now.getDayOfMonth();
int week = now.getWeekOfWeekyear();
int month = now.getMonthOfYear();
int year = now.getYear();
int season = getSeason(day, month);

getSeason() 很容易实现。没有任何解决方案可以在不创建任何对象的情况下完成所有这些操作。对了，你为什么需要这么多性能？！？！

Answer 7

请注意，Calendar.getInstance 非常昂贵，但您通常可以通过调用该方法一次并重用来获取您的 Calendar 对象（除非您需要为每个线程提供日历：日历不是线程安全的）。

Answer 8

我已经在 SO 上阅读了很多关于 Joda Time 的帖子，现在我终于下载并试了一下。

Gareth Davis 的回答已经被接受，我对此没有异议。但我很想知道 Joda Time 的不同之处在哪里。

根据问题和接受的答案，我做了一个类来比较JDK Calendar和Joda Time Chronology的执行时间。

我发现 Calendar 实现始终运行得更快，而不是快两倍。

import java.util.Calendar;
import java.util.Date;

import org.joda.time.Chronology;
import org.joda.time.chrono.ISOChronology;


public class CalendarTest {

    private static final int ITERATIONS = 1000000;

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            jdkCalendar();
            jodaChronology();
        }
    }

    private static void jdkCalendar() {
        long start = System.currentTimeMillis();
        Calendar c = Calendar.getInstance();
        int hourOfDay = 0;
        int dayOfMonth = 0;
        int weekOfYear = 0;
        int month = 0;
        int year = 0;
        for (int i = 0; i < ITERATIONS; i++) {
            c.setTimeInMillis(System.currentTimeMillis());
            hourOfDay = c.get(Calendar.HOUR_OF_DAY);
            dayOfMonth = c.get(Calendar.DAY_OF_MONTH);
            weekOfYear = c.get(Calendar.WEEK_OF_YEAR);
            month = c.get(Calendar.MONTH);
            year = c.get(Calendar.YEAR);
        }
        long duration = System.currentTimeMillis() - start;
        System.err.printf("jdk:  duration %d, hourOfDay: %d, dayOfMonth: %d, weekOfYear: %d, month: %d, year: %d\n", duration, hourOfDay, dayOfMonth, weekOfYear, month, year);
    }

    private static void jodaChronology() {
        long start = System.currentTimeMillis();
        Chronology chronology = ISOChronology.getInstanceUTC(); // This can be static
        int hourOfDay = 0;
        int dayOfMonth = 0;
        int weekOfYear = 0;
        int month = 0;
        int year = 0;
        for (int i = 0; i < ITERATIONS; i++) {
            long msSinceEpoch = System.currentTimeMillis();
            hourOfDay = chronology.hourOfDay().get(msSinceEpoch);
            dayOfMonth = chronology.dayOfMonth().get(msSinceEpoch);
            weekOfYear = chronology.weekOfWeekyear().get(msSinceEpoch);
            month = chronology.monthOfYear().get(msSinceEpoch);
            year = chronology.years().getValue(msSinceEpoch);
        }
        long duration = System.currentTimeMillis() - start;
        System.err.printf("joda: duration %d, hourOfDay: %d, dayOfMonth: %d, weekOfYear: %d, month: %d, year: %d\n", duration, hourOfDay, dayOfMonth, weekOfYear, month, year);
    }

}

样本输出：

jdk:  duration 1714, hourOfDay: 12, dayOfMonth: 24, weekOfYear: 25, month: 5, year: 2011
joda: duration 2099, hourOfDay: 12, dayOfMonth: 24, weekOfYear: 25, month: 6, year: 41
jdk:  duration 377, hourOfDay: 12, dayOfMonth: 24, weekOfYear: 25, month: 5, year: 2011
joda: duration 689, hourOfDay: 12, dayOfMonth: 24, weekOfYear: 25, month: 6, year: 41
jdk:  duration 340, hourOfDay: 12, dayOfMonth: 24, weekOfYear: 25, month: 5, year: 2011
joda: duration 680, hourOfDay: 12, dayOfMonth: 24, weekOfYear: 25, month: 6, year: 41
jdk:  duration 330, hourOfDay: 12, dayOfMonth: 24, weekOfYear: 25, month: 5, year: 2011
joda: duration 653, hourOfDay: 12, dayOfMonth: 24, weekOfYear: 25, month: 6, year: 41
jdk:  duration 326, hourOfDay: 12, dayOfMonth: 24, weekOfYear: 25, month: 5, year: 2011
joda: duration 596, hourOfDay: 12, dayOfMonth: 24, weekOfYear: 25, month: 6, year: 41
jdk:  duration 337, hourOfDay: 12, dayOfMonth: 24, weekOfYear: 25, month: 5, year: 2011
joda: duration 620, hourOfDay: 12, dayOfMonth: 24, weekOfYear: 25, month: 6, year: 41
jdk:  duration 471, hourOfDay: 12, dayOfMonth: 24, weekOfYear: 25, month: 5, year: 2011
joda: duration 590, hourOfDay: 12, dayOfMonth: 24, weekOfYear: 25, month: 6, year: 41
jdk:  duration 326, hourOfDay: 12, dayOfMonth: 24, weekOfYear: 25, month: 5, year: 2011
joda: duration 591, hourOfDay: 12, dayOfMonth: 24, weekOfYear: 25, month: 6, year: 41
jdk:  duration 336, hourOfDay: 12, dayOfMonth: 24, weekOfYear: 25, month: 5, year: 2011
joda: duration 595, hourOfDay: 12, dayOfMonth: 24, weekOfYear: 25, month: 6, year: 41
jdk:  duration 327, hourOfDay: 12, dayOfMonth: 24, weekOfYear: 25, month: 5, year: 2011
joda: duration 560, hourOfDay: 12, dayOfMonth: 24, weekOfYear: 25, month: 6, year: 41

Answer 9

当您需要在每次调用字段的 getter 之前创建 DateTime 类的实例时，我会推荐 JodaTime。但是，当您调用 getter 方法而不是创建实例时，最好使用 JDK 8 中的 java.time 库，或向后移植 ThreeTenABP。

这是因为 JodaTime 的 DateTime 类自纪元开始以来仅存储 long iMillis，并且某些字段（如 minuteOfHour、dayOfMonth）的所有 getter 总是从头开始计算此值。但是ZonedDateTime of java.time 将此字段存储在单独的变量中，例如：int year, short month, short day,...
我创建了some benchmarks for comparision