| /* |
| * Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| package java.rmi.server; |
| |
| import java.io.DataInput; |
| import java.io.DataOutput; |
| import java.io.IOException; |
| import java.io.Serializable; |
| import java.security.SecureRandom; |
| |
| /** |
| * A <code>UID</code> represents an identifier that is unique over time |
| * with respect to the host it is generated on, or one of 2<sup>16</sup> |
| * "well-known" identifiers. |
| * |
| * <p>The {@link #UID()} constructor can be used to generate an |
| * identifier that is unique over time with respect to the host it is |
| * generated on. The {@link #UID(short)} constructor can be used to |
| * create one of 2<sup>16</sup> well-known identifiers. |
| * |
| * <p>A <code>UID</code> instance contains three primitive values: |
| * <ul> |
| * <li><code>unique</code>, an <code>int</code> that uniquely identifies |
| * the VM that this <code>UID</code> was generated in, with respect to its |
| * host and at the time represented by the <code>time</code> value (an |
| * example implementation of the <code>unique</code> value would be a |
| * process identifier), |
| * or zero for a well-known <code>UID</code> |
| * <li><code>time</code>, a <code>long</code> equal to a time (as returned |
| * by {@link System#currentTimeMillis()}) at which the VM that this |
| * <code>UID</code> was generated in was alive, |
| * or zero for a well-known <code>UID</code> |
| * <li><code>count</code>, a <code>short</code> to distinguish |
| * <code>UID</code>s generated in the same VM with the same |
| * <code>time</code> value |
| * </ul> |
| * |
| * <p>An independently generated <code>UID</code> instance is unique |
| * over time with respect to the host it is generated on as long as |
| * the host requires more than one millisecond to reboot and its system |
| * clock is never set backward. A globally unique identifier can be |
| * constructed by pairing a <code>UID</code> instance with a unique host |
| * identifier, such as an IP address. |
| * |
| * @author Ann Wollrath |
| * @author Peter Jones |
| * @since JDK1.1 |
| */ |
| public final class UID implements Serializable { |
| |
| private static int hostUnique; |
| private static boolean hostUniqueSet = false; |
| |
| private static final Object lock = new Object(); |
| private static long lastTime = System.currentTimeMillis(); |
| private static short lastCount = Short.MIN_VALUE; |
| |
| /** indicate compatibility with JDK 1.1.x version of class */ |
| private static final long serialVersionUID = 1086053664494604050L; |
| |
| /** |
| * number that uniquely identifies the VM that this <code>UID</code> |
| * was generated in with respect to its host and at the given time |
| * @serial |
| */ |
| private final int unique; |
| |
| /** |
| * a time (as returned by {@link System#currentTimeMillis()}) at which |
| * the VM that this <code>UID</code> was generated in was alive |
| * @serial |
| */ |
| private final long time; |
| |
| /** |
| * 16-bit number to distinguish <code>UID</code> instances created |
| * in the same VM with the same time value |
| * @serial |
| */ |
| private final short count; |
| |
| /** |
| * Generates a <code>UID</code> that is unique over time with |
| * respect to the host that it was generated on. |
| */ |
| public UID() { |
| |
| synchronized (lock) { |
| if (!hostUniqueSet) { |
| hostUnique = (new SecureRandom()).nextInt(); |
| hostUniqueSet = true; |
| } |
| unique = hostUnique; |
| if (lastCount == Short.MAX_VALUE) { |
| boolean interrupted = Thread.interrupted(); |
| boolean done = false; |
| while (!done) { |
| long now = System.currentTimeMillis(); |
| if (now == lastTime) { |
| // wait for time to change |
| try { |
| Thread.sleep(1); |
| } catch (InterruptedException e) { |
| interrupted = true; |
| } |
| } else { |
| // If system time has gone backwards increase |
| // original by 1ms to maintain uniqueness |
| lastTime = (now < lastTime) ? lastTime+1 : now; |
| lastCount = Short.MIN_VALUE; |
| done = true; |
| } |
| } |
| if (interrupted) { |
| Thread.currentThread().interrupt(); |
| } |
| } |
| time = lastTime; |
| count = lastCount++; |
| } |
| } |
| |
| /** |
| * Creates a "well-known" <code>UID</code>. |
| * |
| * There are 2<sup>16</sup> possible such well-known ids. |
| * |
| * <p>A <code>UID</code> created via this constructor will not |
| * clash with any <code>UID</code>s generated via the no-arg |
| * constructor. |
| * |
| * @param num number for well-known <code>UID</code> |
| */ |
| public UID(short num) { |
| unique = 0; |
| time = 0; |
| count = num; |
| } |
| |
| /** |
| * Constructs a <code>UID</code> given data read from a stream. |
| */ |
| private UID(int unique, long time, short count) { |
| this.unique = unique; |
| this.time = time; |
| this.count = count; |
| } |
| |
| /** |
| * Returns the hash code value for this <code>UID</code>. |
| * |
| * @return the hash code value for this <code>UID</code> |
| */ |
| public int hashCode() { |
| return (int) time + (int) count; |
| } |
| |
| /** |
| * Compares the specified object with this <code>UID</code> for |
| * equality. |
| * |
| * This method returns <code>true</code> if and only if the |
| * specified object is a <code>UID</code> instance with the same |
| * <code>unique</code>, <code>time</code>, and <code>count</code> |
| * values as this one. |
| * |
| * @param obj the object to compare this <code>UID</code> to |
| * |
| * @return <code>true</code> if the given object is equivalent to |
| * this one, and <code>false</code> otherwise |
| */ |
| public boolean equals(Object obj) { |
| if (obj instanceof UID) { |
| UID uid = (UID) obj; |
| return (unique == uid.unique && |
| count == uid.count && |
| time == uid.time); |
| } else { |
| return false; |
| } |
| } |
| |
| /** |
| * Returns a string representation of this <code>UID</code>. |
| * |
| * @return a string representation of this <code>UID</code> |
| */ |
| public String toString() { |
| return Integer.toString(unique,16) + ":" + |
| Long.toString(time,16) + ":" + |
| Integer.toString(count,16); |
| } |
| |
| /** |
| * Marshals a binary representation of this <code>UID</code> to |
| * a <code>DataOutput</code> instance. |
| * |
| * <p>Specifically, this method first invokes the given stream's |
| * {@link DataOutput#writeInt(int)} method with this <code>UID</code>'s |
| * <code>unique</code> value, then it invokes the stream's |
| * {@link DataOutput#writeLong(long)} method with this <code>UID</code>'s |
| * <code>time</code> value, and then it invokes the stream's |
| * {@link DataOutput#writeShort(int)} method with this <code>UID</code>'s |
| * <code>count</code> value. |
| * |
| * @param out the <code>DataOutput</code> instance to write |
| * this <code>UID</code> to |
| * |
| * @throws IOException if an I/O error occurs while performing |
| * this operation |
| */ |
| public void write(DataOutput out) throws IOException { |
| out.writeInt(unique); |
| out.writeLong(time); |
| out.writeShort(count); |
| } |
| |
| /** |
| * Constructs and returns a new <code>UID</code> instance by |
| * unmarshalling a binary representation from an |
| * <code>DataInput</code> instance. |
| * |
| * <p>Specifically, this method first invokes the given stream's |
| * {@link DataInput#readInt()} method to read a <code>unique</code> value, |
| * then it invoke's the stream's |
| * {@link DataInput#readLong()} method to read a <code>time</code> value, |
| * then it invoke's the stream's |
| * {@link DataInput#readShort()} method to read a <code>count</code> value, |
| * and then it creates and returns a new <code>UID</code> instance |
| * that contains the <code>unique</code>, <code>time</code>, and |
| * <code>count</code> values that were read from the stream. |
| * |
| * @param in the <code>DataInput</code> instance to read |
| * <code>UID</code> from |
| * |
| * @return unmarshalled <code>UID</code> instance |
| * |
| * @throws IOException if an I/O error occurs while performing |
| * this operation |
| */ |
| public static UID read(DataInput in) throws IOException { |
| int unique = in.readInt(); |
| long time = in.readLong(); |
| short count = in.readShort(); |
| return new UID(unique, time, count); |
| } |
| } |