java.time.temporal.ChronoUnit#MILLIS源码实例Demo

public static ChronoUnit chronoUnit(TimeUnit unit) {
    switch (unit) {
        case NANOSECONDS:
            return ChronoUnit.NANOS;
        case MICROSECONDS:
            return ChronoUnit.MICROS;
        case MILLISECONDS:
            return ChronoUnit.MILLIS;
        case SECONDS:
            return ChronoUnit.SECONDS;
        case MINUTES:
            return ChronoUnit.MINUTES;
        case HOURS:
            return ChronoUnit.HOURS;
        case DAYS:
            return ChronoUnit.DAYS;
        default:
            throw new IllegalArgumentException("Cannot convert timeunit");
    }
}
 

public static TemporalUnit convertToJavaTimeUnit(org.ehcache.xml.model.TimeUnit unit) {
  switch (unit) {
    case NANOS:
      return ChronoUnit.NANOS;
    case MICROS:
      return ChronoUnit.MICROS;
    case MILLIS:
      return ChronoUnit.MILLIS;
    case SECONDS:
      return ChronoUnit.SECONDS;
    case MINUTES:
      return ChronoUnit.MINUTES;
    case HOURS:
      return ChronoUnit.HOURS;
    case DAYS:
      return ChronoUnit.DAYS;
    default:
      throw new IllegalArgumentException("Unknown time unit: " + unit);
  }
}
 

public static TemporalUnit jucTimeUnitToTemporalUnit(TimeUnit timeUnit) {
  switch (timeUnit) {
    case NANOSECONDS:
      return ChronoUnit.NANOS;
    case MICROSECONDS:
      return ChronoUnit.MICROS;
    case MILLISECONDS:
      return ChronoUnit.MILLIS;
    case SECONDS:
      return ChronoUnit.SECONDS;
    case MINUTES:
      return ChronoUnit.MINUTES;
    case HOURS:
      return ChronoUnit.HOURS;
    case DAYS:
      return ChronoUnit.DAYS;
    default:
      throw new AssertionError("Unkown TimeUnit: " + timeUnit);
  }
}
 

private static ChronoUnit toChronoUnit(TimeUnit unit) { 
    Objects.requireNonNull(unit, "unit"); 
    switch (unit) { 
        case NANOSECONDS: 
            return ChronoUnit.NANOS; 
        case MICROSECONDS: 
            return ChronoUnit.MICROS; 
        case MILLISECONDS: 
            return ChronoUnit.MILLIS; 
        case SECONDS: 
            return ChronoUnit.SECONDS; 
        case MINUTES: 
            return ChronoUnit.MINUTES; 
        case HOURS: 
            return ChronoUnit.HOURS; 
        case DAYS: 
            return ChronoUnit.DAYS; 
        default: 
            throw new IllegalArgumentException("Unknown TimeUnit constant"); 
    } 
}
 

@Override
@Bulkhead(waitingTaskQueue = 5, value = 5)
@Retry(delay = 1, delayUnit = ChronoUnit.MILLIS, maxRetries = 10, maxDuration=999999)
public Future test(BackendTestDelegate action) throws InterruptedException {
    Utils.log("in business method of bean " + this.getClass().getName());
    return action.perform();
}
 

@Asynchronous
@Fallback(fallbackMethod = "fallback")
@Timeout(value = 20L, unit = ChronoUnit.MILLIS)
@Retry(delay = 10L, maxRetries = 2)
public CompletionStage<String> faultTolerance() {
    tracer.buildSpan("ft").start().finish();
    throw new RuntimeException();
}
 

public DateWrapper(final int year, final Month month, final int dayOfMonth, final int hour, final int minute,
		final int second, final int millis) {
	wrapped = ZonedDateTime
			.of(
					LocalDateTime.of(year, month, dayOfMonth, hour, minute, second, millis * 1000000),
						ZoneId.systemDefault())
				.toInstant();
	accuracy = ChronoUnit.MILLIS;
}
 

