1 /* 2 * Copyright (c) 2023, 2024, 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. 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 id=default 26 * @summary Test virtual thread with monitor enter/exit 27 * @modules java.base/java.lang:+open jdk.management 28 * @library /test/lib 29 * @run junit/othervm --enable-native-access=ALL-UNNAMED MonitorEnterExit 30 */ 31 32 import java.time.Duration; 33 import java.util.ArrayList; 34 import java.util.List; 35 import java.util.concurrent.CountDownLatch; 36 import java.util.concurrent.ThreadFactory; 37 import java.util.concurrent.ThreadLocalRandom; 38 import java.util.concurrent.Executors; 39 import java.util.concurrent.ExecutorService; 40 import java.util.concurrent.atomic.AtomicBoolean; 41 import java.util.concurrent.locks.LockSupport; 42 import java.util.stream.IntStream; 43 import java.util.stream.Stream; 44 45 import jdk.test.lib.thread.VThreadPinner; 46 import jdk.test.lib.thread.VThreadRunner; // ensureParallelism requires jdk.management 47 import jdk.test.lib.thread.VThreadScheduler; 48 import org.junit.jupiter.api.Test; 49 import org.junit.jupiter.api.BeforeAll; 50 import org.junit.jupiter.api.RepeatedTest; 51 import org.junit.jupiter.params.ParameterizedTest; 52 import org.junit.jupiter.params.provider.Arguments; 53 import org.junit.jupiter.params.provider.ValueSource; 54 import org.junit.jupiter.params.provider.MethodSource; 55 import org.junit.jupiter.api.condition.*; 56 import static org.junit.jupiter.api.Assertions.*; 57 import static org.junit.jupiter.api.Assumptions.*; 58 59 class MonitorEnterExit { 60 static final int MAX_ENTER_DEPTH = 256; 61 62 @BeforeAll 63 static void setup() { 64 // need >=2 carriers for testing pinning when main thread is a virtual thread 65 if (Thread.currentThread().isVirtual()) { 66 VThreadRunner.ensureParallelism(2); 67 } 68 } 69 70 /** 71 * Test monitor enter with no contention. 72 */ 73 @Test 74 void testEnterNoContention() throws Exception { 75 var lock = new Object(); 76 VThreadRunner.run(() -> { 77 synchronized (lock) { 78 assertTrue(Thread.holdsLock(lock)); 79 } 80 assertFalse(Thread.holdsLock(lock)); 81 }); 82 } 83 84 /** 85 * Test monitor enter with contention, monitor is held by platform thread. 86 */ 87 @Test 88 void testEnterWhenHeldByPlatformThread() throws Exception { 89 testEnterWithContention(); 90 } 91 92 /** 93 * Test monitor enter with contention, monitor is held by virtual thread. 94 */ 95 @Test 96 void testEnterWhenHeldByVirtualThread() throws Exception { 97 VThreadRunner.run(this::testEnterWithContention); 98 } 99 100 /** 101 * Test monitor enter with contention, monitor will be held by caller thread. 102 */ 103 private void testEnterWithContention() throws Exception { 104 var lock = new Object(); 105 var started = new CountDownLatch(1); 106 var entered = new AtomicBoolean(); 107 var vthread = Thread.ofVirtual().unstarted(() -> { 108 started.countDown(); 109 synchronized (lock) { 110 assertTrue(Thread.holdsLock(lock)); 111 entered.set(true); 112 } 113 assertFalse(Thread.holdsLock(lock)); 114 }); 115 try { 116 synchronized (lock) { 117 vthread.start(); 118 119 // wait for thread to start and block 120 started.await(); 121 await(vthread, Thread.State.BLOCKED); 122 123 assertFalse(entered.get()); 124 } 125 } finally { 126 vthread.join(); 127 } 128 assertTrue(entered.get()); 129 } 130 131 /** 132 * Test monitor reenter. 133 */ 134 @Test 135 void testReenter() throws Exception { 136 var lock = new Object(); 137 VThreadRunner.run(() -> { 138 testReenter(lock, 0); 139 assertFalse(Thread.holdsLock(lock)); 140 }); 141 } 142 143 private void testReenter(Object lock, int depth) { 144 if (depth < MAX_ENTER_DEPTH) { 145 synchronized (lock) { 146 assertTrue(Thread.holdsLock(lock)); 147 testReenter(lock, depth + 1); 148 assertTrue(Thread.holdsLock(lock)); 149 } 150 } 151 } 152 153 /** 154 * Test monitor enter when pinned. 155 */ 156 @Test 157 void testEnterWhenPinned() throws Exception { 158 var lock = new Object(); 159 VThreadPinner.runPinned(() -> { 160 synchronized (lock) { 161 assertTrue(Thread.holdsLock(lock)); 162 } 163 assertFalse(Thread.holdsLock(lock)); 164 }); 165 } 166 167 /** 168 * Test monitor reenter when pinned. 169 */ 170 @Test 171 void testReenterWhenPinned() throws Exception { 172 VThreadRunner.run(() -> { 173 var lock = new Object(); 174 synchronized (lock) { 175 VThreadPinner.runPinned(() -> { 176 assertTrue(Thread.holdsLock(lock)); 177 synchronized (lock) { 178 assertTrue(Thread.holdsLock(lock)); 179 } 180 assertTrue(Thread.holdsLock(lock)); 181 }); 182 } 183 assertFalse(Thread.holdsLock(lock)); 184 }); 185 } 186 187 /** 188 * Test contended monitor enter when pinned. Monitor is held by platform thread. 189 */ 190 @Test 191 void testContendedEnterWhenPinnedHeldByPlatformThread() throws Exception { 192 testEnterWithContentionWhenPinned(); 193 } 194 195 /** 196 * Test contended monitor enter when pinned. Monitor is held by virtual thread. 197 */ 198 @Test 199 void testContendedEnterWhenPinnedHeldByVirtualThread() throws Exception { 200 // need at least two carrier threads 201 int previousParallelism = VThreadRunner.ensureParallelism(2); 202 try { 203 VThreadRunner.run(this::testEnterWithContentionWhenPinned); 204 } finally { 205 VThreadRunner.setParallelism(previousParallelism); 206 } 207 } 208 209 /** 210 * Test contended monitor enter when pinned, monitor will be held by caller thread. 211 */ 212 private void testEnterWithContentionWhenPinned() throws Exception { 213 var lock = new Object(); 214 var started = new CountDownLatch(1); 215 var entered = new AtomicBoolean(); 216 Thread vthread = Thread.ofVirtual().unstarted(() -> { 217 VThreadPinner.runPinned(() -> { 218 started.countDown(); 219 synchronized (lock) { 220 entered.set(true); 221 } 222 }); 223 }); 224 synchronized (lock) { 225 // start thread and wait for it to block 226 vthread.start(); 227 started.await(); 228 await(vthread, Thread.State.BLOCKED); 229 assertFalse(entered.get()); 230 } 231 vthread.join(); 232 233 // check thread entered monitor 234 assertTrue(entered.get()); 235 } 236 237 /** 238 * Returns a stream of elements that are ordered pairs of platform and virtual thread 239 * counts. 0,2,4,..16 platform threads. 2,4,6,..32 virtual threads. 240 */ 241 static Stream<Arguments> threadCounts() { 242 return IntStream.range(0, 17) 243 .filter(i -> i % 2 == 0) 244 .mapToObj(i -> i) 245 .flatMap(np -> IntStream.range(2, 33) 246 .filter(i -> i % 2 == 0) 247 .mapToObj(vp -> Arguments.of(np, vp))); 248 } 249 250 /** 251 * Test mutual exclusion of monitors with platform and virtual threads. 252 */ 253 @ParameterizedTest 254 @MethodSource("threadCounts") 255 void testMutualExclusion(int nPlatformThreads, int nVirtualThreads) throws Exception { 256 class Counter { 257 int count; 258 synchronized void increment() { 259 count++; 260 Thread.yield(); 261 } 262 } 263 var counter = new Counter(); 264 int nThreads = nPlatformThreads + nVirtualThreads; 265 var threads = new Thread[nThreads]; 266 int index = 0; 267 for (int i = 0; i < nPlatformThreads; i++) { 268 threads[index] = Thread.ofPlatform() 269 .name("platform-" + index) 270 .unstarted(counter::increment); 271 index++; 272 } 273 for (int i = 0; i < nVirtualThreads; i++) { 274 threads[index] = Thread.ofVirtual() 275 .name("virtual-" + index) 276 .unstarted(counter::increment); 277 index++; 278 } 279 // start all threads 280 for (Thread thread : threads) { 281 thread.start(); 282 } 283 // wait for all threads to terminate 284 for (Thread thread : threads) { 285 thread.join(); 286 } 287 assertEquals(nThreads, counter.count); 288 } 289 290 /** 291 * Test unblocking a virtual thread waiting to enter a monitor held by a platform thread. 292 */ 293 @RepeatedTest(20) 294 void testUnblockingByPlatformThread() throws Exception { 295 testUnblocking(); 296 } 297 298 /** 299 * Test unblocking a virtual thread waiting to enter a monitor held by another 300 * virtual thread. 301 */ 302 @RepeatedTest(20) 303 void testUnblockingByVirtualThread() throws Exception { 304 VThreadRunner.run(this::testUnblocking); 305 } 306 307 /** 308 * Test unblocking a virtual thread waiting to enter a monitor, monitor will be 309 * initially be held by caller thread. 310 */ 311 private void testUnblocking() throws Exception { 312 var lock = new Object(); 313 var started = new CountDownLatch(1); 314 var entered = new AtomicBoolean(); 315 var vthread = Thread.ofVirtual().unstarted(() -> { 316 started.countDown(); 317 synchronized (lock) { 318 entered.set(true); 319 } 320 }); 321 try { 322 synchronized (lock) { 323 vthread.start(); 324 started.await(); 325 326 // random delay before exiting monitor 327 switch (ThreadLocalRandom.current().nextInt(4)) { 328 case 0 -> { /* no delay */} 329 case 1 -> Thread.onSpinWait(); 330 case 2 -> Thread.yield(); 331 case 3 -> await(vthread, Thread.State.BLOCKED); 332 default -> fail(); 333 } 334 335 assertFalse(entered.get()); 336 } 337 } finally { 338 vthread.join(); 339 } 340 assertTrue(entered.get()); 341 } 342 343 /** 344 * Test that unblocking a virtual thread waiting to enter a monitor does not consume 345 * the thread's parking permit. 346 */ 347 @Test 348 void testParkingPermitNotConsumed() throws Exception { 349 var lock = new Object(); 350 var started = new CountDownLatch(1); 351 var vthread = Thread.ofVirtual().unstarted(() -> { 352 started.countDown(); 353 LockSupport.unpark(Thread.currentThread()); 354 synchronized (lock) { } // should block 355 LockSupport.park(); // should not park 356 }); 357 358 synchronized (lock) { 359 vthread.start(); 360 // wait for thread to start and block 361 started.await(); 362 await(vthread, Thread.State.BLOCKED); 363 } 364 vthread.join(); 365 } 366 367 /** 368 * Test that unblocking a virtual thread waiting to enter a monitor does not make 369 * available the thread's parking permit. 370 */ 371 @Test 372 void testParkingPermitNotOffered() throws Exception { 373 var lock = new Object(); 374 var started = new CountDownLatch(1); 375 var vthread = Thread.ofVirtual().unstarted(() -> { 376 started.countDown(); 377 synchronized (lock) { } // should block 378 LockSupport.park(); // should park 379 }); 380 381 synchronized (lock) { 382 vthread.start(); 383 // wait for thread to start and block 384 started.await(); 385 await(vthread, Thread.State.BLOCKED); 386 } 387 388 try { 389 // wait for thread to park, it should not terminate 390 await(vthread, Thread.State.WAITING); 391 vthread.join(Duration.ofMillis(100)); 392 assertEquals(Thread.State.WAITING, vthread.getState()); 393 } finally { 394 LockSupport.unpark(vthread); 395 vthread.join(); 396 } 397 } 398 399 /** 400 * Waits for the given thread to reach a given state. 401 */ 402 private void await(Thread thread, Thread.State expectedState) throws InterruptedException { 403 Thread.State state = thread.getState(); 404 while (state != expectedState) { 405 assertTrue(state != Thread.State.TERMINATED, "Thread has terminated"); 406 Thread.sleep(10); 407 state = thread.getState(); 408 } 409 } 410 }