Introducción a varios métodos de implementación y diferencias de Java Thread Pool
import java.text.dateFormat; import java.text.simpledateFormat; import java.util.arrayList; import java.util.date; import java.util.list; import java.util.list; import java.util.concurrent.callable; import java.util.concurrent.executics; importación; importación; importación; java.util.concurrent.executors; import java.util.concurrent.future; public class testThreadPool {// -newfixedThreadPool es similar a CachethreadPool, y también se puede usar si se reutiliza, pero no puede crear nuevos hilos en cualquier momento // - su noquedad: en cualquier momento, en el tiempo, en la mayoría, se puede reutilizar un número fijo. En este momento, si se establece un nuevo hilo, solo se puede colocar en otra cola y esperar hasta que un hilo en el hilo actual termine y se mueva fuera de la piscina directamente //, a diferencia de Cachethreadpool, FixedThreadPool no tiene un mecanismo inactivo (también puede estar allí, pero el documento no lo menciona, debe ser muy largo, similar a TCP o UDP /////a inactivo que depende del lineismo inactivo). FixedThreadPool está dirigido principalmente a algunos subprocesos concurrentes regulares muy estables y fijos, en su mayoría utilizados en servidores // - del código fuente del método, el grupo de caché y fijo el grupo llama al mismo grupo subyacente, pero los parámetros son diferentes: // El recuento de subprocesos fijo es fijo, y es 0 segundos inactivos (sin inactividad) // El recuento de piscinas de cache admite 0 -Integer.Max_Value (obviamente, el hostio inactivo) no considerado en absoluto), 60 segundos inactivos static static eScutorService fixedservice = ejecutors.newfixedthreadpool (6); // -Cache Pool, primero verifique si hay hilos previamente establecidos en el grupo, si hay, reutilizado. De lo contrario, cree un nuevo hilo y agréguelo a la piscina // -Cache La piscina generalmente se usa para realizar algunas tareas asíncronas con una vida útil muy corta //, por lo tanto, no se usa mucho en algunos servidores de tipo de demonio orientados a las conexión. // - El hilo que puede reutilizar debe ser un hilo en la piscina dentro del tiempo de espera inactivo. El tiempo de espera predeterminado es de 60 años. Si el tiempo de inactividad excede la duración, la instancia del subproceso se terminará y se moverá fuera de la piscina. // Tenga en cuenta que el hilo que coloca en CachedThreadPool no tiene que preocuparse por su final. Si está inactivo después del tiempo de espera, se terminará automáticamente. private static ejecutorservice cacheservice = ejecutors.newCachedThreadPool (); // -singleton hilo, solo puede haber un hilo en cualquier grupo de tiempo // -El grupo subyacente es el mismo que el grupo de caché y el grupo fijo, pero el número de subprocesos es 1-1,0 segundos inactivos (sin inactividad) staticsecutorservice privado servicio de solteros = ejecutores.newsinglethreadExecutor (); // -Scheduled Hild Pool // -Los hilos en este grupo se pueden retrasar en secuencia de acuerdo con el cronograma, o el servicio de ejecutores estático privado ProgramedService = Ejecutores. NewscheduledThreadPool (10); public static void main (string [] args) {dateFormat format = new SimpleDateFormat ("yyyyy-mm-dd hh: mm: ss"); Lista <integer> customerList = new ArrayList <Integer> (); System.out.println (format.format (nuevo date ())); testFixedThreadPool (FixedService, CustomerList); System.out.println ("--------------------------"); testFixedThreadPool (FixedService, CustomerList); fijoservice.shutdown (); System.out.println (fixedservice.isshutdown ()); System.out.println ("----------------------------------------------------"); testCachethreadPool (Cacheservice, CustomerList); System.out.println ("----------------------------------------------------"); testCachethreadPool (Cacheservice, CustomerList); Cacheservice.shutdownnow (); System.out.println ("----------------------------------------------------"); testSingleServiceThreadPool (SingleService, CustomerList); testSingleServiceThreadPool (SingleService, CustomerList); SingleService.shutdown (); System.out.println ("----------------------------------------------------"); TestScheduledServiceThreadPool (ProchuledService, CustomerList); TestScheduledServiceThreadPool (ProchuledService, CustomerList); ProchuledService.shutdown (); } public static void testScheduledServiceThreadPool (Servicio de EjecutorService, List <integer> CustomerList) {List <Callable <integer>> listCallable = new ArrayList <Callable <Integer>> (); for (int i = 0; i <10; i ++) {Callable <integer> callable = new Callable <Ingerger> () {@Override public Integer Call () lanza excepción {return new Random (). NextInt (10); }}; listCallable.Add (llamable); } try {list <Euthure <Integer>> listFuture = Service.invokeAll (listCallable); para (futuro <Integer> Future: ListFuture) {Integer id = futuro.get (); CustomerList.Add (id); }} catch (Exception e) {E.PrintStackTrace (); } System.out.println (CustomerList.ToString ()); } public static void testSingleServiceThreadPool (EjecutorService Service, List <integer> CustomerList) {List <Callable <List <Integer>>> ListCallable = New ArrayList <Callable <List <Integer>>> (); for (int i = 0; i <10; i ++) {llameable <List <Integer>>> callable = new Callable <List <Integer> () {@Override Public List <Integer> call () lanza excepción {list <Integer> list = getList (new Random (). NextInt (10)); boolean isstop = false; while (list.size ()> 0 &&! ISstop) {System.out.println (Thread.CurrentThread (). GetId () + " - Sleep: 1000"); isstop = true; } Lista de retorno; }}; listCallable.Add (llamable); } try {list <Future <List <Integer>>> listFuture = Service.invokeAll (listCallable); para (Future <List <Integer>> Future: ListFuture) {list <Integer> list = futuro.get (); CustomerList.addall (lista); }} catch (Exception e) {E.PrintStackTrace (); } System.out.println (CustomerList.ToString ()); } public static void testCachethreadPool (Servicio EjecutorService, List <integer> CustomerList) {List <Callable <List <Integer>>> listCallable = new ArrayList <Callable <List <Integer>> (); for (int i = 0; i <10; i ++) {Callable <List <Integer>> Callable = New Callable <List <Integer> () {@Override Public List <Integer> call () lanza excepción {list <Integer> list = getList (new Random (). NextInt (10)); boolean isstop = false; while (list.size ()> 0 &&! ISstop) {System.out.println (Thread.CurrentThread (). GetId () + " - Sleep: 1000"); isstop = true; } Lista de retorno; }}; listCallable.Add (llamable); } try {list <Future <List <Integer>>> listFuture = Service.invokeAll (listCallable); para (Future <List <Integer>> Future: ListFuture) {list <Integer> list = futuro.get (); CustomerList.addall (lista); }} catch (Exception e) {E.PrintStackTrace (); } System.out.println (CustomerList.ToString ()); } public static void testFixedThreadPool (Servicio de EjecutorService, List <integer> CustomerList) {List <Callable <List <Integer>>> listCallable = new ArrayList <Callable <List <Integer>>> (); for (int i = 0; i <10; i ++) {Callable <List <Integer>> Callable = New Callable <List <Integer> () {@Override Public List <Integer> call () lanza excepción {list <Integer> list = getList (new Random (). NextInt (10)); boolean isstop = false; while (list.size ()> 0 &&! ISstop) {System.out.println (Thread.CurrentThread (). GetId () + " - Sleep: 1000"); isstop = true; } Lista de retorno; }}; listCallable.Add (llamable); } try {list <Future <List <Integer>>> listFuture = Service.invokeAll (listCallable); para (Future <List <Integer>> Future: ListFuture) {list <Integer> list = futuro.get (); CustomerList.addall (lista); }} catch (Exception e) {E.PrintStackTrace (); } System.out.println (CustomerList.ToString ()); } public static list <integer> getList (int x) {list <integer> list = new ArrayList <Integer> (); list.add (x); list.add (x * x); lista de devolución; }}Uso: Linked Bloquingqueue para implementar la explicación del grupo de subprocesos
// Por ejemplo: corePoolSize = 3, maximumumumpeolSize = 6, LinkedBlockingqueue (10) // el método de procesamiento predeterminado de DeclechExecutionHandler predeterminado es: ThreadPoolExeCutor.abortpolicy // ThreadPoolExeCutor EjecutorService = New ThreadPoolExecutor (CorePoolSize, Maxim SuProolSize, 1L, TimeUnit.secondS, NewPoole LinkedBlokingqueue <Runnable> (10)); // 1. Si el hilo que se ejecuta en el grupo de subprocesos (es decir, llamar a Executorservice.execute) no alcanza LinkedBockingqueue.init (10), el número de subprocesos actualmente ejecutados es: CorePoolSize (3) // 2. Si el número de hilos excedió LinkedBlockingqueue.init (10) y excedió> = init (10)+corepoolsize (3), y es menor que init (10)+maximoMuboolSize. El número de subprocesos actualmente iniciados es: (actual hilos-init (10)) // 3. Si el número de hilos llamados excede init (10)+maximumumpoolsize, esto se maneja de acuerdo con las reglas de rechazarexecutionHandler.
Acerca de: Explicación de varias implementaciones predeterminadas de RecheedExecutionHandler
// se usa predeterminado: threadpoolexecutor.abortpolicy. El controlador es rechazado y lanzará un tiempo de ejecución rechazado. RecheedExeCutionHandler Policy = new ThreadPoolExeCutor.abortpolicy (); //// en Threadpoolexecutor.callerrunspolicy, el hilo llama a la ejecución en sí que ejecuta la tarea. Esta estrategia proporciona un mecanismo de control de retroalimentación simple que puede ralentizar la presentación de nuevas tareas. // Policy = new ThreadPoolExeCutor.CallerRunspolicy (); //// en ThreadpoolExecutor.DiscardPolicy, se eliminarán las tareas que no se pueden ejecutar. // Policy = new ThreadPoolExeCutor.DiscarDpolicy (); //// En ThreadpoolExecutor.DiscardoldPolicy, si el albacea no ha sido cerrado, la tarea al jefe de la cola de trabajo se eliminará, y la ejecución del programa se volverá a intentar (repita este proceso si falla de nuevo). // Política = new ThreadPoolExecutor.DiscardoldSpolicy ();
La introducción anterior a los métodos de implementación y diferencias de Java Thread Pool es todo el contenido que he compartido con usted. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.