Java Clock.systemUTC方法代码示例

import java.time.Clock; //导入方法依赖的package包/类
public void test_equals() {
    Clock a = Clock.systemUTC();
    Clock b = Clock.systemUTC();
    assertEquals(a.equals(a), true);
    assertEquals(a.equals(b), true);
    assertEquals(b.equals(a), true);
    assertEquals(b.equals(b), true);

    Clock c = Clock.system(PARIS);
    Clock d = Clock.system(PARIS);
    assertEquals(c.equals(c), true);
    assertEquals(c.equals(d), true);
    assertEquals(d.equals(c), true);
    assertEquals(d.equals(d), true);

    assertEquals(a.equals(c), false);
    assertEquals(c.equals(a), false);

    assertEquals(a.equals(null), false);
    assertEquals(a.equals("other type"), false);
    assertEquals(a.equals(Clock.fixed(Instant.now(), ZoneOffset.UTC)), false);
}
 

import java.time.Clock; //导入方法依赖的package包/类
private static void testCase03() {
    RedPacketsContext context = new RedPacketsContext();
    Random rand = new Random();
    final Clock clockStart = Clock.systemUTC();
    long start = clockStart.millis();

    for (int i = 0; i < 1000000; i++) {
        int totalMoney = rand.nextInt(200) + 1;
        int totalPeople = rand.nextInt(100) + 1;
        checkResult(totalMoney, totalPeople, context);
    }

    final Clock clockEnd = Clock.systemUTC();
    long end = clockEnd.millis();

    System.out.println((end-start)/1000 + " Seconds passed");

}
 

import java.time.Clock; //导入方法依赖的package包/类
public static void testClock() throws InterruptedException {
    //时钟提供给我们用于访问某个特定 时区的 瞬时时间、日期 和 时间的。  
    Clock c1 = Clock.systemUTC(); //系统默认UTC时钟（当前瞬时时间 System.currentTimeMillis()）  
    System.out.println(c1.millis()); //每次调用将返回当前瞬时时间（UTC）  
    Clock c2 = Clock.systemDefaultZone(); //系统默认时区时钟（当前瞬时时间）  
    Clock c31 = Clock.system(ZoneId.of("Europe/Paris")); //巴黎时区  
    System.out.println(c31.millis()); //每次调用将返回当前瞬时时间（UTC）  
    Clock c32 = Clock.system(ZoneId.of("Asia/Shanghai"));//上海时区  
    System.out.println(c32.millis());//每次调用将返回当前瞬时时间（UTC）  
    Clock c4 = Clock.fixed(Instant.now(), ZoneId.of("Asia/Shanghai"));//固定上海时区时钟  
    System.out.println(c4.millis());
    Thread.sleep(1000);
    System.out.println(c4.millis()); //不变 即时钟时钟在那一个点不动  
    Clock c5 = Clock.offset(c1, Duration.ofSeconds(2)); //相对于系统默认时钟两秒的时钟  
    System.out.println(c1.millis());
    System.out.println(c5.millis());
}
 

import java.time.Clock; //导入方法依赖的package包/类
ExpirationBasedCache()
{
    _cache = new ConcurrentHashMap<>();
    _clock = Clock.systemUTC();

    Timer timer = new Timer("cacheExpiration", true);
    timer.scheduleAtFixedRate(new TimerTask() {
        @Override
        public void run() {
            expireCacheEntries();
        }} , 60, 60);
}
 

import java.time.Clock; //导入方法依赖的package包/类
synchronized void initialize(String servers) {
    if (isInitialized.get()) {
        logger.warn("Already initialized");
        return;
    }

    try {
        Properties props = new Properties();
        props.put("bootstrap.servers", servers);
        props.put("group.id", groupId);
        props.put("key.deserializer", StringDeserializer.class.getName());
        props.put("value.deserializer", StringDeserializer.class.getName());
        props.put("heartbeat.interval.ms", "10000");
        props.put("session.timeout.ms", "20000");
        props.put("enable.auto.commit", Boolean.toString(enableAutoCommit));
        props.put("auto.offset.reset", offsetReset.toString().toLowerCase());
        realConsumer = new KafkaConsumer<>(props);

        List<String> topics = new ArrayList<String>();
        topics.add(topic);
        realConsumer.subscribe(topics, this);

        offsetCommitter = new OffsetCommitter(realConsumer, Clock.systemUTC());
        primaryExecutor = Executors.newSingleThreadExecutor();
        primaryExecutor.submit(this);
        isInitialized.set(true);
    } catch (Exception ex) {
        logger.error("Error building Kafka consumer", ex);
    }
}
 

