Java tutorial
/* * 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 1.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); } }