How to download lots of files concurrently in android? -

i want download number of files concurrently in android, instance, there 10000 files downloaded, each file have small size 20kb, , want 3 threads concurrently download files.

maybe asynctask suitable? , may queue needed manage 10000 urls?

there comments mentioned downloadmanager.class, support concurrent download? because there many files , file size small, think concurrently doing faster.

i think asynctask suitable this. can create 2 queues say, runningtasks , pendingtasks.

when ever try download task put in runningtasks list , other tasks in pendingtasks list. execute tasks added in running tasks list using asynctask handler . add listener whenever task gets completed. remove task pendingtasks , add in pendingtasks list. see logic implmented below:-

public class downloader {     asynctaskscheduler scheduler;      public downloader()     {         scheduler  = new asynctaskscheduler();     }      public void startdownload()     {         long ts = system.currenttimemillis();         yourasynctask handler = new yourasynctask();         scheduler.schedule(handler, ts);      }  } 
    
    public class yourasynctask extends asynctask<void, void, bitmap> {
    
         asynctaskscheduler listener;     string uri;
        
         public yourasynctask(asynctaskscheduler listener, uri)
         {
             this.uri = uri;
             this.listener = listener;
         }
      
         @override
      protected bitmap doinbackground(void... params)     {
             try {
                 //do http download here uri             // return bitmap downloaded ;          return bitmap;
             } catch (ioexception e) {             e.printstacktrace();
             }
          
             return null;
         }
      
         @override
         protected void onpostexecute(bitmap bitmap)
         {   
             this.listener.downloadcompleted(this);
         } 
    }
        public class taskinfo {
    
         asynctask< void , void, bitmap> async;
         long timestamp;
    
       
         public taskinfo(){}
        
         public taskinfo(asynctask< void , void, bitmap> async, long timestamp)
         {
             this.async = async;
             this.timestamp = timestamp;
    
         }
    
         public asynctask<void, void, bitmap> gethandler()
         {
             return this.async;
         }
      
         public long gettimestamp()
         {
             return this.timestamp;
         }
     
    }
      public interface downloadercompleted {
    
         void downloadcompleted(asynctask<void, void, bitmap> task);     
    }       
        
        public class asynctaskscheduler implements downloadercompleted     {
          
                 private static final int running_task_list_size = 3;
        
                 public arraylist<taskinfo> runningtasks; 
                 public linkedlist<taskinfo> pendingtasks;
          
                 public asynctaskscheduler()
                 {
                     runningtasks = new arraylist<taskinfo>(); 
                     pendingtasks = new linkedlist<taskinfo>();
                 }
          
                 public void schedule(asynctask<void, void, bitmap> handler, long timestamp)
                 {
                     //running task list not full add task it
                     taskinfo taskinfo = new taskinfo(handler,timestamp);
                     if (!isrunningtasklistfull())
                     {
                         runningtasks.add(taskinfo);
                    
                         //check if task added running list , there in pending list , remove it.
                         for(int = 0; i< pendingtasks.size();i++)
                         {
                      
                             if (pendingtasks.get(i).getvideoid().equals(videoid))
                             {
                                 pendingtasks.remove(i);
                                 break;
                             }
                         }
                  
                         taskinfo.gethandler().executeonexecutor(asynctask.thread_pool_executor);
                   
                     } else
                     {
                         //check if task in pending list , if yes no need add it.
                          boolean found = false;
                         for(int = 0; i< pendingtasks.size();i++)
                         {
                             if (pendingtasks.get(i).getvideoid().equals(videoid))
                             {
                                 found = true;
                                 break;
                             }
                         }
                         if (found == false)
                         {
                             pendingtasks.addfirst(taskinfo);
                         }
                     }
                 }
          
                 public boolean isrunningtasklistfull()
                 {
                     if (runningtasks.size() == running_task_list_size)
                     return true;
                     else
                   return false;
                 }
        
                 @override
          public void downloadcompleted(asynctask<void, void, bitmap> handler)         {
                     //check task in running list , remove .
                     boolean found = false;
        
                     (int = 0; < runningtasks.size(); i++)
                     {
                         if (runningtasks.get(i).gethandler().equals(handler))
                         {
                             runningtasks.remove(i);
                             found = true;
                             break;
                         }
                     }
        
        
                
                     if (found == true )
                     {   
                         if (pendingtasks.size() > 0)                 {
                             taskinfo taskinfo = pendingtasks.removefirst();
                             schedule(taskinfo.gethandler(), taskinfo.gettimestamp());
                         } else                 {                     //all tasks downloaded
                             }
                         }
                 }
             }