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
26 package java.lang.management;
27
28 import javax.management.openmbean.CompositeData;
29 import java.util.concurrent.locks.*;
30 import 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
56 public 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