infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-01-28 12:09:14 +00:00
Code Issues Packages Projects Releases Wiki Activity

8365483: Test sun/rmi/runtime/Log/6409194/NoConsoleOutput.java sometimes fails

Browse Source 
Reviewed-by: dfuchs, jpai
This commit is contained in:
David Beaumont 2025-09-10 11:49:02 +00:00 committed by Daniel Fuchs
parent edae355e95
commit 4d4e51c41f
2 changed files with 145 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
src/java.logging/share/classes/java/util/logging/StreamHandler.java
View File

@ -214,13 +214,16 @@ public class StreamHandler extends Handler {
try {
synchronized (this) {
// Re-check writer between isLoggable() and here.
Writer writer = this.writer;
if (!doneHeader) {
writer.write(formatter.getHead(this));
doneHeader = true;
if (writer != null) {
if (!doneHeader) {
writer.write(formatter.getHead(this));
doneHeader = true;
}
writer.write(msg);
synchronousPostWriteHook();
}
writer.write(msg);
synchronousPostWriteHook();
}
} catch (Exception ex) {
// We don't want to throw an exception here, but we

137
test/jdk/java/util/logging/StreamHandlerRacyCloseTest.java Normal file
View File

@ -0,0 +1,137 @@
/*
* Copyright (c) 2025, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
import java.io.ByteArrayOutputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicReference;
import java.util.logging.ErrorManager;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.SimpleFormatter;
import java.util.logging.StreamHandler;
import org.junit.jupiter.api.Test;
/*
* @test
* @bug 8365483
* @summary verify that concurrent calls to publish() and close() on a
* StreamHandler do not cause unexpected exceptions
* @run junit StreamHandlerRacyCloseTest
*/
public class StreamHandlerRacyCloseTest {
private static final class ExceptionTrackingErrorManager extends ErrorManager {
private final AtomicReference<Exception> firstError = new AtomicReference<>();
@Override
public void error(String msg, Exception ex, int code) {
// just track one/first exception, that's good enough for this test
this.firstError.compareAndSet(null, new RuntimeException(msg, ex));
}
}
@Test
void testRacyClose() throws Exception {
final int numTimes = 100;
try (ExecutorService executor = Executors.newFixedThreadPool(numTimes)) {
final List<Callable<Void>> tasks = new ArrayList<>();
for (int i = 1; i <= numTimes; i++) {
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
// construct a StreamHandler with an ErrorManager which propagates
// any errors that happen during publish()
final StreamHandler handler = new StreamHandler(baos, new SimpleFormatter());
handler.setErrorManager(new ExceptionTrackingErrorManager());
final CountDownLatch latch = new CountDownLatch(2);
// create a publisher and closer task which will run concurrently
tasks.add(new Publisher(handler, latch));
tasks.add(new Closer(handler, latch));
}
// submit the tasks and expect successful completion of each
final List<Future<Void>> completed = executor.invokeAll(tasks);
for (var f : completed) {
f.get();
}
}
}
private static final class Closer implements Callable<Void> {
private final StreamHandler handler;
private final CountDownLatch startLatch;
private Closer(final StreamHandler handler, final CountDownLatch startLatch) {
this.handler = handler;
this.startLatch = startLatch;
}
@Override
public Void call() throws Exception {
// notify the other task of our readiness
this.startLatch.countDown();
// wait for the other task to arrive
this.startLatch.await();
// close the handler
this.handler.close();
// propagate any exception that may have been caught by the error manager
final var errMgr = (ExceptionTrackingErrorManager) this.handler.getErrorManager();
if (errMgr.firstError.get() != null) {
throw errMgr.firstError.get();
}
return null;
}
}
private static final class Publisher implements Callable<Void> {
private final StreamHandler handler;
private final CountDownLatch startLatch;
private Publisher(final StreamHandler handler, final CountDownLatch startLatch) {
this.handler = handler;
this.startLatch = startLatch;
}
@Override
public Void call() throws Exception {
final LogRecord record = new LogRecord(Level.WARNING, "hello world");
// notify the other task of our readiness
this.startLatch.countDown();
// wait for the other task to arrive
this.startLatch.await();
// publish the record
this.handler.publish(record);
// propagate any exception that may have been caught by the error manager
final var errMgr = (ExceptionTrackingErrorManager) this.handler.getErrorManager();
if (errMgr.firstError.get() != null) {
throw errMgr.firstError.get();
}
return null;
}
}
}