SpringBoot文件上传接口并发性能调优

// 读取上传的文件
part part = request.getpart("data");
inputstream in = part.getinputstream();

bytearrayoutputstream str=new bytearrayoutputstream();
int k;
byte[] file = null;
while((k=in.read())!=-1){
    str.write(k);
}
file = str.tobytearray();
str.close();
in.close();

/**
 * reads the next byte of data from the input stream. the value byte is
 * returned as an {@code int} in the range {@code 0} to
 * {@code 255}. if no byte is available because the end of the stream
 * has been reached, the value {@code -1} is returned. this method
 * blocks until input data is available, the end of the stream is detected,
 * or an exception is thrown.
 *
 * <p> a subclass must provide an implementation of this method.
 *
 * @return     the next byte of data, or {@code -1} if the end of the
 *             stream is reached.
 * @throws     ioexception  if an i/o error occurs.
 */
public abstract int read() throws ioexception;

byte[] buffer = new byte[8192];
int bytesread;
while ((bytesread = in.read(buffer)) != -1) {
    str.write(buffer, 0, bytesread);
}

/**
 * reads some number of bytes from the input stream and stores them into
 * the buffer array <code>b</code>. the number of bytes actually read is
 * returned as an integer.  this method blocks until input data is
 * available, end of file is detected, or an exception is thrown.
 *
 * <p> if the length of <code>b</code> is zero, then no bytes are read and
 * <code>0</code> is returned; otherwise, there is an attempt to read at
 * least one byte. if no byte is available because the stream is at the
 * end of the file, the value <code>-1</code> is returned; otherwise, at
 * least one byte is read and stored into <code>b</code>.
 *
 * <p> the first byte read is stored into element <code>b[0]</code>, the
 * next one into <code>b[1]</code>, and so on. the number of bytes read is,
 * at most, equal to the length of <code>b</code>. let <i>k</i> be the
 * number of bytes actually read; these bytes will be stored in elements
 * <code>b[0]</code> through <code>b[</code><i>k</i><code>-1]</code>,
 * leaving elements <code>b[</code><i>k</i><code>]</code> through
 * <code>b[b.length-1]</code> unaffected.
 *
 * <p> the <code>read(b)</code> method for class <code>inputstream</code>
 * has the same effect as: <pre><code> read(b, 0, b.length) </code></pre>
 *
 * @param      b   the buffer into which the data is read.
 * @return     the total number of bytes read into the buffer, or
 *             <code>-1</code> if there is no more data because the end of
 *             the stream has been reached.
 * @exception  ioexception  if the first byte cannot be read for any reason
 * other than the end of the file, if the input stream has been closed, or
 * if some other i/o error occurs.
 * @exception  nullpointerexception  if <code>b</code> is <code>null</code>.
 * @see        java.io.inputstream#read(byte[], int, int)
 */
public int read(byte b[]) throws ioexception {
    return read(b, 0, b.length);
}

servlet:
  multipart:
    file-size-threshold: 1mb

// org.apache.tomcat.util.http.fileupload.disk.diskfileitemfactory.java

/**
 * <p>the default {@link org.apache.tomcat.util.http.fileupload.fileitemfactory}
 * implementation. this implementation creates
 * {@link org.apache.tomcat.util.http.fileupload.fileitem} instances which keep
 * their
 * content either in memory, for smaller items, or in a temporary file on disk,
 * for larger items. the size threshold, above which content will be stored on
 * disk, is configurable, as is the directory in which temporary files will be
 * created.</p>
 *
 * <p>if not otherwise configured, the default configuration values are as
 * follows:</p>
 * <ul>
 *   <li>size threshold is 10 kib.</li>
 *   <li>repository is the system default temp directory, as returned by
 *       {@code system.getproperty("java.io.tmpdir")}.</li>
 * </ul>
 * <p>
 * <b>note</b>: files are created in the system default temp directory with
 * predictable names. this means that a local attacker with write access to that
 * directory can perform a toutoc attack to replace any uploaded file with a
 * file of the attackers choice. the implications of this will depend on how the
 * uploaded file is used but could be significant. when using this
 * implementation in an environment with local, untrusted users,
 * {@link #setrepository(file)} must be used to configure a repository location
 * that is not publicly writable. in a servlet container the location identified
 * by the servletcontext attribute {@code javax.servlet.context.tempdir}
 * may be used.
 * </p>
 *
 * <p>temporary files, which are created for file items, will be deleted when
 * the associated request is recycled.</p>
 *
 * @since fileupload 1.1
 */
public class diskfileitemfactory implements fileitemfactory {

    // ----------------------------------------------------- manifest constants

    /**
     * the default threshold above which uploads will be stored on disk.
     */
    public static final int default_size_threshold = 10240;
}

// org.apache.tomcat.util.http.fileupload.disk.diskfileitem.java

/**
 * the threshold above which uploads will be stored on disk.
 */
private final int sizethreshold;

/**
 * returns an {@link java.io.outputstream outputstream} that can
 * be used for storing the contents of the file.
 *
 * @return an {@link java.io.outputstream outputstream} that can be used
 *         for storing the contents of the file.
 *
 */
@override
public outputstream getoutputstream() {
    if (dfos == null) {
        final file outputfile = gettempfile();
        dfos = new deferredfileoutputstream(sizethreshold, outputfile);
    }
    return dfos;
}

// org.apache.tomcat.util.http.fileupload.deferredfileoutputstream.java

/**
 * an output stream which will retain data in memory until a specified
 * threshold is reached, and only then commit it to disk. if the stream is
 * closed before the threshold is reached, the data will not be written to
 * disk at all.
 * <p>
 * this class originated in fileupload processing. in this use case, you do
 * not know in advance the size of the file being uploaded. if the file is small
 * you want to store it in memory (for speed), but if the file is large you want
 * to store it to file (to avoid memory issues).
 */
public class deferredfileoutputstream
    extends thresholdingoutputstream
{
     /**
     * constructs an instance of this class which will trigger an event at the
     * specified threshold, and save data to a file beyond that point.
     * the initial buffer size will default to 1024 bytes which is bytearrayoutputstream's default buffer size.
     *
     * @param threshold  the number of bytes at which to trigger an event.
     * @param outputfile the file to which data is saved beyond the threshold.
     */
    public deferredfileoutputstream(final int threshold, final file outputfile)
    {
        this(threshold,  outputfile, null, null, null, bytearrayoutputstream.default_size);
    }
}

tomcat:
    threads:
        max: 400
    max-connections: 10000
    accept-count: 1000