import java.time.Clock; //导入方法依赖的package包/类
@Test
public void
givenReadingFromEmptyStorePosition_readsFromTheCache() throws Exception {
    underlyingEventStore.write(stream_1, singletonList(event_1));
    saveAllToCache(getCacheFile("cache.gz"));

    assertThat(readAllFromEmpty(cacheEventReader), hasSize(1));

    CacheEventReader newCacheEventReader = new CacheEventReader(new JavaInMemoryEventStore(Clock.systemUTC()), CODEC, cacheDirectory, "cache");
    assertThat(readAllFromEmpty(newCacheEventReader), hasSize(1));
    assertThat(readAllFromEmpty(newCacheEventReader), equalTo(readAllToList(underlyingEventStore)));
}
 

import java.time.Clock; //导入方法依赖的package包/类
public static void testInstant() {
    //瞬时时间 相当于以前的System.currentTimeMillis()  
    Instant instant1 = Instant.now();
    System.out.println(instant1.getEpochSecond());//精确到秒 得到相对于1970-01-01 00:00:00 UTC的一个时间  
    System.out.println(instant1.toEpochMilli()); //精确到毫秒  
    Clock clock1 = Clock.systemUTC(); //获取系统UTC默认时钟  
    Instant instant2 = Instant.now(clock1);//得到时钟的瞬时时间  
    System.out.println(instant2.toEpochMilli());
    Clock clock2 = Clock.fixed(instant1, ZoneId.systemDefault()); //固定瞬时时间时钟  
    Instant instant3 = Instant.now(clock2);//得到时钟的瞬时时间  
    System.out.println(instant3.toEpochMilli());//equals instant1  
}
 

import java.time.Clock; //导入方法依赖的package包/类
/**
 * Tests the constructor sets things appropriately.
 */
@Test
public void testConstructor() {
    // Define inputs
    final MessageBus messageBus = new MessageBus(new FifoBuffer());
    final Map<VirtualSpoutIdentifier, Queue<MessageId>> ackQueue = Maps.newConcurrentMap();
    final Map<VirtualSpoutIdentifier, Queue<MessageId>> failQueue = Maps.newConcurrentMap();
    final Clock clock = Clock.systemUTC();

    // Define some config params
    final long consumerStateFlushInterval = 200L;

    // Create our spout delegate
    final DelegateSpout spout = mock(DelegateSpout.class);

    // Create config
    final Map<String, Object> topologyConfig = getDefaultConfig(consumerStateFlushInterval);

    // Create instance.
    SpoutRunner spoutRunner = new SpoutRunner(
        spout,
        messageBus,
        clock,
        topologyConfig
    );

    // Call getters and validate!
    assertEquals("Clock instance is what we expect", clock, spoutRunner.getClock());
    assertEquals("TopologyConfig looks legit", topologyConfig, spoutRunner.getTopologyConfig());
    assertEquals(
        "getConsumerStateFlushIntervalMs() returns right value",
        consumerStateFlushInterval,
        spoutRunner.getConsumerStateFlushIntervalMs()
    );

    assertNotNull("StartTime is null", spoutRunner.getStartTime());
    assertNotEquals("StartTime is not zero", 0, spoutRunner.getStartTime());
    assertEquals("Spout delegate got set", spout, spoutRunner.getSpout());
}
 

import java.time.Clock; //导入方法依赖的package包/类
public void test_instant() {
    Clock system = Clock.systemUTC();
    assertEquals(system.getZone(), ZoneOffset.UTC);
    for (int i = 0; i < 10000; i++) {
        // assume can eventually get these within 10 milliseconds
        Instant instant = system.instant();
        long systemMillis = System.currentTimeMillis();
        if (systemMillis - instant.toEpochMilli() < 10) {
            return;  // success
        }
    }
    fail();
}
 

import java.time.Clock; //导入方法依赖的package包/类
@Override
public Job newJob(TriggerFiredBundle bundle, Scheduler scheduler) throws SchedulerException {

    JobDetail jobDetail = bundle.getJobDetail();
    MetricRegistry metricRegistry = autowireCapableBeanFactory.getBean(MetricRegistry.class);
    HistorianDAO historianDAO = autowireCapableBeanFactory.getBean(HistorianDAO.class);
    AfterDAO afterDAO = autowireCapableBeanFactory.getBean(AfterDAO.class);

    try {
        return new TriggerAwareLoggingJob(
                new HistorianJob(
                        new TimedJob(
                                new ErrorHandlingJob(
                                        (Job) autowireCapableBeanFactory.autowire(jobDetail.getJobClass(),
                                                AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR, false)
                                ),
                                metricRegistry
                        ),
                        Clock.systemUTC(),
                        scheduler.getSchedulerName(),
                        scheduler.getSchedulerInstanceId(),
                        historianDAO,
                        afterDAO
                )
        );
    } catch (Exception e) {
        throw new SchedulerException(
                "Problem instantiating class '"
                        + jobDetail.getJobClass().getName() + "'", e);
    }
}
 

