docs: private void startResponseReadSync() throws IOException {
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
              Tr.entry(tc, "startResponseReadSync");
          }
          HttpInvalidMessageException inv = checkRequestValidity();
          if (null != inv) {
              // invalid request message
              throw inv;
          }
          // check whether read-ahead is enabled. Bypass this code once the
          // init() method has been called (d264854) and continue as normal
          if (isReadAheadEnabled() && READ_STATE_TIME_RESET != getReadState()) {
              // read ahead is active
  
              int state = CALLBACK_STATE_IDLE;
              // grab the read-ahead states in a sync block to avoid timing windows
              // with the callback kicking in at the same time
              synchronized (this.stateSyncObject) {
                  state = getCallbackState();
                  setReadState(READ_STATE_SYNC);
              }
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                  Tr.debug(tc, "Sync response read, callback state: " + state);
              }
              switch (state) {
                  case (CALLBACK_STATE_COMPLETE):
                      // use regular message parsing logic below
                      break;
                  case (CALLBACK_STATE_ERROR):
                      // read-ahead has already hit an error, throw that to caller
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                          Tr.debug(tc, "Read-ahead reports previous failure");
                      }
                      if (null == this.readException) {
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                              Tr.debug(tc, "Callback indicates error but no exception");
                          }
                          throw new IOException("Bad read-ahead state");
                      }
                      throw this.readException;
  
                  case (CALLBACK_STATE_PENDING):
                      // read-ahead is still going on so we need to block here waiting
                      // on that to complete (or fail)
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                          Tr.debug(tc, "Waiting for read-ahead to finish");
                      }
  
                      // we can't do anything except keep waiting otherwise
                      // there's going to be a read outstanding while the
                      // application channel thinks it can close the connection
                      while (CALLBACK_STATE_PENDING == getCallbackState()) {
                          try {
                              synchronized (this.readAheadSyncer) {
                                  this.readAheadSyncer.wait(2 * getHttpConfig().getReadTimeout());
                              }
                          } catch (InterruptedException ie) {
                              // no FFDC required
                              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                                  Tr.debug(tc, "Read-ahead block wait timed out");
                              }
                          }
                      }
                      // check for an error from the callback
                      if (null != this.readException) {
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                              Tr.debug(tc, "Read-ahead reports new failure");
                          }
                          throw this.readException;
                      }
                      // otherwise use the regular parsing logic below
                      break;
                  default:
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                          Tr.debug(tc, "Unexpected state (" + state + ") during sync readahead");
                      }
                      throw new IOException("Read-ahead state failure: " + state);
              }
          }
  
          // Make sure the response message exists
          getResponseImpl();
          readSyncResponse();
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
              Tr.exit(tc, "startResponseReadSync");
          }
      }