Android 凌空增加线程池大小

下面的代码生成300个http请求，每个请求从数据库返回10000行。10000的总大小约为0.4mb。所以300*0.4=120mb

问题：

增加线程池大小以处理凌空请求会如何影响应用程序的性能？我将其更改为12，但执行时间和数据大小与4相同。有什么区别吗

当增加截击线程的数量时，结果数据是否也会增加？如果有1个线程，则每次返回的最大数据量为0.4mb。但是如果我们有4个，最大值将是1.6mb

仿真器：4核多线程

ExecutorService service  = Executors.newFixedThreadPool(4);
RequestQueue queue;
AtomicInteger counter = new AtomicInteger(0);

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);


    File cacheDir = new File(this.getCacheDir(), "Volley");
    queue = new RequestQueue(new DiskBasedCache(cacheDir), new BasicNetwork(new HurlStack()), 4);
    queue.start();
    start();
}



public void start(){

    String url ="...";
    for(int i =0 ; i<300; i++) {
        counter.incrementAndGet();
        StringRequest stringRequest = new StringRequest(Request.Method.GET, url,
                new Response.Listener<String>() {
                    @Override
                    public void onResponse(String response) {

                        method(response);
                    }
                }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                Log.d("VolleyError", error.toString());
            }
        });
        stringRequest.setTag("a");
        queue.add(stringRequest);
    }
}

public synchronized void decreased(){

    if(counter.decrementAndGet()==0)
        start();
}

public void method( String response){

        Runnable task = new Runnable() {
            @Override
            public void run() {

                List<Customer> customers= new ArrayList<>();
                ObjectMapper objectMapper = new ObjectMapper();
                TypeFactory typeFactory = objectMapper.getTypeFactory();
                try {
                customers= objectMapper.readValue(response, new TypeReference<List<Customer>>() {});

                              //Simulate database insertion delay
                              try {
                                    Thread.sleep(1000);
                                } catch (InterruptedException e) {
                                   e.printStackTrace();
                                }

                    decreased();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
        };


    logHeap("");
    service.execute(task);

}

ExecutorService=Executors.newFixedThreadPool（4）；
请求队列；
AtomicInteger计数器=新的AtomicInteger（0）；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
File cacheDir=新文件（this.getCacheDir（），“Volley”）；
队列=新的请求队列（新的DiskBasedCache（cacheDir），新的基本网络（新的HurlStack（）），4）；
queue.start（）；
start（）；
}
公开作废开始（）{
字符串url=“…”；
对于（int i=0；i关于问题1：
与12相比，大小为4的线程池更好。
线程池大小应与可用的处理器数量相结合

由于处理器数量有限，应用程序不应产生不必要的线程，因为这可能会导致性能问题。因为android操作系统必须管理更多线程之间的资源，这将导致每个线程的等待时间和实际时间增加

理想情况下，假设线程没有锁定，这样它们就不会相互阻塞（彼此独立），并且可以假设工作负载（处理）相同，那么池大小为
Runtime.getRuntime（）.availableProcessors（）或availableProcessors（）+1
的结果最好。
有关更多信息，请参阅链接

关于问题2：如果我正确理解了您的问题，那么返回的数据应该没有变化，因为线程池大小对网络负载没有影响，只有等待时间和实际时间会在线程池大小值发生变化时发生变化。
让我们不要“假设”注意这里的主要问题。我说的是截取。我不知道线程是否相互阻塞。在截取的情况下，线程池大小应该接近可用的处理器，而且创建更多线程也会有不必要的开销。“线程池大小对网络负载没有影响”。但是线程池解析来自服务器的响应，然后将它们发送到主线程。因此，如果我们有12个线程，12个并发响应将被解析并发送到主线程。因此，如果主线程的速度不够快，无法执行响应，内存将不断增加。我说的对吗？所有12个线程不会同时处于运行状态，因为线程r在大多数运行时，不在处理器上运行。getRuntime（）。availableProcessors（）将处于运行状态，其他将处于等待状态。OK。最后一个问题。网络延迟是否也会影响性能？如果响应缓慢，4个线程将与1个线程一样好。对吗？