diff --git a/servlet/src/main/java/io/grpc/servlet/AsyncServletOutputStreamWriter.java b/servlet/src/main/java/io/grpc/servlet/AsyncServletOutputStreamWriter.java
index 67001085b02..7a9a689cfa0 100644
--- a/servlet/src/main/java/io/grpc/servlet/AsyncServletOutputStreamWriter.java
+++ b/servlet/src/main/java/io/grpc/servlet/AsyncServletOutputStreamWriter.java
@@ -16,13 +16,11 @@
 
 package io.grpc.servlet;
 
-import static com.google.common.base.Preconditions.checkState;
 import static io.grpc.servlet.ServletServerStream.toHexString;
 import static java.util.logging.Level.FINE;
 import static java.util.logging.Level.FINEST;
 
 import com.google.common.annotations.VisibleForTesting;
-import com.google.errorprone.annotations.CheckReturnValue;
 import io.grpc.InternalLogId;
 import io.grpc.servlet.ServletServerStream.ServletTransportState;
 import java.io.IOException;
@@ -59,8 +57,18 @@ final class AsyncServletOutputStreamWriter {
    *
    * <p>There are two threads, the container thread (calling {@code onWritePossible()}) and the
    * application thread (calling {@code runOrBuffer()}) that read and update the
-   * writeState. Only onWritePossible() may turn {@code readyAndDrained} from false to true, and
-   * only runOrBuffer() may turn it from true to false.
+   * {@code writeState}. The state machine has three states:
+   * <ul>
+   *   <li>{@code READY_AND_DRAINED}: The stream is ready to receive writes, and the write queue
+   *       is empty.
+   *   <li>{@code NOT_READY_OR_NOT_DRAINED}: The stream is not ready or there is buffered data
+   *       in the write queue.
+   *   <li>{@code WRITING}: An application thread is actively executing a direct write.
+   * </ul>
+   * Only {@code onWritePossible()} may transition from {@code NOT_READY_OR_NOT_DRAINED} to
+   * {@code READY_AND_DRAINED}. Only {@code runOrBuffer()} may transition from
+   * {@code READY_AND_DRAINED} to {@code WRITING}, and from {@code WRITING} back to
+   * {@code READY_AND_DRAINED} or {@code NOT_READY_OR_NOT_DRAINED}.
    */
   private final AtomicReference<WriteState> writeState = new AtomicReference<>(WriteState.DEFAULT);
 
@@ -173,11 +181,22 @@ void complete() {
   /** Called from the container thread {@link javax.servlet.WriteListener#onWritePossible()}. */
   void onWritePossible() throws IOException {
     log.finest("onWritePossible: ENTRY. The servlet output stream becomes ready");
-    if (writeState.get().readyAndDrained) {
-      assureReadyAndDrainedTurnsFalse();
+    if (writeState.get().state == WriteState.WRITING) {
+      if (!assureWritingStateTurnsStateOtherThanWriting()) {
+        return;
+      }
+    }
+    if (writeState.get().state == WriteState.READY_AND_DRAINED) {
+      return;
     }
     while (isReady.getAsBoolean()) {
       WriteState curState = writeState.get();
+      if (curState.state == WriteState.WRITING) {
+        if (!assureWritingStateTurnsStateOtherThanWriting()) {
+          return;
+        }
+        continue;
+      }
 
       ActionItem actionItem = writeChain.poll();
       if (actionItem != null) {
@@ -185,7 +204,7 @@ void onWritePossible() throws IOException {
         continue;
       }
 
-      if (writeState.compareAndSet(curState, curState.withReadyAndDrained(true))) {
+      if (writeState.compareAndSet(curState, new WriteState(WriteState.READY_AND_DRAINED))) {
         // state has not changed since.
         log.finest(
             "onWritePossible: EXIT. All data available now is sent out and the servlet output"
@@ -198,15 +217,21 @@ void onWritePossible() throws IOException {
     log.finest("onWritePossible: EXIT. The servlet output stream becomes not ready");
   }
 
-  private void assureReadyAndDrainedTurnsFalse() {
-    // readyAndDrained should have been set to false already.
-    // Just in case due to a race condition readyAndDrained is still true at this moment and is
-    // being set to false by runOrBuffer() concurrently.
+  private boolean assureWritingStateTurnsStateOtherThanWriting() {
     parkingThread = Thread.currentThread();
-    while (writeState.get().readyAndDrained) {
-      LockSupport.parkNanos(TimeUnit.MINUTES.toNanos(1)); // should return immediately
+    try {
+      while (writeState.get().state == WriteState.WRITING) {
+        LockSupport.parkNanos(TimeUnit.MINUTES.toNanos(1));
+        if (Thread.interrupted()) {
+          Thread.currentThread().interrupt();
+          log.fine("Thread interrupted while parked");
+          return false;
+        }
+      }
+      return true;
+    } finally {
+      parkingThread = null;
     }
-    parkingThread = null;
   }
 
   /**
@@ -216,48 +241,92 @@ private void assureReadyAndDrainedTurnsFalse() {
    * <p>Called from application thread.
    */
   private void runOrBuffer(ActionItem actionItem) throws IOException {
-    WriteState curState = writeState.get();
-    if (curState.readyAndDrained) { // write to the outputStream directly
-      try {
-        actionItem.run();
-      } catch (IllegalStateException e) {
-        if (actionItem == flushAction || actionItem == completeAction) {
-          throw e;
+    ActionItem itemToWrite = actionItem;
+    while (true) {
+      WriteState curState = writeState.get();
+      if (curState.state == WriteState.READY_AND_DRAINED) { // write to the outputStream directly
+        WriteState writingState = new WriteState(WriteState.WRITING);
+        if (writeState.compareAndSet(curState, writingState)) {
+          boolean successfulExited = false;
+          try {
+            while (true) {
+              if (itemToWrite != null) {
+                try {
+                  itemToWrite.run();
+                } catch (IllegalStateException e) {
+                  if (itemToWrite == flushAction || itemToWrite == completeAction) {
+                    throw e;
+                  }
+                  writeChain.offer(itemToWrite);
+                  writeState.set(new WriteState(WriteState.NOT_READY_OR_NOT_DRAINED));
+                  LockSupport.unpark(parkingThread);
+                  successfulExited = true;
+                  return;
+                }
+                if (itemToWrite == completeAction) {
+                  writeState.set(new WriteState(WriteState.NOT_READY_OR_NOT_DRAINED));
+                  LockSupport.unpark(parkingThread);
+                  successfulExited = true;
+                  return;
+                }
+              }
+
+              if (isReady.getAsBoolean()) {
+                itemToWrite = writeChain.poll();
+                if (itemToWrite != null) {
+                  continue;
+                }
+                WriteState latestState = writeState.get();
+                if (latestState.state == WriteState.WRITING) {
+                  if (writeState.compareAndSet(
+                      latestState, new WriteState(WriteState.READY_AND_DRAINED))) {
+                    LockSupport.unpark(parkingThread);
+                    successfulExited = true;
+                    return;
+                  }
+                  // CAS failed, loop again to poll and write
+                } else {
+                  successfulExited = true;
+                  return;
+                }
+              } else {
+                WriteState latestState = writeState.get();
+                if (latestState.state == WriteState.WRITING) {
+                  if (writeState.compareAndSet(
+                      latestState, new WriteState(WriteState.NOT_READY_OR_NOT_DRAINED))) {
+                    LockSupport.unpark(parkingThread);
+                    log.finest("the servlet output stream becomes not ready");
+                    successfulExited = true;
+                    return;
+                  }
+                  // CAS failed, loop again with itemToWrite = null
+                  itemToWrite = null;
+                } else {
+                  successfulExited = true;
+                  return;
+                }
+              }
+            }
+          } finally {
+            if (!successfulExited) {
+              writeState.set(new WriteState(WriteState.NOT_READY_OR_NOT_DRAINED));
+              LockSupport.unpark(parkingThread);
+            }
+          }
+        }
+      } else { // NOT_READY_OR_NOT_DRAINED or WRITING
+        writeChain.offer(itemToWrite);
+        if (writeState.compareAndSet(curState, new WriteState(curState.state))) {
+          return;
+        }
+        itemToWrite = writeChain.poll();
+        if (itemToWrite == null) {
+          return;
         }
-        buffer(actionItem, curState);
-        return;
-      }
-      if (actionItem == completeAction) {
-        return;
-      }
-      if (!isReady.getAsBoolean()) {
-        boolean successful =
-            writeState.compareAndSet(curState, curState.withReadyAndDrained(false));
-        LockSupport.unpark(parkingThread);
-        checkState(successful, "Bug: curState is unexpectedly changed by another thread");
-        log.finest("the servlet output stream becomes not ready");
       }
-    } else { // buffer to the writeChain
-      buffer(actionItem, curState);
     }
   }
 
-  private void buffer(ActionItem actionItem, WriteState curState) throws IOException {
-    writeChain.offer(actionItem);
-    if (writeState.compareAndSet(curState, curState.withReadyAndDrained(false))) {
-      LockSupport.unpark(parkingThread);
-    } else {
-      checkState(
-          writeState.get().readyAndDrained,
-          "Bug: onWritePossible() should have changed readyAndDrained to true, but not");
-      ActionItem lastItem = writeChain.poll();
-      if (lastItem != null) {
-        checkState(lastItem == actionItem, "Bug: lastItem != actionItem");
-        runOrBuffer(lastItem);
-      }
-    } // state has not changed since
-  }
-
   /** Write actions, e.g. writeBytes, flush, complete. */
   @FunctionalInterface
   @VisibleForTesting
@@ -277,34 +346,16 @@ default void finest(String str, Object...params) {}
   }
 
   private static final class WriteState {
+    static final int READY_AND_DRAINED = 0;
+    static final int NOT_READY_OR_NOT_DRAINED = 1;
+    static final int WRITING = 2; // Active direct write in progress
 
-    static final WriteState DEFAULT = new WriteState(false);
+    static final WriteState DEFAULT = new WriteState(NOT_READY_OR_NOT_DRAINED);
 
-    /**
-     * The servlet output stream is ready and the writeChain is empty.
-     *
-     * <p>readyAndDrained turns from false to true when:
-     * {@code onWritePossible()} exits while currently there is no more data to write, but the last
-     * check of {@link javax.servlet.ServletOutputStream#isReady()} is true.
-     *
-     * <p>readyAndDrained turns from true to false when:
-     * {@code runOrBuffer()} exits while either the action item is written directly to the
-     * servlet output stream and the check of {@link javax.servlet.ServletOutputStream#isReady()}
-     * right after that returns false, or the action item is buffered into the writeChain.
-     */
-    final boolean readyAndDrained;
-
-    WriteState(boolean readyAndDrained) {
-      this.readyAndDrained = readyAndDrained;
-    }
+    final int state;
 
-    /**
-     * Only {@code onWritePossible()} can set readyAndDrained to true, and only {@code
-     * runOrBuffer()} can set it to false.
-     */
-    @CheckReturnValue
-    WriteState withReadyAndDrained(boolean readyAndDrained) {
-      return new WriteState(readyAndDrained);
+    WriteState(int state) {
+      this.state = state;
     }
   }
 }
diff --git a/servlet/src/test/java/io/grpc/servlet/AsyncServletOutputStreamWriterTest.java b/servlet/src/test/java/io/grpc/servlet/AsyncServletOutputStreamWriterTest.java
index e7474078ec9..d3d02568dd1 100644
--- a/servlet/src/test/java/io/grpc/servlet/AsyncServletOutputStreamWriterTest.java
+++ b/servlet/src/test/java/io/grpc/servlet/AsyncServletOutputStreamWriterTest.java
@@ -23,7 +23,6 @@
 import io.grpc.servlet.AsyncServletOutputStreamWriter.Log;
 import java.io.IOException;
 import java.lang.reflect.Field;
-import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -287,10 +286,11 @@ private static void forceReadyAndDrained(AsyncServletOutputStreamWriter writer)
     AtomicReference<Object> writeState =
         (AtomicReference<Object>) writeStateField.get(writer);
     Object curState = writeState.get();
-    Method withReadyAndDrained = curState.getClass().getDeclaredMethod(
-        "withReadyAndDrained", boolean.class);
-    withReadyAndDrained.setAccessible(true);
-    writeState.set(withReadyAndDrained.invoke(curState, true));
+    java.lang.reflect.Constructor<?> constructor =
+        curState.getClass().getDeclaredConstructor(int.class);
+    constructor.setAccessible(true);
+    Object newState = constructor.newInstance(0 /* READY_AND_DRAINED */);
+    writeState.set(newState);
   }
 
   @Test