TimeUnit - [ Java参考文档 ] - 在线原生手册

目录搜索

文字

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM 2 Platform
Standard Ed. 6

上一个下一个

框架 无框架

类 java.util.concurrent.TimeUnit
的使用

使用 TimeUnit 的软件包
java.util.concurrent	在并发编程中很常用的实用工具类。
java.util.concurrent.locks	为锁和等待条件提供一个框架的接口和类，它不同于内置同步和监视器。
javax.swing	提供一组“轻量级”（全部是 Java 语言）组件，尽量让这些组件在所有平台上的工作方式都相同。

java.util.concurrent 中 TimeUnit 的使用

返回 TimeUnit 的 java.util.concurrent 中的方法
`static TimeUnit`	`TimeUnit.valueOf(String name)` 返回带有指定名称的该类型的枚举常量。
`static TimeUnit[]`	`TimeUnit.values()` Returns an array containing the constants of this enum type, in the order they are declared.

参数类型为 TimeUnit 的 java.util.concurrent 中的方法

boolean CountDownLatch.await(long timeout, TimeUnit unit)
使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断或超出了指定的等待时间。

int CyclicBarrier.await(long timeout, TimeUnit unit)
在所有参与者都已经在此屏障上调用 await 方法之前将一直等待,或者超出了指定的等待时间。

boolean ExecutorService.awaitTermination(long timeout, TimeUnit unit)
请求关闭、发生超时或者当前线程中断，无论哪一个首先发生之后，都将导致阻塞，直到所有任务完成执行。

boolean ThreadPoolExecutor.awaitTermination(long timeout, TimeUnit unit)

long TimeUnit.convert(long sourceDuration, TimeUnit sourceUnit)
将给定单元的时间段转换到此单元。

V Exchanger.exchange(V x, long timeout, TimeUnit unit)
等待另一个线程到达此交换点（除非当前线程被中断，或者超出了指定的等待时间），然后将给定的对象传送给该线程，同时接收该线程的对象。

V Future.get(long timeout, TimeUnit unit)
如有必要，最多等待为使计算完成所给定的时间之后，获取其结果（如果结果可用）。

V FutureTask.get(long timeout, TimeUnit unit)

long Delayed.getDelay(TimeUnit unit)
返回与此对象相关的剩余延迟时间，以给定的时间单位表示。

long ThreadPoolExecutor.getKeepAliveTime(TimeUnit unit)
返回线程保持活动的时间，该时间就是超过核心池大小的线程可以在终止前保持空闲的时间值。




<T> List<Future<T>>

AbstractExecutorService.invokeAll(Collection<? extends Callable<T>> tasks,
          long timeout,
          TimeUnit unit)




<T> List<Future<T>>

ExecutorService.invokeAll(Collection<? extends Callable<T>> tasks,
          long timeout,
          TimeUnit unit)

执行给定的任务，当所有任务完成或超时期满时（无论哪个首先发生），返回保持任务状态和结果的 Future 列表。




<T> T

AbstractExecutorService.invokeAny(Collection<? extends Callable<T>> tasks,
          long timeout,
          TimeUnit unit)




<T> T

ExecutorService.invokeAny(Collection<? extends Callable<T>> tasks,
          long timeout,
          TimeUnit unit)

执行给定的任务，如果在给定的超时期满前某个任务已成功完成（也就是未抛出异常），则返回其结果。

boolean ArrayBlockingQueue.offer(E e, long timeout, TimeUnit unit)
将指定的元素插入此队列的尾部，如果该队列已满，则在到达指定的等待时间之前等待可用的空间。

boolean BlockingDeque.offer(E e, long timeout, TimeUnit unit)
将指定的元素插入此双端队列表示的队列中（即此双端队列的尾部），必要时将在指定的等待时间内一直等待可用空间。

boolean BlockingQueue.offer(E e, long timeout, TimeUnit unit)
将指定元素插入此队列中，在到达指定的等待时间前等待可用的空间（如果有必要）。

boolean DelayQueue.offer(E e, long timeout, TimeUnit unit)
将指定元素插入此延迟队列中。

boolean LinkedBlockingDeque.offer(E e, long timeout, TimeUnit unit)

boolean LinkedBlockingQueue.offer(E e, long timeout, TimeUnit unit)
将指定元素插入到此队列的尾部，如有必要，则等待指定的时间以使空间变得可用。

boolean PriorityBlockingQueue.offer(E e, long timeout, TimeUnit unit)
将指定元素插入此优先级队列。

boolean SynchronousQueue.offer(E o, long timeout, TimeUnit unit)
将指定元素插入到此队列，如有必要则等待指定的时间，以便另一个线程接收它。

boolean BlockingDeque.offerFirst(E e, long timeout, TimeUnit unit)
将指定的元素插入此双端队列的开头，必要时将在指定的等待时间内等待可用空间。

boolean LinkedBlockingDeque.offerFirst(E e, long timeout, TimeUnit unit)

boolean BlockingDeque.offerLast(E e, long timeout, TimeUnit unit)
将指定的元素插入此双端队列的末尾，必要时将在指定的等待时间内等待可用空间。

boolean LinkedBlockingDeque.offerLast(E e, long timeout, TimeUnit unit)

E ArrayBlockingQueue.poll(long timeout, TimeUnit unit)

E BlockingDeque.poll(long timeout, TimeUnit unit)
获取并移除此双端队列表示的队列的头部（即此双端队列的第一个元素），如有必要将在指定的等待时间内等待可用元素。

