Berapa banyak permintaan yang boleh dikendalikan oleh SpringBoot pada masa yang sama?

Teks

Kita semua tahu bahawa bekas terbenam lalai SpringBoot ialah Tomcat, yang bermaksud bahawa program kami sebenarnya berjalan dalam Tomcat. Jadi bukan berapa banyak permintaan SpringBoot boleh kendalikan, tetapi berapa banyak permintaan Tomcat boleh kendalikan.

Konfigurasi lalai Tomcat berada dalam fail spring-configuration-metadata.json dan kelas konfigurasi yang sepadan ialah org.springframework.boot.autoconfigure.web.ServerProperties.

Terdapat empat parameter yang berkaitan dengan bilangan permintaan yang diproses:

• server.tomcat.threads.min-spare: Bilangan minimum benang pekerja, saiz lalai ialah 10. Parameter ini bersamaan dengan pekerja jangka panjang Jika bilangan permintaan serentak tidak mencapai 10, urutan ini akan digunakan dalam urutan untuk memproses permintaan. server.tomcat.threads.max: Bilangan maksimum utas pekerja, saiz lalai ialah 200. Parameter ini bersamaan dengan pekerja sementara Jika bilangan permintaan serentak adalah antara 10 dan 200, rangkaian pekerja sementara ini akan digunakan untuk pemprosesan. server.tomcat.max-connections: Bilangan maksimum sambungan, saiz lalai ialah 8192. Menunjukkan bilangan maksimum permintaan yang Tomcat boleh mengendalikan Permintaan melebihi 8192 akan diletakkan dalam baris gilir menunggu.

• server.tomcat.accept-count: Panjang baris gilir menunggu, saiz lalai ialah 100.

Berikan contoh untuk menggambarkan hubungan antara parameter ini:

Jika anda membandingkan Tomcat dengan restoran, Maka permintaan adalah sebenarnya setaraf tetamu. min-spare ialah chef (pekerja tetap maks ialah jumlah bilangan chef (pekerja tetap + pekerja sementara); . Tetamu yang datang diberi keutamaan untuk duduk di restoran, dan kemudian chef mula bekerja Jika pekerja jangka panjang boleh menyelesaikan kerja, biarkan pekerja jangka panjang melakukannya , biarkan pekerja sementara yang melakukannya. Terdapat 15 chef dalam gambar, dan terdapat 30 tempat duduk dalam restoran itu, jika 20 tetamu datang sekarang, akan ada 5 orang yang menunggu di restoran itu. Jika 35 orang datang sekarang dan tiada ruang di dalam restoran, 5 orang akan diminta duduk di depan pintu dahulu. Kalau 50 orang datang, hotel tu ada 40 seat + bangku kecil depan pintu, jadi 10 orang akan keluar.

Dalam erti kata lain, bilangan maksimum permintaan yang boleh dikendalikan oleh SpringBoot pada masa yang sama ialah max-connections+accept-count, dan permintaan yang melebihi nombor ini akan dibuang terus.

Selepas membacanya di atas kertas, saya akhirnya sedar bahawa saya perlu melakukannya secara terperinci.

Yang di atas hanyalah hasil teori Sekarang mari kita gunakan contoh praktikal kecil untuk menunjukkan sama ada ini berlaku:

Buat projek SpringBoot dan konfigurasikannya dalam parameter application.yml, kerana nombor lalai adalah terlalu besar dan sukar untuk diuji, jadi tetapkan ia lebih kecil:

server:
  tomcat:
    threads:
      # 最少线程数
      min-spare: 10
      # 最多线程数
      max: 15
    # 最大连接数
    max-connections: 30
    # 最大等待数
    accept-count: 10

Mari tulis antara muka yang mudah:

    @GetMapping("/test")
    public Response test1(HttpServletRequest request) throws Exception {
        log.info("ip:{},线程:{}", request.getRemoteAddr(), Thread.currentThread().getName());
        Thread.sleep(500);
        return Response.buildSuccess();
    }

Kod ini sangat mudah, cuma cetak nama benang , dan kemudian tidur selama 0.5 saat Ini pasti akan menyebabkan beberapa permintaan diproses sekaligus dan memasuki barisan menunggu.

Kemudian saya mencipta kes ujian menggunakan Apifox untuk mensimulasikan 100 permintaan:

Perhatikan keputusan ujian:

Seperti yang dapat dilihat daripada keputusan, kerana jumlah set bilangan-sambungan-maks+terima ialah 40, 60 permintaan akan dibuang, itulah yang kami jangkakan. Oleh kerana urutan maksimum ialah 15, iaitu, 25 permintaan akan menunggu dahulu, dan kemudian 15 akan diproses selepas 15 yang pertama diproses, dan akhirnya 10 akan diproses, iaitu, 40 permintaan dibahagikan kepada tiga kelompok 15, 15, dan 10. berurusan dengan.

Daripada log cetakan konsol, kita dapat melihat bahawa nombor utas maksimum ialah 15, yang juga mengesahkan idea sebelumnya.

Untuk meringkaskan: Jika bilangan permintaan serentak adalah lebih rendah daripada server.tomcat.threads.max, ia akan diproses serta-merta, dan lebihan akan menunggu untuk pertama. Jika Jika bilangan melebihi jumlah sambungan maks dan kiraan terima, lebihan akan dibuang terus.

Sambungan: Bagaimana masalah konkurensi timbul

Setakat ini, kami telah mengetahui berapa banyak permintaan yang boleh dikendalikan oleh SpringBoot pada masa yang sama. Tetapi di sini saya ingin memanjangkannya berdasarkan contoh di atas, itulah sebabnya beberapa nilai dalam senario serentak berbeza daripada apa yang kami jangkakan?

设想有以下场景：厨师们用一个账本记录一共做了多少道菜，每个厨师做完菜都记录一下，每次记录都是将账本上的数字先抄到草稿纸上，计算x+1等于多少，然后将计算的结果写回到账本上。

Spring容器中的Bean默认是单例的，也就是说，处理请求的Controller、Service实例就只有一份。在并发场景下，将cookSum定义为全局变量，是所有线程共享的，当一个线程读到了cookSum=20，然后计算，写回前另一个线程也读到是20，两个线程都加1后写回，最终cookSum就变成了21，但是实际上应该是22，因为加了两次。

private int cookSum = 0;

@GetMapping("/test")
public Response test1(HttpServletRequest request) throws Exception {
	// 做菜。。。。。。
	cookSum += 1;
    log.info("做了{}道菜", cookSum);
    Thread.sleep(500);
	return Response.buildSuccess();
}

Atas ialah kandungan terperinci Berapa banyak permintaan yang boleh dikendalikan oleh SpringBoot pada masa yang sama?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!