Au cours des deux dernières années de travail dans Android, en recherchant le code source Android, je vais également comprendre le traitement simultané Java du multi-lancement.
La question est donc de savoir comment implémenter un pool de threads en série?
Qu'est-ce qu'une piscine de threads en série?
En d'autres termes, nos objets coulissables devraient avoir un mécanisme de file d'attente, qui pénètre à partir de la queue de la file d'attente en séquence, et sélectionne Runnable à partir de la tête de la file d'attente pour l'exécution.
Puisque nous avons une idée, considérons la structure de données requise?
Étant donné que nous insérons l'objet Runnable à partir de la fin de la file d'attente et exécutons l'objet Runnable à partir de la tête de la file d'attente, nous avons naturellement besoin d'une file d'attente. Le SDK de Java nous a fourni une bonne structure de données de file d'attente, telle que la file d'attente à double extrémité: ArrayDeque <Cunnable>.
Importer java.util.arraydequ; import java.util.concurrent.blockingqueue; import java.util.concurrent.linkedblockingdeque; import java.util.concurrent.threadfactory; import java.util.concurrent.threadpoolECUTOR; java.util.concurrent.atomic.atomicInteger; / ** * créé par Wzy le 16-1-5. * / classe publique SerialexEcutor {private runnable Mactive; Private ArrayDequ <Scombable> MarRayDequ = new ArrayDequ <> (); Final statique privé int cpu_count = runtime.getRuntime (). DisponibleProcessors (); private static final int core_pool_size = cpu_count + 1; Final statique privé int maximum_pool_size = cpu_count * 2 + 1; Final statique privé int keep_alive = 1; BlockingQueue finale statique privée <Nuenable> SpoolworkQueue = new LinkedBlockingDeque <> (128); private statique final threadfactory sthreadfactory = new ThreadFactory () {private final atomicInteger mcount = new atomicInteger (1); @Override public thread newthread (runnable r) {return new Thread (r, "série #" + mcount.getandincrement ()); }}; Final Final statique privé ThreadPoolExecutor Thread_execUtor = new ThreadPoolExecutor (CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, keep_alive, timeunit.seconds, spoolworkQueue, sthReadFactory); public synchronisé void execute (final runnable r) {marRayDequ.offer (new Runnable () {@Override public void run () {try {r.run ();} enfin {scheduleNExt ();}}}); // Lorsque la première fois que vous rejoignez la file d'attente, Mactive est vide, vous devez donc appeler manuellement la méthode ScheduleNext if (MACCAL == null) {scheduleNext (); }} private void scheduleNext () {if ((mactive = marRayDequ.poll ())! = null) {thread_executor.execute (mactive); }} public static void main (String [] args) {serialexEcutor serialexEcutor = new SerialexEcutor (); pour (int i = 0; i <10; i ++) {final int j = i; SerialexEcutor.ExECUTE (new Runnable () {@Override public void run () {System.out.println ("le num est:" + (j + 1)); try {Thread.Sleep (1000);} catch (InterruptedException e) {e.printStStackTrace ();}}}); }}}Les résultats de l'exécution sont les suivants:
Le num est: 1
Le num est: 2
Le num est: 3
Le num est: 4
Le num est: 5
Le num est: 6
Le num est: 7
Le num est: 8
Le num est: 9
Le num est: 10
Ce qui précède est tout le contenu de cet article sur l'analyse des instances de pool de fils de série de la concurrence de Java, et j'espère que cela sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets connexes sur ce site. S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!