public PyramidPlunderTimer(
	Duration duration,
	BufferedImage image,
	PyramidPlunderPlugin plugin,
	PyramidPlunderConfig config,
	Client client
)
{
	super(duration.toMillis(), ChronoUnit.MILLIS, image, plugin);
	this.config = config;
	this.client = client;
}
 

@DataProvider(name="BadTemporalUnit")
Object[][] data_badTemporalUnit() {
    return new Object[][] {
        {ChronoUnit.MICROS},
        {ChronoUnit.MILLIS},
        {ChronoUnit.HALF_DAYS},
        {ChronoUnit.DECADES},
        {ChronoUnit.CENTURIES},
        {ChronoUnit.MILLENNIA},
    };
}
 

@DataProvider(name="BadTemporalUnit")
Object[][] data_badTemporalUnit() {
    return new Object[][] {
        {ChronoUnit.MICROS},
        {ChronoUnit.MILLIS},
        {ChronoUnit.HALF_DAYS},
        {ChronoUnit.DECADES},
        {ChronoUnit.CENTURIES},
        {ChronoUnit.MILLENNIA},
    };
}
 

static Duration getDuration(String time) {
    String value = time.trim();
    TemporalUnit temporalUnit = ChronoUnit.MILLIS;
    long timeVal = 0;
    for (TimeUnit timeUnit : values()) {
        for (String suffix : timeUnit.descriptions) {
            if (value.endsWith(suffix)) {
                temporalUnit = timeUnit.timeUnit;
                timeVal = Long.parseLong(value.substring(0, value.length() - suffix.length()));
            }
        }
    }
    return Duration.of(timeVal, temporalUnit);
}
 

@DataProvider(name="BadTemporalUnit")
Object[][] data_badTemporalUnit() {
    return new Object[][] {
        {ChronoUnit.MICROS},
        {ChronoUnit.MILLIS},
        {ChronoUnit.HALF_DAYS},
        {ChronoUnit.DECADES},
        {ChronoUnit.CENTURIES},
        {ChronoUnit.MILLENNIA},
    };
}
 

@DataProvider(name="BadTemporalUnit")
Object[][] data_badTemporalUnit() {
    return new Object[][] {
        {ChronoUnit.MICROS},
        {ChronoUnit.MILLIS},
        {ChronoUnit.HALF_DAYS},
        {ChronoUnit.DECADES},
        {ChronoUnit.CENTURIES},
        {ChronoUnit.MILLENNIA},
    };
}
 

AggressionTimer(final Duration duration, final BufferedImage image, final Plugin plugin, final boolean visible)
{
	super(duration.toMillis(), ChronoUnit.MILLIS, image, plugin);
	setTooltip("Time until NPCs become unaggressive");
	this.visible = visible;
}
 

TimerTimer(GameTimer timer, Duration duration, Plugin plugin)
{
	super(duration.toMillis(), ChronoUnit.MILLIS, null, plugin);
	this.timer = timer;
	setPriority(InfoBoxPriority.MED);
}
 

RespawnTimer(Boss boss, BufferedImage bossImage, Plugin plugin)
{
	super(boss.getSpawnTime().toMillis(), ChronoUnit.MILLIS, bossImage, plugin);
	this.boss = boss;
}
 

@Override
public ChronoUnit jitterDelayUnit() {
    return ChronoUnit.MILLIS;
}
 

@Timeout(value = 1, unit = ChronoUnit.MILLIS)
public void serviceValue() throws InterruptedException {
    Thread.sleep(TimeUnit.MINUTES.toMillis(1));
}
 

@Test
public final void whenMillisecondsTotalComputedResultCorrect() {
    TimePeriod millis = new TimePeriod(ChronoUnit.MILLIS, 480);
    assertThat(millis.totalSeconds(), is(equalTo(0.48)));
}
 

@Test
void millis() {

    TimeInterval interval = new TimeInterval(3L, ChronoUnit.MILLIS);

    Assertions.assertThat(interval.toString()).isEqualTo("3ms");
}