# HG changeset patch # User kamg # Date 1243463541 25200 # Node ID a2a950ba257ffa4e55ffb253d01a4803762b6830 # Parent 131e94bf12c37a04ff43092fab6ce89961cbb05e# Parent 399e50e3766734e84f9c0b870f85efc2dfa9a798 Merge diff -r 131e94bf12c3 -r a2a950ba257f jdk/src/share/classes/java/net/URLConnection.java --- a/jdk/src/share/classes/java/net/URLConnection.java Wed May 27 13:20:23 2009 -0700 +++ b/jdk/src/share/classes/java/net/URLConnection.java Wed May 27 15:32:21 2009 -0700 @@ -1237,7 +1237,6 @@ } private static Hashtable handlers = new Hashtable(); - private static final ContentHandler UnknownContentHandlerP = new UnknownContentHandler(); /** * Gets the Content Handler appropriate for this connection. @@ -1264,7 +1263,7 @@ handler = lookupContentHandlerClassFor(contentType); } catch(Exception e) { e.printStackTrace(); - handler = UnknownContentHandlerP; + handler = UnknownContentHandler.INSTANCE; } handlers.put(contentType, handler); } @@ -1335,7 +1334,7 @@ } } - return UnknownContentHandlerP; + return UnknownContentHandler.INSTANCE; } /** @@ -1761,6 +1760,8 @@ class UnknownContentHandler extends ContentHandler { + static final ContentHandler INSTANCE = new UnknownContentHandler(); + public Object getContent(URLConnection uc) throws IOException { return uc.getInputStream(); } diff -r 131e94bf12c3 -r a2a950ba257f jdk/test/Makefile --- a/jdk/test/Makefile Wed May 27 13:20:23 2009 -0700 +++ b/jdk/test/Makefile Wed May 27 15:32:21 2009 -0700 @@ -228,6 +228,25 @@ ################################################################ +# perftest to collect statistics + +# Expect JPRT to set JPRT_PACKTEST_HOME. +PERFTEST_HOME = ${TEST_ROOT}/perf +ifdef JPRT_PERFTEST_HOME + PERFTEST_HOME = $(JPRT_PERFTEST_HOME) +endif + +perftest: ( $(PERFTEST_HOME)/perftest \ + -t $(shell $(GETMIXEDPATH) "$(PRODUCT_HOME)") \ + -w $(shell $(GETMIXEDPATH) "$(ABS_TEST_OUTPUT_DIR)") \ + -h $(PERFTEST_HOME) \ + ) ; $(BUNDLE_UP_AND_EXIT) + + +PHONY_LIST += perftest + +################################################################ + # vmsqe tests # Expect JPRT to set JPRT_VMSQE_HOME. diff -r 131e94bf12c3 -r a2a950ba257f jdk/test/java/lang/management/ThreadMXBean/LockingThread.java --- a/jdk/test/java/lang/management/ThreadMXBean/LockingThread.java Wed May 27 13:20:23 2009 -0700 +++ b/jdk/test/java/lang/management/ThreadMXBean/LockingThread.java Wed May 27 15:32:21 2009 -0700 @@ -66,6 +66,8 @@ throw new RuntimeException(e); } } + Utils.waitForBlockWaitingState(t1); + Utils.waitForBlockWaitingState(t2); } static long[] getThreadIds() { return new long[] {t1.getId(), t2.getId()}; diff -r 131e94bf12c3 -r a2a950ba257f jdk/test/java/lang/management/ThreadMXBean/MonitorDeadlock.java --- a/jdk/test/java/lang/management/ThreadMXBean/MonitorDeadlock.java Wed May 27 13:20:23 2009 -0700 +++ b/jdk/test/java/lang/management/ThreadMXBean/MonitorDeadlock.java Wed May 27 15:32:21 2009 -0700 @@ -83,11 +83,24 @@ void waitUntilDeadlock() { barr.await(); - // sleep a little while to wait until threads are blocked. - try { - Thread.sleep(100); - } catch (InterruptedException e) { - // ignore + + for (int i=0; i < 100; i++) { + // sleep a little while to wait until threads are blocked. + try { + Thread.sleep(100); + } catch (InterruptedException e) { + // ignore + } + boolean retry = false; + for (Thread t: dThreads) { + if (t.getState() == Thread.State.RUNNABLE) { + retry = true; + break; + } + } + if (!retry) { + break; + } } } diff -r 131e94bf12c3 -r a2a950ba257f jdk/test/java/lang/management/ThreadMXBean/SynchronizerDeadlock.java --- a/jdk/test/java/lang/management/ThreadMXBean/SynchronizerDeadlock.java Wed May 27 13:20:23 2009 -0700 +++ b/jdk/test/java/lang/management/ThreadMXBean/SynchronizerDeadlock.java Wed May 27 15:32:21 2009 -0700 @@ -83,11 +83,24 @@ void waitUntilDeadlock() { barr.await(); - // sleep a little while to wait until threads are blocked. - try { - Thread.sleep(100); - } catch (InterruptedException e) { - // ignore + + for (int i=0; i < 100; i++) { + // sleep a little while to wait until threads are blocked. + try { + Thread.sleep(100); + } catch (InterruptedException e) { + // ignore + } + boolean retry = false; + for (Thread t: dThreads) { + if (t.getState() == Thread.State.RUNNABLE) { + retry = true; + break; + } + } + if (!retry) { + break; + } } } diff -r 131e94bf12c3 -r a2a950ba257f jdk/test/java/lang/management/ThreadMXBean/SynchronizerLockingThread.java --- a/jdk/test/java/lang/management/ThreadMXBean/SynchronizerLockingThread.java Wed May 27 13:20:23 2009 -0700 +++ b/jdk/test/java/lang/management/ThreadMXBean/SynchronizerLockingThread.java Wed May 27 15:32:21 2009 -0700 @@ -28,7 +28,7 @@ * monitors. * @author Mandy Chung * - * @build ThreadDump + * @build ThreadDump Utils */ import java.lang.management.*; @@ -63,6 +63,9 @@ throw new RuntimeException(e); } } + + Utils.waitForBlockWaitingState(t1); + Utils.waitForBlockWaitingState(t2); } static long[] getThreadIds() { diff -r 131e94bf12c3 -r a2a950ba257f jdk/test/java/lang/management/ThreadMXBean/ThreadStackTrace.java --- a/jdk/test/java/lang/management/ThreadMXBean/ThreadStackTrace.java Wed May 27 13:20:23 2009 -0700 +++ b/jdk/test/java/lang/management/ThreadMXBean/ThreadStackTrace.java Wed May 27 15:32:21 2009 -0700 @@ -28,7 +28,7 @@ * ThreadInfo.getThreadState() * @author Mandy Chung * - * @run build Semaphore + * @run build Semaphore Utils * @run main ThreadStackTrace */ @@ -48,16 +48,6 @@ private static int esDepth = 3; private static int methodExamine1= 2; - private static void goSleep(long ms) { - try { - Thread.sleep(ms); - } catch (InterruptedException e) { - e.printStackTrace(); - System.out.println("Unexpected exception."); - testFailed = true; - } - } - private static void checkNullThreadInfo(Thread t) throws Exception { ThreadInfo ti = mbean.getThreadInfo(t.getId()); if (ti != null) { @@ -96,7 +86,7 @@ "is waiting to begin."); // The Examiner should be waiting to be notified by the BlockedThread - checkThreadState(examiner, Thread.State.WAITING); + Utils.checkThreadState(examiner, Thread.State.WAITING); // Check that the stack is returned correctly for a new thread checkStack(examiner, examinerStack, esDepth); @@ -135,35 +125,6 @@ } } - private static void checkThreadState(Thread thread, Thread.State s) - throws Exception { - - ThreadInfo ti = mbean.getThreadInfo(thread.getId()); - if (ti.getThreadState() != s) { - ThreadInfo info = - mbean.getThreadInfo(thread.getId(), Integer.MAX_VALUE); - System.out.println(INDENT + "TEST FAILED:"); - printStack(thread, info.getStackTrace()); - System.out.println(INDENT + "Thread state: " + info.getThreadState()); - - throw new RuntimeException("TEST FAILED: " + - "Thread state for " + thread + " returns " + ti.getThreadState() + - ". Expected to be " + s); - } - } - - private static void checkThreadState(Thread thread, - Thread.State s1, Thread.State s2) - throws Exception { - - ThreadInfo ti = mbean.getThreadInfo(thread.getId()); - if (ti.getThreadState() != s1 && ti.getThreadState() != s2) { - throw new RuntimeException("TEST FAILED: " + - "Thread state for " + thread + " returns " + ti.getThreadState() + - ". Expected to be " + s1 + " or " + s2); - } - } - private static void checkStack(Thread t, String[] expectedStack, int depth) throws Exception { ThreadInfo ti = mbean.getThreadInfo(t.getId(), Integer.MAX_VALUE); @@ -197,20 +158,20 @@ handshake.semaP(); // give a chance for the examiner thread to really wait - goSleep(20); + Utils.goSleep(20); } void waitUntilLockAReleased() { handshake.semaP(); // give a chance for the examiner thread to really wait - goSleep(50); + Utils.goSleep(50); } private void notifyWaiter() { // wait until the examiner waits on the semaphore while (handshake.getWaiterCount() == 0) { - goSleep(20); + Utils.goSleep(20); } handshake.semaV(); } @@ -278,10 +239,10 @@ // wait until the examiner is waiting for blockedThread's notification while (!blockedThread.hasWaitersForBlocked()) { - goSleep(50); + Utils.goSleep(50); } // give a chance for the examiner thread to really wait - goSleep(20); + Utils.goSleep(20); } private Thread itself; @@ -290,7 +251,7 @@ examine2(); try { System.out.println("Checking examiner's its own stack trace"); - checkThreadState(itself, Thread.State.RUNNABLE); + Utils.checkThreadState(itself, Thread.State.RUNNABLE); checkStack(itself, examinerStack, methodExamine1); // wait until blockedThread is blocked on lockB @@ -298,7 +259,7 @@ System.out.println("Checking stack trace for " + "BlockedThread - should be blocked on lockB."); - checkThreadState(blockedThread, Thread.State.BLOCKED); + Utils.checkThreadState(blockedThread, Thread.State.BLOCKED); checkStack(blockedThread, blockedStack, methodB); } catch (Exception e) { e.printStackTrace(); @@ -312,7 +273,7 @@ synchronized (lockA) { // wait until main thread gets signalled of the semaphore while (handshake.getWaiterCount() == 0) { - goSleep(20); + Utils.goSleep(20); } handshake.semaV(); // notify the main thread @@ -321,12 +282,12 @@ blockedThread.waitUntilBlocked(); System.out.println("Checking examiner's its own stack trace"); - checkThreadState(itself, Thread.State.RUNNABLE); + Utils.checkThreadState(itself, Thread.State.RUNNABLE); checkStack(itself, examinerStack, esDepth); System.out.println("Checking stack trace for " + "BlockedThread - should be blocked on lockA."); - checkThreadState(blockedThread, Thread.State.BLOCKED); + Utils.checkThreadState(blockedThread, Thread.State.BLOCKED); checkStack(blockedThread, blockedStack, bsDepth); } catch (Exception e) { @@ -344,7 +305,7 @@ try { System.out.println("Checking stack trace for " + "BlockedThread - should be waiting on lockA."); - checkThreadState(blockedThread, Thread.State.WAITING); + Utils.checkThreadState(blockedThread, Thread.State.WAITING); checkStack(blockedThread, blockedStack, bsDepth); // Let the blocked thread go @@ -357,7 +318,7 @@ } } // give some time for BlockedThread to proceed - goSleep(50); + Utils.goSleep(50); } // examine2() public void run() { diff -r 131e94bf12c3 -r a2a950ba257f jdk/test/java/lang/management/ThreadMXBean/ThreadStateTest.java --- a/jdk/test/java/lang/management/ThreadMXBean/ThreadStateTest.java Wed May 27 13:20:23 2009 -0700 +++ b/jdk/test/java/lang/management/ThreadMXBean/ThreadStateTest.java Wed May 27 15:32:21 2009 -0700 @@ -24,14 +24,13 @@ /* * @test * @bug 4967283 5080203 - * @ignore Due to 5080203, cannot rely on this test always passing. * @summary Basic unit test of thread states returned by * ThreadMXBean.getThreadInfo.getThreadState(). * It also tests lock information returned by ThreadInfo. * * @author Mandy Chung * - * @build ThreadExecutionSynchronizer + * @build ThreadExecutionSynchronizer Utils * @run main ThreadStateTest */ @@ -43,7 +42,6 @@ public class ThreadStateTest { private static final ThreadMXBean tm = ManagementFactory.getThreadMXBean(); - private static boolean testFailed = false; static class Lock { private String name; @@ -64,32 +62,32 @@ MyThread myThread = new MyThread("MyThread"); // before myThread starts - // checkThreadState(myThread, Thread.State.NEW); + // Utils.checkThreadState(myThread, Thread.State.NEW); myThread.start(); myThread.waitUntilStarted(); - checkThreadState(myThread, Thread.State.RUNNABLE); + Utils.checkThreadState(myThread, Thread.State.RUNNABLE); checkLockInfo(myThread, Thread.State.RUNNABLE, null, null); myThread.suspend(); - goSleep(10); + Utils.goSleep(10); checkSuspendedThreadState(myThread, Thread.State.RUNNABLE); myThread.resume(); synchronized (globalLock) { myThread.goBlocked(); - checkThreadState(myThread, Thread.State.BLOCKED); + Utils.checkThreadState(myThread, Thread.State.BLOCKED); checkLockInfo(myThread, Thread.State.BLOCKED, globalLock, Thread.currentThread()); } myThread.goWaiting(); - checkThreadState(myThread, Thread.State.WAITING); + Utils.checkThreadState(myThread, Thread.State.WAITING); checkLockInfo(myThread, Thread.State.WAITING, globalLock, null); myThread.goTimedWaiting(); - checkThreadState(myThread, Thread.State.TIMED_WAITING); + Utils.checkThreadState(myThread, Thread.State.TIMED_WAITING); checkLockInfo(myThread, Thread.State.TIMED_WAITING, globalLock, null); @@ -102,32 +100,30 @@ Bug ID : 5062095 *********************************************** myThread.goParked(); - checkThreadState(myThread, Thread.State.WAITING); + Utils.checkThreadState(myThread, Thread.State.WAITING); checkLockInfo(myThread, Thread.State.WAITING, null, null); myThread.goTimedParked(); - checkThreadState(myThread, Thread.State.TIMED_WAITING); + Utils.checkThreadState(myThread, Thread.State.TIMED_WAITING); checkLockInfo(myThread, Thread.State.TIMED_WAITING, null, null); */ myThread.goSleeping(); - checkThreadState(myThread, Thread.State.TIMED_WAITING); + Utils.checkThreadState(myThread, Thread.State.TIMED_WAITING); checkLockInfo(myThread, Thread.State.TIMED_WAITING, null, null); myThread.terminate(); - // checkThreadState(myThread, ThreadState.TERMINATED); + // Utils.checkThreadState(myThread, ThreadState.TERMINATED); try { myThread.join(); } catch (InterruptedException e) { e.printStackTrace(); - System.out.println("Unexpected exception."); - testFailed = true; + System.out.println("TEST FAILED: Unexpected exception."); + throw new RuntimeException(e); } - if (testFailed) - throw new RuntimeException("TEST FAILED."); System.out.println("Test passed."); } @@ -148,32 +144,7 @@ throw new RuntimeException(t.getName() + " expected to be suspended " + " but isSuspended() returns " + info.isSuspended()); } - checkThreadState(t, state); - } - - private static void checkThreadState(Thread t, Thread.State expected) { - ThreadInfo ti = tm.getThreadInfo(t.getId()); - Thread.State state = ti.getThreadState(); - if (state == null) { - throw new RuntimeException(t.getName() + " expected to have " + - expected + " but got null."); - } - - if (state != expected) { - if (expected == Thread.State.BLOCKED) { - int retryCount=0; - while (ti.getThreadState() != expected) { - if (retryCount >= 500) { - throw new RuntimeException(t.getName() + - " expected to have " + expected + " but got " + state); - } - goSleep(100); - } - } else { - throw new RuntimeException(t.getName() + " expected to have " + - expected + " but got " + state); - } - } + Utils.checkThreadState(t, state); } private static String getLockName(Object lock) { @@ -250,16 +221,6 @@ } } - private static void goSleep(long ms) { - try { - Thread.sleep(ms); - } catch (InterruptedException e) { - e.printStackTrace(); - System.out.println("Unexpected exception."); - testFailed = true; - } - } - static class MyThread extends Thread { private ThreadExecutionSynchronizer thrsync = new ThreadExecutionSynchronizer(); @@ -335,7 +296,7 @@ LockSupport.park(); // give a chance for the main thread to block System.out.println(" myThread is going to park."); - goSleep(10); + Utils.goSleep(10); break; } case TIMED_PARKED: { @@ -346,7 +307,7 @@ LockSupport.parkUntil(deadline); // give a chance for the main thread to block - goSleep(10); + Utils.goSleep(10); break; } case SLEEPING: { @@ -375,7 +336,7 @@ public void waitUntilStarted() { // wait for MyThread. thrsync.waitForSignal(); - goSleep(10); + Utils.goSleep(10); } public void goBlocked() { @@ -383,7 +344,7 @@ setState(BLOCKED); // wait for MyThread to get blocked thrsync.waitForSignal(); - goSleep(20); + Utils.goSleep(20); } public void goWaiting() { @@ -391,28 +352,28 @@ setState(WAITING); // wait for MyThread to wait on object. thrsync.waitForSignal(); - goSleep(20); + Utils.goSleep(20); } public void goTimedWaiting() { System.out.println("Waiting myThread to go timed waiting."); setState(TIMED_WAITING); // wait for MyThread timed wait call. thrsync.waitForSignal(); - goSleep(20); + Utils.goSleep(20); } public void goParked() { System.out.println("Waiting myThread to go parked."); setState(PARKED); // wait for MyThread state change to PARKED. thrsync.waitForSignal(); - goSleep(20); + Utils.goSleep(20); } public void goTimedParked() { System.out.println("Waiting myThread to go timed parked."); setState(TIMED_PARKED); // wait for MyThread. thrsync.waitForSignal(); - goSleep(20); + Utils.goSleep(20); } public void goSleeping() { @@ -420,21 +381,21 @@ setState(SLEEPING); // wait for MyThread. thrsync.waitForSignal(); - goSleep(20); + Utils.goSleep(20); } public void terminate() { System.out.println("Waiting myThread to terminate."); setState(TERMINATE); // wait for MyThread. thrsync.waitForSignal(); - goSleep(20); + Utils.goSleep(20); } private void setState(int newState) { switch (state) { case BLOCKED: while (state == BLOCKED) { - goSleep(20); + Utils.goSleep(20); } state = newState; break; diff -r 131e94bf12c3 -r a2a950ba257f jdk/test/java/lang/management/ThreadMXBean/Utils.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/jdk/test/java/lang/management/ThreadMXBean/Utils.java Wed May 27 15:32:21 2009 -0700 @@ -0,0 +1,79 @@ +/* + * Copyright 2003-2006 Sun Microsystems, Inc. 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. + * + * 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + */ + +/* + * Utility class for ThreadMXBean tests + */ +import java.lang.management.ManagementFactory; +import java.lang.management.ThreadMXBean; + +public class Utils { + private static final ThreadMXBean tm = ManagementFactory.getThreadMXBean(); + private static final int MAX_RETRY = 200; + + public static boolean waitForBlockWaitingState(Thread t) { + // wait for the thread to transition to the expected state + int retryCount=0; + while (t.getState() == Thread.State.RUNNABLE && retryCount < MAX_RETRY) { + goSleep(100); + retryCount++; + } + return (t.getState() != Thread.State.RUNNABLE); + } + + public static boolean waitForThreadState(Thread t, Thread.State expected) { + // wait for the thread to transition to the expected state + int retryCount=0; + while (t.getState() != expected && retryCount < MAX_RETRY) { + goSleep(100); + retryCount++; + } + return (t.getState() == expected); + } + + public static void checkThreadState(Thread t, Thread.State expected) { + waitForThreadState(t, expected); + + Thread.State state = tm.getThreadInfo(t.getId()).getThreadState(); + if (state == null) { + throw new RuntimeException(t.getName() + " expected to have " + + expected + " but got null."); + } + if (state != expected) { + t.dumpStack(); + throw new RuntimeException(t.getName() + + " expected to have " + expected + " but got " + state); + } + } + + public static void goSleep(long ms) { + try { + Thread.sleep(ms); + } catch (InterruptedException e) { + e.printStackTrace(); + System.out.println("TEST FAILED: Unexpected exception."); + throw new RuntimeException(e); + } + } + +} diff -r 131e94bf12c3 -r a2a950ba257f jdk/test/java/util/logging/LoggingDeadlock2.java --- a/jdk/test/java/util/logging/LoggingDeadlock2.java Wed May 27 13:20:23 2009 -0700 +++ b/jdk/test/java/util/logging/LoggingDeadlock2.java Wed May 27 15:32:21 2009 -0700 @@ -24,7 +24,6 @@ /* * @test * @bug 6467152 6716076 6829503 - * @ignore Until made more stable, see 6829636. * @summary deadlock occurs in LogManager initialization and JVM termination * @author Serguei Spitsyn / Hitachi / Martin Buchholz *