1/* 2 * Copyright (c) 2005, 2017, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26package java.lang.management; 27 28import javax.management.openmbean.CompositeData; 29import java.util.concurrent.locks.*; 30import sun.management.LockInfoCompositeData; 31 32/** 33 * Information about a <em>lock</em>. A lock can be a built-in object monitor, 34 * an <em>ownable synchronizer</em>, or the {@link Condition Condition} 35 * object associated with synchronizers. 36 * <p> 37 * <a id="OwnableSynchronizer">An ownable synchronizer</a> is 38 * a synchronizer that may be exclusively owned by a thread and uses 39 * {@link AbstractOwnableSynchronizer AbstractOwnableSynchronizer} 40 * (or its subclass) to implement its synchronization property. 41 * {@link ReentrantLock ReentrantLock} and the write-lock (but not 42 * the read-lock) of {@link ReentrantReadWriteLock ReentrantReadWriteLock} are 43 * two examples of ownable synchronizers provided by the platform. 44 * 45 * <h3><a id="MappedType">MXBean Mapping</a></h3> 46 * {@code LockInfo} is mapped to a {@link CompositeData CompositeData} 47 * as specified in the {@link #from from} method. 48 * 49 * @see java.util.concurrent.locks.AbstractOwnableSynchronizer 50 * @see java.util.concurrent.locks.Condition 51 * 52 * @author Mandy Chung 53 * @since 1.6 54 */ 55 56public class LockInfo { 57 58 private String className; 59 private int identityHashCode; 60 61 /** 62 * Constructs a {@code LockInfo} object. 63 * 64 * @param className the fully qualified name of the class of the lock object. 65 * @param identityHashCode the {@link System#identityHashCode 66 * identity hash code} of the lock object. 67 */ 68 public LockInfo(String className, int identityHashCode) { 69 if (className == null) { 70 throw new NullPointerException("Parameter className cannot be null"); 71 } 72 this.className = className; 73 this.identityHashCode = identityHashCode; 74 } 75 76 /** 77 * package-private constructors 78 */ 79 LockInfo(Object lock) { 80 this.className = lock.getClass().getName(); 81 this.identityHashCode = System.identityHashCode(lock); 82 } 83 84 /** 85 * Returns the fully qualified name of the class of the lock object. 86 * 87 * @return the fully qualified name of the class of the lock object. 88 */ 89 public String getClassName() { 90 return className; 91 } 92 93 /** 94 * Returns the identity hash code of the lock object 95 * returned from the {@link System#identityHashCode} method. 96 * 97 * @return the identity hash code of the lock object. 98 */ 99 public int getIdentityHashCode() { 100 return identityHashCode; 101 } 102 103 /** 104 * Returns a {@code LockInfo} object represented by the 105 * given {@code CompositeData}. 106 * The given {@code CompositeData} must contain the following attributes: 107 * <table class="striped" style="margin-left:2em;"> 108 * <caption style="display:none">The attributes and the types the given CompositeData contains</caption> 109 * <thead style="text-align:left"> 110 * <tr> 111 * <th scope="col">Attribute Name</th> 112 * <th scope="col">Type</th> 113 * </tr> 114 * </thead> 115 * <tbody style="text-align:left"> 116 * <tr> 117 * <th scope="row">className</th> 118 * <td>{@code java.lang.String}</td> 119 * </tr> 120 * <tr> 121 * <th scope="row">identityHashCode</th> 122 * <td>{@code java.lang.Integer}</td> 123 * </tr> 124 * </tbody> 125 * </table> 126 * 127 * @param cd {@code CompositeData} representing a {@code LockInfo} 128 * 129 * @throws IllegalArgumentException if {@code cd} does not 130 * represent a {@code LockInfo} with the attributes described 131 * above. 132 * @return a {@code LockInfo} object represented 133 * by {@code cd} if {@code cd} is not {@code null}; 134 * {@code null} otherwise. 135 * 136 * @since 1.8 137 */ 138 public static LockInfo from(CompositeData cd) { 139 if (cd == null) { 140 return null; 141 } 142 143 if (cd instanceof LockInfoCompositeData) { 144 return ((LockInfoCompositeData) cd).getLockInfo(); 145 } else { 146 return LockInfoCompositeData.toLockInfo(cd); 147 } 148 } 149 150 /** 151 * Returns a string representation of a lock. The returned 152 * string representation consists of the name of the class of the 153 * lock object, the at-sign character `@', and the unsigned 154 * hexadecimal representation of the <em>identity</em> hash code 155 * of the object. This method returns a string equals to the value of: 156 * <blockquote> 157 * <pre> 158 * lock.getClass().getName() + '@' + Integer.toHexString(System.identityHashCode(lock)) 159 * </pre></blockquote> 160 * where {@code lock} is the lock object. 161 * 162 * @return the string representation of a lock. 163 */ 164 public String toString() { 165 return className + '@' + Integer.toHexString(identityHashCode); 166 } 167} 168