sample/java.util.concurrent.TimeUnit.txt

   1 *java.util.concurrent.TimeUnit* *TimeUnit* A TimeUnit represents time durations
   2
   3 public enumTimeUnit
   4   extends    |java.lang.Enum|
   5
   6 |java.util.concurrent.TimeUnit_Description|
   7 |java.util.concurrent.TimeUnit_Fields|
   8 |java.util.concurrent.TimeUnit_Constructors|
   9 |java.util.concurrent.TimeUnit_Methods|
  10
  11 ================================================================================
  12
  13 *java.util.concurrent.TimeUnit_Methods*
  14 |java.util.concurrent.TimeUnit.convert(long,TimeUnit)|Convert the given time du
  15 |java.util.concurrent.TimeUnit.sleep(long)|Performs a Thread.sleep using this u
  16 |java.util.concurrent.TimeUnit.timedJoin(Thread,long)|Performs a timed Thread.j
  17 |java.util.concurrent.TimeUnit.timedWait(Object,long)|Performs a timed Object.w
  18 |java.util.concurrent.TimeUnit.toDays(long)|Equivalent to DAYS.convert(duration
  19 |java.util.concurrent.TimeUnit.toHours(long)|Equivalent to HOURS.convert(durati
  20 |java.util.concurrent.TimeUnit.toMicros(long)|Equivalent to MICROSECONDS.conver
  21 |java.util.concurrent.TimeUnit.toMillis(long)|Equivalent to MILLISECONDS.conver
  22 |java.util.concurrent.TimeUnit.toMinutes(long)|Equivalent to MINUTES.convert(du
  23 |java.util.concurrent.TimeUnit.toNanos(long)|Equivalent to NANOSECONDS.convert(
  24 |java.util.concurrent.TimeUnit.toSeconds(long)|Equivalent to SECONDS.convert(du
  25 |java.util.concurrent.TimeUnit.valueOf(String)|
  26 |java.util.concurrent.TimeUnit.values()|
  27
  28 *java.util.concurrent.TimeUnit_Description*
  29
  30 A TimeUnit represents time durations at a given unit of granularity and
  31 provides utility methods to convert across units, and to perform timing and
  32 delay operations in these units. A TimeUnit does not maintain time information,
  33 but only helps organize and use time representations that may be maintained
  34 separately across various contexts. A nanosecond is defined as one thousandth
  35 of a microsecond, a microsecond as one thousandth of a millisecond, a
  36 millisecond as one thousandth of a second, a minute as sixty seconds, an hour
  37 as sixty minutes, and a day as twenty four hours.
  38
  39 A TimeUnit is mainly used to inform time-based methods how a given timing
  40 parameter should be interpreted. For example, the following code will timeout
  41 in 50 milliseconds if the lock(|java.util.concurrent.locks.Lock|) is not
  42 available:
  43
  44 Lock lock = ...; if ( lock.tryLock(50L, TimeUnit.MILLISECONDS) ) ...
  45
  46 while this code will timeout in 50 seconds:
  47
  48 Lock lock = ...; if ( lock.tryLock(50L, TimeUnit.SECONDS) ) ...
  49
  50 Note however, that there is no guarantee that a particular timeout
  51 implementation will be able to notice the passage of time at the same
  52 granularity as the given TimeUnit.
  53
  54
  55
  56 *java.util.concurrent.TimeUnit.convert(long,TimeUnit)*
  57
  58 public long convert(
  59   long sourceDuration,
  60   java.util.concurrent.TimeUnit sourceUnit)
  61
  62 Convert the given time duration in the given unit to this unit. Conversions
  63 from finer to coarser granularities truncate, so lose precision. For example
  64 converting 999 milliseconds to seconds results in 0. Conversions from coarser
  65 to finer granularities with arguments that would numerically overflow saturate
  66 to Long.MIN_VALUE if negative or Long.MAX_VALUE if positive.
  67
  68 For example, to convert 10 minutes to milliseconds, use:
  69 TimeUnit.MILLISECONDS.convert(10L, TimeUnit.MINUTES)
  70
  71
  72     sourceDuration - the time duration in the given sourceUnit
  73     sourceUnit - the unit of the sourceDuration argument
  74
  75     Returns: the converted duration in this unit, or Long.MIN_VALUE if conversion would
  76              negatively overflow, or Long.MAX_VALUE if it would positively
  77              overflow.
  78
  79 *java.util.concurrent.TimeUnit.sleep(long)*
  80
  81 public void sleep(long timeout)
  82   throws |java.lang.InterruptedException|
  83
  84 Performs a Thread.sleep using this unit. This is a convenience method that
  85 converts time arguments into the form required by the Thread.sleep method.
  86
  87
  88     timeout - the minimum time to sleep. If less than or equal to zero, do not sleep at all.
  89
  90 *java.util.concurrent.TimeUnit.timedJoin(Thread,long)*
  91
  92 public void timedJoin(
  93   java.lang.Thread thread,
  94   long timeout)
  95   throws |java.lang.InterruptedException|
  96
  97 Performs a timed Thread.join using this time unit. This is a convenience method
  98 that converts time arguments into the form required by the Thread.join method.
  99
 100
 101     thread - the thread to wait for
 102     timeout - the maximum time to wait. If less than or equal to zero, do not wait at all.
 103
 104 *java.util.concurrent.TimeUnit.timedWait(Object,long)*
 105
 106 public void timedWait(
 107   java.lang.Object obj,
 108   long timeout)
 109   throws |java.lang.InterruptedException|
 110
 111 Performs a timed Object.wait using this time unit. This is a convenience method
 112 that converts timeout arguments into the form required by the Object.wait
 113 method.
 114
 115 For example, you could implement a blocking poll method (see
 116 BlockingQueue.poll(|java.util.concurrent.BlockingQueue|) ) using:
 117
 118 public synchronized Object poll(long timeout, TimeUnit unit) throws
 119 InterruptedException { while (empty) { unit.timedWait(this, timeout); ... } }
 120
 121
 122     obj - the object to wait on
 123     timeout - the maximum time to wait. If less than or equal to zero, do not wait at all.
 124
 125 *java.util.concurrent.TimeUnit.toDays(long)*
 126
 127 public long toDays(long duration)
 128
 129 Equivalent to DAYS.convert(duration, this).
 130
 131
 132     duration - the duration
 133
 134     Returns: the converted duration
 135
 136 *java.util.concurrent.TimeUnit.toHours(long)*
 137
 138 public long toHours(long duration)
 139
 140 Equivalent to HOURS.convert(duration, this).
 141
 142
 143     duration - the duration
 144
 145     Returns: the converted duration, or Long.MIN_VALUE if conversion would negatively
 146              overflow, or Long.MAX_VALUE if it would positively overflow.
 147
 148 *java.util.concurrent.TimeUnit.toMicros(long)*
 149
 150 public long toMicros(long duration)
 151
 152 Equivalent to MICROSECONDS.convert(duration, this).
 153
 154
 155     duration - the duration
 156
 157     Returns: the converted duration, or Long.MIN_VALUE if conversion would negatively
 158              overflow, or Long.MAX_VALUE if it would positively overflow.
 159
 160 *java.util.concurrent.TimeUnit.toMillis(long)*
 161
 162 public long toMillis(long duration)
 163
 164 Equivalent to MILLISECONDS.convert(duration, this).
 165
 166
 167     duration - the duration
 168
 169     Returns: the converted duration, or Long.MIN_VALUE if conversion would negatively
 170              overflow, or Long.MAX_VALUE if it would positively overflow.
 171
 172 *java.util.concurrent.TimeUnit.toMinutes(long)*
 173
 174 public long toMinutes(long duration)
 175
 176 Equivalent to MINUTES.convert(duration, this).
 177
 178
 179     duration - the duration
 180
 181     Returns: the converted duration, or Long.MIN_VALUE if conversion would negatively
 182              overflow, or Long.MAX_VALUE if it would positively overflow.
 183
 184 *java.util.concurrent.TimeUnit.toNanos(long)*
 185
 186 public long toNanos(long duration)
 187
 188 Equivalent to NANOSECONDS.convert(duration, this).
 189
 190
 191     duration - the duration
 192
 193     Returns: the converted duration, or Long.MIN_VALUE if conversion would negatively
 194              overflow, or Long.MAX_VALUE if it would positively overflow.
 195
 196 *java.util.concurrent.TimeUnit.toSeconds(long)*
 197
 198 public long toSeconds(long duration)
 199
 200 Equivalent to SECONDS.convert(duration, this).
 201
 202
 203     duration - the duration
 204
 205     Returns: the converted duration, or Long.MIN_VALUE if conversion would negatively
 206              overflow, or Long.MAX_VALUE if it would positively overflow.
 207
 208 *java.util.concurrent.TimeUnit.valueOf(String)*
 209
 210 public static |java.util.concurrent.TimeUnit| valueOf(java.lang.String name)
 211
 212
 213
 214
 215
 216 *java.util.concurrent.TimeUnit.values()*
 217
 218 public static final |java.util.concurrent.TimeUnit|[] values()
 219
 220
 221
 222
 223
 224