test/java/lang/management/ThreadMXBean/ThreadMXBeanStateTest.java

Print this page




   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /*
  25  * @test
  26  * @bug     4967283 5080203
  27  * @summary Basic unit test of thread states returned by
  28  *          ThreadMXBean.getThreadInfo.getThreadState().
  29  *          It also tests lock information returned by ThreadInfo.
  30  *
  31  * @author  Mandy Chung
  32  *
  33  * @build ThreadExecutionSynchronizer Utils
  34  * @run main ThreadStateTest

  35  */
  36 
  37 import java.lang.management.ManagementFactory;
  38 import java.lang.management.ThreadMXBean;
  39 import java.lang.management.ThreadInfo;

  40 
  41 import java.util.concurrent.locks.LockSupport;
  42 
  43 public class ThreadStateTest {
  44     private static final ThreadMXBean tm = ManagementFactory.getThreadMXBean();
  45 
  46     static class Lock {
  47         private String name;
  48         Lock(String name) {
  49             this.name = name;
  50         }
  51         public String toString() {
  52             return name;
  53         }
  54     }
  55     private static Lock globalLock = new Lock("my lock");
  56 
  57     public static void main(String[] argv) {
  58         // Force thread state initialization now before the test
  59         // verification begins.
  60         Thread.currentThread().getState();


  61 
  62         MyThread myThread = new MyThread("MyThread");
  63 
  64         // before myThread starts
  65         // Utils.checkThreadState(myThread, Thread.State.NEW);
  66 
  67         myThread.start();
  68         myThread.waitUntilStarted();
  69         Utils.checkThreadState(myThread, Thread.State.RUNNABLE);
  70         checkLockInfo(myThread, Thread.State.RUNNABLE, null, null);
  71 
  72         myThread.suspend();
  73         Utils.goSleep(10);
  74         checkSuspendedThreadState(myThread, Thread.State.RUNNABLE);
  75         myThread.resume();

  76 
  77         synchronized (globalLock) {
  78             myThread.goBlocked();
  79             Utils.checkThreadState(myThread, Thread.State.BLOCKED);
  80             checkLockInfo(myThread, Thread.State.BLOCKED,
  81                           globalLock, Thread.currentThread());
  82         }
  83 
  84         myThread.goWaiting();
  85         Utils.checkThreadState(myThread, Thread.State.WAITING);
  86         checkLockInfo(myThread, Thread.State.WAITING,
  87                       globalLock, null);
  88 
  89         myThread.goTimedWaiting();
  90         Utils.checkThreadState(myThread, Thread.State.TIMED_WAITING);
  91         checkLockInfo(myThread, Thread.State.TIMED_WAITING,
  92                       globalLock, null);
  93 
  94 



  95 
  96       /*
  97        *********** parkUntil seems not working
  98        * ignore this park case for now.
  99 
 100          Bug ID : 5062095
 101        ***********************************************
 102         myThread.goParked();
 103         Utils.checkThreadState(myThread, Thread.State.WAITING);
 104         checkLockInfo(myThread, Thread.State.WAITING, null, null);
 105 
 106         myThread.goTimedParked();
 107         Utils.checkThreadState(myThread, Thread.State.TIMED_WAITING);
 108         checkLockInfo(myThread, Thread.State.TIMED_WAITING, null, null);
 109 
 110        */
 111 
 112         myThread.goSleeping();
 113         Utils.checkThreadState(myThread, Thread.State.TIMED_WAITING);
 114         checkLockInfo(myThread, Thread.State.TIMED_WAITING, null, null);
 115 
 116 
 117         myThread.terminate();
 118         // Utils.checkThreadState(myThread, ThreadState.TERMINATED);
 119 
 120         try {
 121             myThread.join();
 122         } catch (InterruptedException e) {
 123             e.printStackTrace();
 124             System.out.println("TEST FAILED: Unexpected exception.");
 125             throw new RuntimeException(e);
 126         }
 127         System.out.println("Test passed.");
 128     }
 129 
 130     private static void checkSuspendedThreadState(Thread t, Thread.State state) {
 131         ThreadInfo info = tm.getThreadInfo(t.getId());
 132         if (info == null) {
 133             throw new RuntimeException(t.getName() +
 134                " expected to have ThreadInfo " +
 135                " but got null.");
 136         }
 137 
 138         if (info.getThreadState() != state) {
 139             throw new RuntimeException(t.getName() + " expected to be in " +
 140                 state + " state but got " + info.getThreadState());
 141         }
 142 
 143         if (!info.isSuspended()) {
 144             throw new RuntimeException(t.getName() + " expected to be suspended " +
 145                 " but isSuspended() returns " + info.isSuspended());
 146         }
 147         Utils.checkThreadState(t, state);
 148     }
 149 
 150     private static String getLockName(Object lock) {
 151         if (lock == null) return null;
 152 
 153         return lock.getClass().getName() + '@' +
 154             Integer.toHexString(System.identityHashCode(lock));
 155     }
 156 
 157     private static void checkLockInfo(Thread t, Thread.State state, Object lock, Thread owner) {
 158         ThreadInfo info = tm.getThreadInfo(t.getId());
 159         if (info == null) {
 160             throw new RuntimeException(t.getName() +
 161                " expected to have ThreadInfo " +
 162                " but got null.");
 163         }
 164 
 165         if (info.getThreadState() != state) {
 166             throw new RuntimeException(t.getName() + " expected to be in " +
 167                 state + " state but got " + info.getThreadState());


 203         if (owner == null && info.getLockOwnerId() != -1) {
 204             throw new RuntimeException("Lock owner is expected " +
 205                 " to be -1 but got " + info.getLockOwnerId());
 206         }
 207 
 208         if (owner != null && info.getLockOwnerId() <= 0) {
 209             throw new RuntimeException("Lock owner is expected to be " +
 210                 owner.getName() + "(id = " + owner.getId() +
 211                 ") but got " + info.getLockOwnerId());
 212         }
 213         if (owner != null && info.getLockOwnerId() != owner.getId()) {
 214             throw new RuntimeException("Lock owner is expected to be " +
 215                 owner.getName() + "(id = " + owner.getId() +
 216                 ") but got " + info.getLockOwnerId());
 217         }
 218         if (info.isSuspended()) {
 219             throw new RuntimeException(t.getName() +
 220                 " isSuspended() returns " + info.isSuspended());
 221         }
 222     }
 223 
 224     static class MyThread extends Thread {
 225         private ThreadExecutionSynchronizer thrsync = new ThreadExecutionSynchronizer();
 226 
 227         MyThread(String name) {
 228             super(name);
 229         }
 230 
 231         private final int RUNNABLE = 0;
 232         private final int BLOCKED = 1;
 233         private final int WAITING = 2;
 234         private final int TIMED_WAITING = 3;
 235         private final int PARKED = 4;
 236         private final int TIMED_PARKED = 5;
 237         private final int SLEEPING = 6;
 238         private final int TERMINATE = 7;
 239         private int state = RUNNABLE;
 240 
 241         private boolean done = false;
 242         public void run() {
 243             // Signal main thread to continue.
 244             thrsync.signal();
 245             while (!done) {
 246                 switch (state) {
 247                     case RUNNABLE: {
 248                         double sum = 0;
 249                         for (int i = 0; i < 1000; i++) {
 250                            double r = Math.random();
 251                            double x = Math.pow(3, r);
 252                            sum += x - r;
 253                         }
 254                         break;
 255                     }
 256                     case BLOCKED: {
 257                         // signal main thread.
 258                         thrsync.signal();
 259                         System.out.println("  myThread is going to block.");
 260                         synchronized (globalLock) {
 261                             // finish blocking
 262                             state = RUNNABLE;
 263                         }
 264                         break;
 265                     }
 266                     case WAITING: {
 267                         synchronized (globalLock) {
 268                             // signal main thread.
 269                             thrsync.signal();
 270                             System.out.println("  myThread is going to wait.");
 271                             try {
 272                                 globalLock.wait();
 273                             } catch (InterruptedException e) {
 274                                 // ignore
 275                             }
 276                         }
 277                         break;
 278                     }
 279                     case TIMED_WAITING: {
 280                         synchronized (globalLock) {
 281                             // signal main thread.
 282                             thrsync.signal();
 283                             System.out.println("  myThread is going to timed wait.");
 284                             try {
 285                                 globalLock.wait(10000);
 286                             } catch (InterruptedException e) {
 287                                 // ignore
 288                             }
 289                         }
 290                         break;
 291                     }
 292                     case PARKED: {
 293                         // signal main thread.
 294                         thrsync.signal();
 295                         System.out.println("  myThread is going to park.");
 296                         LockSupport.park();
 297                         // give a chance for the main thread to block
 298                         System.out.println("  myThread is going to park.");
 299                         Utils.goSleep(10);
 300                         break;
 301                     }
 302                     case TIMED_PARKED: {
 303                         // signal main thread.
 304                         thrsync.signal();
 305                         System.out.println("  myThread is going to timed park.");
 306                         long deadline = System.currentTimeMillis() + 10000*1000;
 307                         LockSupport.parkUntil(deadline);
 308 
 309                         // give a chance for the main thread to block
 310                         Utils.goSleep(10);
 311                         break;
 312                     }
 313                     case SLEEPING: {
 314                         // signal main thread.
 315                         thrsync.signal();
 316                         System.out.println("  myThread is going to sleep.");
 317                         try {
 318                             Thread.sleep(1000000);
 319                         } catch (InterruptedException e) {
 320                             // finish sleeping
 321                             interrupted();
 322                         }
 323                         break;
 324                     }
 325                     case TERMINATE: {
 326                         done = true;
 327                         // signal main thread.
 328                         thrsync.signal();
 329                         break;
 330                     }
 331                     default:
 332                         break;
 333                 }
 334             }
 335         }
 336         public void waitUntilStarted() {
 337             // wait for MyThread.
 338             thrsync.waitForSignal();
 339             Utils.goSleep(10);
 340         }
 341 
 342         public void goBlocked() {
 343             System.out.println("Waiting myThread to go blocked.");
 344             setState(BLOCKED);
 345             // wait for MyThread to get blocked
 346             thrsync.waitForSignal();
 347             Utils.goSleep(20);
 348         }
 349 
 350         public void goWaiting() {
 351             System.out.println("Waiting myThread to go waiting.");
 352             setState(WAITING);
 353             // wait for  MyThread to wait on object.
 354             thrsync.waitForSignal();
 355             Utils.goSleep(20);
 356         }
 357         public void goTimedWaiting() {
 358             System.out.println("Waiting myThread to go timed waiting.");
 359             setState(TIMED_WAITING);
 360             // wait for MyThread timed wait call.
 361             thrsync.waitForSignal();
 362             Utils.goSleep(20);
 363         }
 364         public void goParked() {
 365             System.out.println("Waiting myThread to go parked.");
 366             setState(PARKED);
 367             // wait for  MyThread state change to PARKED.
 368             thrsync.waitForSignal();
 369             Utils.goSleep(20);
 370         }
 371         public void goTimedParked() {
 372             System.out.println("Waiting myThread to go timed parked.");
 373             setState(TIMED_PARKED);
 374             // wait for  MyThread.
 375             thrsync.waitForSignal();
 376             Utils.goSleep(20);
 377         }
 378 
 379         public void goSleeping() {
 380             System.out.println("Waiting myThread to go sleeping.");
 381             setState(SLEEPING);
 382             // wait for  MyThread.
 383             thrsync.waitForSignal();
 384             Utils.goSleep(20);
 385         }
 386         public void terminate() {
 387             System.out.println("Waiting myThread to terminate.");
 388             setState(TERMINATE);
 389             // wait for  MyThread.
 390             thrsync.waitForSignal();
 391             Utils.goSleep(20);
 392         }
 393 
 394         private void setState(int newState) {
 395             switch (state) {
 396                 case BLOCKED:
 397                     while (state == BLOCKED) {
 398                         Utils.goSleep(20);
 399                     }
 400                     state = newState;
 401                     break;
 402                 case WAITING:
 403                 case TIMED_WAITING:
 404                     state = newState;
 405                     synchronized (globalLock) {
 406                         globalLock.notify();
 407                     }
 408                     break;
 409                 case PARKED:
 410                 case TIMED_PARKED:
 411                     state = newState;
 412                     LockSupport.unpark(this);
 413                     break;
 414                 case SLEEPING:
 415                     state = newState;
 416                     this.interrupt();
 417                     break;
 418                 default:
 419                     state = newState;
 420                     break;
 421             }
 422         }
 423     }
 424 }


   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /*
  25  * @test
  26  * @bug     4967283 5080203 8022208
  27  * @summary Basic unit test of thread states returned by
  28  *          ThreadMXBean.getThreadInfo.getThreadState().
  29  *          It also tests lock information returned by ThreadInfo.
  30  *
  31  * @author  Mandy Chung
  32  *
  33  * @library ../../Thread
  34  * @build ThreadMXBeanStateTest ThreadStateController
  35  * @run main ThreadMXBeanStateTest
  36  */
  37 
  38 import java.lang.management.ManagementFactory;
  39 import java.lang.management.ThreadMXBean;
  40 import java.lang.management.ThreadInfo;
  41 import static java.lang.Thread.State.*;
  42 
  43 public class ThreadMXBeanStateTest {


  44     private static final ThreadMXBean tm = ManagementFactory.getThreadMXBean();
  45 
  46     static class Lock {
  47         private String name;
  48         Lock(String name) {
  49             this.name = name;
  50         }
  51         public String toString() {
  52             return name;
  53         }
  54     }
  55     private static Lock globalLock = new Lock("my lock");
  56 
  57     public static void main(String[] argv) throws Exception {
  58         // Force thread state initialization now before the test
  59         // verification begins.
  60         Thread.currentThread().getState();
  61         ThreadStateController thread = new ThreadStateController("StateChanger", globalLock);
  62         thread.setDaemon(true);
  63 


  64         // before myThread starts
  65         thread.checkThreadState(NEW);
  66 
  67         thread.start();
  68         thread.transitionTo(RUNNABLE);
  69         thread.checkThreadState(RUNNABLE);
  70         checkLockInfo(thread, RUNNABLE, null, null);
  71 
  72         thread.suspend();
  73         thread.goSleep(10);
  74         thread.checkThreadState(RUNNABLE);
  75         checkSuspendedThreadState(thread, RUNNABLE);
  76         thread.resume();
  77 
  78         synchronized (globalLock) {
  79             thread.transitionTo(BLOCKED);
  80             thread.checkThreadState(BLOCKED);
  81             checkLockInfo(thread, BLOCKED,
  82                           globalLock, Thread.currentThread());
  83         }
  84 
  85         thread.transitionTo(WAITING);
  86         thread.checkThreadState(WAITING);
  87         checkLockInfo(thread, Thread.State.WAITING,
  88                       globalLock, null);
  89 
  90         thread.transitionTo(TIMED_WAITING);
  91         thread.checkThreadState(TIMED_WAITING);
  92         checkLockInfo(thread, TIMED_WAITING,
  93                       globalLock, null);
  94 
  95 
  96         thread.transitionToPark(true /* timed park */);
  97         thread.checkThreadState(TIMED_WAITING);
  98         checkLockInfo(thread, TIMED_WAITING, null, null);
  99 
 100         thread.transitionToPark(false /* indefinite park */);
 101         thread.checkThreadState(WAITING);
 102         checkLockInfo(thread, WAITING, null, null);
 103 
 104         thread.transitionToSleep();
 105         thread.checkThreadState(TIMED_WAITING);
 106         checkLockInfo(thread, TIMED_WAITING, null, null);


 107 
 108         thread.transitionTo(TERMINATED);
 109         thread.checkThreadState(TERMINATED);

 110 










 111         try {
 112             thread.join();
 113         } catch (InterruptedException e) {
 114             e.printStackTrace();
 115             System.out.println("TEST FAILED: Unexpected exception.");
 116             throw new RuntimeException(e);
 117         }
 118         System.out.println("Test passed.");
 119     }
 120 
 121     private static void checkSuspendedThreadState(Thread t, Thread.State state) {
 122         ThreadInfo info = tm.getThreadInfo(t.getId());
 123         if (info == null) {
 124             throw new RuntimeException(t.getName() +
 125                " expected to have ThreadInfo " +
 126                " but got null.");
 127         }
 128 
 129         if (info.getThreadState() != state) {
 130             throw new RuntimeException(t.getName() + " expected to be in " +
 131                 state + " state but got " + info.getThreadState());
 132         }
 133 
 134         if (!info.isSuspended()) {
 135             throw new RuntimeException(t.getName() + " expected to be suspended " +
 136                 " but isSuspended() returns " + info.isSuspended());
 137         }

 138     }
 139 
 140     private static String getLockName(Object lock) {
 141         if (lock == null) return null;
 142 
 143         return lock.getClass().getName() + '@' +
 144             Integer.toHexString(System.identityHashCode(lock));
 145     }
 146 
 147     private static void checkLockInfo(Thread t, Thread.State state, Object lock, Thread owner) {
 148         ThreadInfo info = tm.getThreadInfo(t.getId());
 149         if (info == null) {
 150             throw new RuntimeException(t.getName() +
 151                " expected to have ThreadInfo " +
 152                " but got null.");
 153         }
 154 
 155         if (info.getThreadState() != state) {
 156             throw new RuntimeException(t.getName() + " expected to be in " +
 157                 state + " state but got " + info.getThreadState());


 193         if (owner == null && info.getLockOwnerId() != -1) {
 194             throw new RuntimeException("Lock owner is expected " +
 195                 " to be -1 but got " + info.getLockOwnerId());
 196         }
 197 
 198         if (owner != null && info.getLockOwnerId() <= 0) {
 199             throw new RuntimeException("Lock owner is expected to be " +
 200                 owner.getName() + "(id = " + owner.getId() +
 201                 ") but got " + info.getLockOwnerId());
 202         }
 203         if (owner != null && info.getLockOwnerId() != owner.getId()) {
 204             throw new RuntimeException("Lock owner is expected to be " +
 205                 owner.getName() + "(id = " + owner.getId() +
 206                 ") but got " + info.getLockOwnerId());
 207         }
 208         if (info.isSuspended()) {
 209             throw new RuntimeException(t.getName() +
 210                 " isSuspended() returns " + info.isSuspended());
 211         }
 212     }









































































































































































































 213 }