jdk-sandbox: comparison src/jdk.incubator.httpclient/share/classes/jdk/incubator/http/internal/common/SequentialScheduler.java

equal deleted inserted replaced

-:01739771e48b
+:f8eabb9a5c0f
 /*
-* Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2016, 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.  Oracle designates this
 */
 void run(DeferredCompleter taskCompleter);
 }
 /**
-* A complete restartable task is one which is simple and self-contained.
+* A simple and self-contained task that completes once its {@code run}
-* It completes once its {@code run} method returns.
+* method returns.
 */
 public static abstract class CompleteRestartableTask
 implements RestartableTask
 {
 @Override
 /** The body of the task. */
 protected abstract void run();
 }
 /**
-* A RestartableTask that runs its main loop within a
+* A task that runs its main loop within a synchronized block to provide
-* synchronized block to place a memory barrier around it.
+* memory visibility between runs. Since the main loop can't run concurrently,
-* Because the main loop can't run concurrently in two treads,
+* the lock shouldn't be contended and no deadlock should ever be possible.
-* then the lock shouldn't be contended and no deadlock should
-* ever be possible.
 */
 public static final class SynchronizedRestartableTask
 extends CompleteRestartableTask {
 private final Runnable mainLoop;
 private final Object lock = new Object();
 public SynchronizedRestartableTask(Runnable mainLoop) {
 this.mainLoop = mainLoop;
 }
 @Override
 private final RestartableTask restartableTask;
 private final DeferredCompleter completer;
 private final SchedulableTask schedulableTask;
 /**
-* A simple task that can be pushed on an executor to execute
+* An auxiliary task that starts the restartable task:
 * {@code restartableTask.run(completer)}.
 */
 private final class SchedulableTask implements Runnable {
 @Override
 public void run() {
 public void runOrSchedule() {
 runOrSchedule(schedulableTask, null);
 }
 /**
-* Runs or schedules the task to be run in the provided executor.
+* Executes or schedules the task to be executed in the provided executor.
 *
 * <p> This method can be used when potential executing from a calling
 * thread is not desirable.
 *
 * @param executor
 *         An executor in which to execute the task, if the task needs
 *         to be executed.
 *
 * @apiNote The given executor can be {@code null} in which case calling
-* {@code deferOrSchedule(null)} is strictly equivalent to calling
+* {@code runOrSchedule(null)} is strictly equivalent to calling
 * {@code runOrSchedule()}.
 */
-public void deferOrSchedule(Executor executor) { // TODO: why this name? why not runOrSchedule?
+public void runOrSchedule(Executor executor) {
 runOrSchedule(schedulableTask, executor);
 }
 private void runOrSchedule(SchedulableTask task, Executor executor) {
 while (true) {
 /**
 * Returns a new {@code SequentialScheduler} that executes the provided
 * {@code mainLoop} from within a {@link SynchronizedRestartableTask}.
 *
-* @apiNote
+* @apiNote This is equivalent to calling
-* This is equivalent to calling
+* {@code new SequentialScheduler(new SynchronizedRestartableTask(mainLoop))}
-* {@code new SequentialScheduler(new SynchronizedRestartableTask(mainloop));}
+* The main loop must not perform any blocking operation.
-* The main loop must not do any blocking operation.
+*
-*
+* @param mainLoop The main loop of the new sequential scheduler
-* @param mainloop The main loop of the new sequential scheduler.
 * @return a new {@code SequentialScheduler} that executes the provided
 * {@code mainLoop} from within a {@link SynchronizedRestartableTask}.
 */
-public static SequentialScheduler synchronizedScheduler(Runnable mainloop) {
+public static SequentialScheduler synchronizedScheduler(Runnable mainLoop) {
-return new SequentialScheduler(new SynchronizedRestartableTask(mainloop));
+return new SequentialScheduler(new SynchronizedRestartableTask(mainLoop));
 }
 }

branch	http-client-branch
changeset 56040	f8eabb9a5c0f
parent 55973	4d9b002587db