import java.time.Clock; //导入方法依赖的package包/类
public void test_millis() {
    Clock system = Clock.systemUTC();
    assertEquals(system.getZone(), ZoneOffset.UTC);
    for (int i = 0; i < 10000; i++) {
        // assume can eventually get these within 10 milliseconds
        long instant = system.millis();
        long systemMillis = System.currentTimeMillis();
        if (systemMillis - instant < 10) {
            return;  // success
        }
    }
    fail();
}
 

import java.time.Clock; //导入方法依赖的package包/类
public TokenlessClientLogger(Service<HttpRequest, HttpResponse> delegate) {
    this(delegate, Clock.systemUTC());
}
 

import java.time.Clock; //导入方法依赖的package包/类
public void test_withZone_fromUTC() {
    Clock test = Clock.systemUTC();
    Clock changed = test.withZone(PARIS);
    assertEquals(changed.getZone(), PARIS);
}
 

import java.time.Clock; //导入方法依赖的package包/类
public TradingHoursServiceImpl() {
    this.clock = Clock.systemUTC();
}
 

import java.time.Clock; //导入方法依赖的package包/类
/**
 * Tests that
 *   - our latch counts down when we start the thread.
 *   - open() is called on the spout on startup.
 *   - close() is called on the spout on shutdown.
 *   - spoutRunner.requestStop() shuts down the instance.
 *   - spoutDelegate.requestStop() shuts down the instance.
 */
@Test
@UseDataProvider("provideTrueAndFalse")
public void testOpenandCloseOnSpoutIsCalled(final boolean shutdownViaSpout) throws InterruptedException {
    // Define inputs
    final Clock clock = Clock.systemUTC();
    final DefaultVirtualSpoutIdentifier virtualSpoutId = new DefaultVirtualSpoutIdentifier("MyVirtualSpoutId");

    // Define some config params
    final long consumerStateFlushInterval = TimeUnit.MILLISECONDS.convert(maxWaitTime, TimeUnit.SECONDS);

    // Create our spout delegate
    final MockDelegateSpout mockSpout = new MockDelegateSpout(virtualSpoutId);

    // Setup mock MessageBus
    final VirtualSpoutMessageBus messageBus = mock(VirtualSpoutMessageBus.class);
    when(messageBus.getAckedMessage(eq(virtualSpoutId))).thenReturn(null);
    when(messageBus.getFailedMessage(eq(virtualSpoutId))).thenReturn(null);

    // Create config
    final Map<String, Object> topologyConfig = getDefaultConfig(consumerStateFlushInterval);

    // Create instance.
    SpoutRunner spoutRunner = new SpoutRunner(
        mockSpout,
        messageBus,
        clock,
        topologyConfig
    );

    // Start in a separate thread.
    final CompletableFuture future = startSpoutRunner(spoutRunner);

    // Wait for open to be called since it runs async.
    await()
        .atMost(maxWaitTime, TimeUnit.SECONDS)
        .until(() -> mockSpout.wasOpenCalled, equalTo(true));

    // Verify open was called once, but not close
    assertTrue("Open was called on our mock spout", mockSpout.wasOpenCalled);
    assertFalse("Close has not been called yet on our mock spout", mockSpout.wasCloseCalled);

    // Verify queues got setup
    verify(messageBus, times(1)).registerVirtualSpout(eq(virtualSpoutId));

    // But not torn down yet
    verify(messageBus, never()).unregisterVirtualSpout(anyObject());

    // Shut down
    if (shutdownViaSpout) {
        logger.info("Requesting stop via Spout.isCompleted()");
        mockSpout.completed = true;
    } else {
        logger.info("Requesting stop via SpoutRunner.requestStop()");
        spoutRunner.requestStop();
    }

    // Wait for thread to stop.
    await()
        .atMost(maxWaitTime * 2, TimeUnit.SECONDS)
        .until(future::isDone);

    // Make sure it actually stopped
    assertEquals("Should have no running threads", 0, executorService.getActiveCount());

    // verify close was called
    assertTrue("Close was called on our mock spout", mockSpout.wasCloseCalled);

    // Verify entries removed from buffer, ackQueue, failQueue
    verify(messageBus, times(1)).unregisterVirtualSpout(eq(virtualSpoutId));
}