E BlockingQueue.poll(long timeout, TimeUnit unit)
获取并移除此队列的头部，在指定的等待时间前等待可用的元素（如果有必要）。

Future<V> CompletionService.poll(long timeout, TimeUnit unit)
获取并移除表示下一个已完成任务的 Future，如果目前不存在这样的任务，则将等待指定的时间（如果有必要）。

E DelayQueue.poll(long timeout, TimeUnit unit)
获取并移除此队列的头部，在可从此队列获得到期延迟的元素，或者到达指定的等待时间之前一直等待（如有必要）。

Future<V> ExecutorCompletionService.poll(long timeout, TimeUnit unit)

E LinkedBlockingDeque.poll(long timeout, TimeUnit unit)

E LinkedBlockingQueue.poll(long timeout, TimeUnit unit)

E PriorityBlockingQueue.poll(long timeout, TimeUnit unit)

E SynchronousQueue.poll(long timeout, TimeUnit unit)
获取并移除此队列的头，如有必要则等待指定的时间，以便另一个线程插入它。

E BlockingDeque.pollFirst(long timeout, TimeUnit unit)
获取并移除此双端队列的第一个元素，必要时将在指定的等待时间等待可用元素。

E LinkedBlockingDeque.pollFirst(long timeout, TimeUnit unit)

E BlockingDeque.pollLast(long timeout, TimeUnit unit)
获取并移除此双端队列的最后一个元素，必要时将在指定的等待时间内等待可用元素。

E LinkedBlockingDeque.pollLast(long timeout, TimeUnit unit)




<V> ScheduledFuture<V>

ScheduledExecutorService.schedule(Callable<V> callable,
         long delay,
         TimeUnit unit)

创建并执行在给定延迟后启用的 ScheduledFuture。




<V> ScheduledFuture<V>

ScheduledThreadPoolExecutor.schedule(Callable<V> callable,
         long delay,
         TimeUnit unit)

ScheduledFuture<?> ScheduledExecutorService.schedule(Runnable command, long delay, TimeUnit unit)
创建并执行在给定延迟后启用的一次性操作。

ScheduledFuture<?> ScheduledThreadPoolExecutor.schedule(Runnable command, long delay, TimeUnit unit)

ScheduledFuture<?> ScheduledExecutorService.scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
创建并执行一个在给定初始延迟后首次启用的定期操作，后续操作具有给定的周期；也就是将在 initialDelay 后开始执行，然后在 initialDelay+period 后执行，接着在 initialDelay + 2 * period 后执行，依此类推。

ScheduledFuture<?> ScheduledThreadPoolExecutor.scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)

ScheduledFuture<?> ScheduledExecutorService.scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。

ScheduledFuture<?> ScheduledThreadPoolExecutor.scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)

void ThreadPoolExecutor.setKeepAliveTime(long time, TimeUnit unit)
设置线程在终止前可以保持空闲的时间限制。

boolean Semaphore.tryAcquire(int permits, long timeout, TimeUnit unit)
如果在给定的等待时间内此信号量有可用的所有许可，并且当前线程未被中断，则从此信号量获取给定数目的许可。

boolean Semaphore.tryAcquire(long timeout, TimeUnit unit)
如果在给定的等待时间内，此信号量有可用的许可并且当前线程未被中断，则从此信号量获取一个许可。

参数类型为 TimeUnit 的 java.util.concurrent 中的构造方法
`ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)` 用给定的初始参数和默认的线程工厂及被拒绝的执行处理程序创建新的 `ThreadPoolExecutor`。
`ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler)` 用给定的初始参数和默认的线程工厂创建新的 `ThreadPoolExecutor`。
`ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory)` 用给定的初始参数和默认被拒绝的执行处理程序创建新的 `ThreadPoolExecutor`。
`ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)` 用给定的初始参数创建新的 `ThreadPoolExecutor`。

java.util.concurrent.locks 中 TimeUnit 的使用

参数类型为 TimeUnit 的 java.util.concurrent.locks 中的方法
`boolean`	`AbstractQueuedLongSynchronizer.ConditionObject.await(long time, TimeUnit unit)` 实现定时条件等待。
`boolean`	`Condition.await(long time, TimeUnit unit)` 造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。
`boolean`	`AbstractQueuedSynchronizer.ConditionObject.await(long time, TimeUnit unit)` 实现定时的条件等待。
`boolean`	`ReentrantReadWriteLock.ReadLock.tryLock(long timeout, TimeUnit unit)` 如果另一个线程在给定的等待时间内没有保持写入锁，并且当前线程未被中断，则获取读取锁。
`boolean`	`ReentrantReadWriteLock.WriteLock.tryLock(long timeout, TimeUnit unit)` 如果另一个线程在给定的等待时间内没有保持写入锁，并且当前线程未被中断，则获取写入锁。
`boolean`	`ReentrantLock.tryLock(long timeout, TimeUnit unit)` 如果锁在给定等待时间内没有被另一个线程保持，且当前线程未被中断，则获取该锁。
`boolean`	`Lock.tryLock(long time, TimeUnit unit)` 如果锁在给定的等待时间内空闲，并且当前线程未被中断，则获取锁。

javax.swing 中 TimeUnit 的使用

参数类型为 TimeUnit 的 javax.swing 中的方法
`T`	`SwingWorker.get(long timeout, TimeUnit unit)` 如有必要，最多等待为使计算完成所给定的时间之后，获取其结果（如果结果可用）。

概述