| /* |
| * Copyright (c) 2018, 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. |
| */ |
| |
| /* @test |
| * @bug 8198928 |
| * @library /test/lib |
| * @build jdk.test.lib.Utils |
| * @run main CloseDuringConnect |
| * @summary Attempt to cause a deadlock by closing a SocketChannel in one thread |
| * where another thread is closing the channel after a connect fail |
| */ |
| |
| import java.io.IOException; |
| import java.io.UncheckedIOException; |
| import java.net.InetAddress; |
| import java.net.InetSocketAddress; |
| import java.net.SocketAddress; |
| import java.nio.channels.SocketChannel; |
| import java.util.concurrent.Executors; |
| import java.util.concurrent.Future; |
| import java.util.concurrent.ScheduledExecutorService; |
| import java.util.stream.IntStream; |
| import static java.util.concurrent.TimeUnit.MILLISECONDS; |
| |
| import jdk.test.lib.Utils; |
| |
| public class CloseDuringConnect { |
| |
| // number of test iterations, needs to be 5-10 at least |
| static final int ITERATIONS = 50; |
| |
| // maximum delay before closing SocketChannel, in milliseconds |
| static final int MAX_DELAY_BEFORE_CLOSE = 20; |
| |
| /** |
| * Invoked by a task in the thread pool to connect to a remote address. |
| * The connection should never be established. |
| */ |
| static Void connect(SocketChannel sc, SocketAddress remote) { |
| try { |
| if (!sc.connect(remote)) { |
| while (!sc.finishConnect()) { |
| Thread.yield(); |
| } |
| } |
| throw new RuntimeException("Connected, should not happen"); |
| } catch (IOException expected) { } |
| if (sc.isConnected()) |
| throw new RuntimeException("isConnected return true, should not happen"); |
| return null; |
| } |
| |
| /** |
| * Invoked by a task in the thread pool to close a socket channel. |
| */ |
| static Void close(SocketChannel sc) { |
| try { |
| sc.close(); |
| } catch (IOException e) { |
| throw new UncheckedIOException("close failed", e); |
| } |
| return null; |
| } |
| |
| /** |
| * Test for deadlock by submitting a task to connect to the given address |
| * while another task closes the socket channel. |
| * @param pool the thread pool to submit or schedule tasks |
| * @param remote the remote address, does not accept connections |
| * @param blocking socket channel blocking mode |
| * @param delay the delay, in millis, before closing the channel |
| */ |
| static void test(ScheduledExecutorService pool, |
| SocketAddress remote, |
| boolean blocking, |
| long delay) { |
| try { |
| SocketChannel sc = SocketChannel.open(); |
| sc.configureBlocking(blocking); |
| Future<Void> r1 = pool.submit(() -> connect(sc, remote)); |
| Future<Void> r2 = pool.schedule(() -> close(sc), delay, MILLISECONDS); |
| r1.get(); |
| r2.get(); |
| } catch (Throwable t) { |
| throw new RuntimeException("Test failed", t); |
| } |
| } |
| |
| public static void main(String[] args) throws Exception { |
| SocketAddress refusing = Utils.refusingEndpoint(); |
| ScheduledExecutorService pool = Executors.newScheduledThreadPool(2); |
| try { |
| IntStream.range(0, ITERATIONS).forEach(i -> { |
| System.out.format("Iteration %d ...%n", (i + 1)); |
| |
| // Execute the test for varying delays up to MAX_DELAY_BEFORE_CLOSE, |
| // for socket channels configured both blocking and non-blocking |
| IntStream.range(0, MAX_DELAY_BEFORE_CLOSE).forEach(delay -> { |
| test(pool, refusing, /*blocking mode*/true, delay); |
| test(pool, refusing, /*blocking mode*/false, delay); |
| }); |
| }); |
| } finally { |
| pool.shutdown(); |
| } |
| } |
| } |