En primer lugar, ¿cuál es el grupo de subprocesos
1.Java en línea de la piscina Cheng es el uso de campo de escena y pelo marcos, y casi todos requieren asíncrono o enviar ejecutar la línea de cualquier negocio programa puede utilizar la línea de la piscina Cheng. En el abierto envió un proceso, uso racional de la línea celular ruta puede ser cinta a . 3 un buen lugar .
Primero: reducir la financiación de consumo de las fuentes . Pasar a través de la reutilización ya la creación construida -line proceso para reducir la línea de impulsión registro de construcción de pin destruido el consumo causado.
Segundo: para mejorar la respuesta debe acelerar . Cuando cualquier tarea llegada de tiempo , cualquier tarea puede no ser necesaria para esperar hasta que la línea deCheng Chong Jian podrá inmediatamente ejecutar la línea.
Tercero: mejorar las líneas de proceso manejable . Línea de proceso son escasos recursos de origen, si no restringido creación construido, no sólo se consume el sistema de recursos del sistema de origen, sino que también reduce el sistema el sistema 's estabilidad caracterización utilizando alambre de celda de paso puede alimentar la línea sistema de distribución de sintonía y monitoreo controles. Sin embargo, para lograr un uso racional de la línea de la piscina Cheng, será necesario para su realización conocido principio.
En segundo lugar, el papel del grupo de subprocesos
1. El grupo de subprocesos es un brote repentino de un gran número de temas diseñados por un número limitado de hilo fijo para un gran número de servicios operativos, reduciendo el tiempo necesario para crear y destruir hilos, para mejorar la eficiencia. Si un hilo es muy largo, no hay necesidad de utilizar el grupo de subprocesos (no no puede funcionar durante mucho tiempo, pero no debería.) Por otra parte, no podemos control de arranque hilos en el grupo de subprocesos, en suspensión, y la suspensión.
En tercer lugar, la clasificación del grupo de subprocesos
1.Java es intrínsecamente compatible con el lenguaje concurrente, significa que el apoyo concurrente múltiples hilos, hilo frecuencia creada en alta concurrencia y gran cantidad de datos es muy consume recursos, como Java proporciona un grupo de subprocesos. En las versiones anteriores jdk1.5, y utilizar el grupo de subprocesos es simple, pero después de JDK1.5, se ha mejorado mucho. Se unió al paquete java.util.concurrent después JDK1.5, se añadió paquete java.util.concurrent dar a los desarrolladores una gran ayuda desarrollar un programa concurrente y resolver los problemas de concurrencia. Y la interfaz Ejecutor, la interfaz Ejecutor como si una interfaz muy antigua (lanzado JDK1.5 2004 años) en virtud de un contrato según el presente artículo se describen, pero muchos programadores para algunos de los principios de la que aún no están familiarizados con, por lo que escribir este artículo para introducido a la interfaz Ejecutor, al mismo tiempo, consolidar sus conocimientos. Si hay un error en el artículo, la bienvenida a señalar.
El órgano más importante marco ejecutor de la aplicación es de clase ThreadPoolExecutor, clase de fábrica newScheduledThreadPool Ejecutores proporciona, newFixedThreadPool, newCachedThreadPool hecho, sólo los parámetros del método constructor ThreadPoolExecutor es diferente. Pasando a través de diferentes parámetros, el grupo de subprocesos se puede construir para diferentes escenarios bajo, entonces su principio subyacente es la forma de lograr que, para introducir este proceso que se ejecute en grupo de subprocesos ThreadPoolExecutor.
corePoolSize: el tamaño de la piscina central. Cuando existen tareas que más tarde, se va a crear un hilo para realizar la tarea, cuando el número de hilos en el grupo de subprocesos alcanza corePoolSize, la tarea va a meter la mano en la cola de caché entre
maximumPoolSize: El número máximo de subprocesos en el grupo de subprocesos, se dijo en el grupo de subprocesos cuántos hilos pueden crear hasta;
KeepAliveTime: indica que el hilo no se mantiene mucho tiempo hasta la ejecución de la tarea se dará por terminado.
unidad: unidad de tiempo KeepAliveTime parámetro, hay siete valores, hay siete tipos TIMEUNIT propiedades estáticas de la clase;
Cuatro, cuatro clases de manera de crear un grupo de subprocesos
ofertas 1.Java cuatro grupo de subprocesos Ejecutores (jdk1.5 y contratos), respectivamente:
1.1.newCachedThreadPool crear un grupo de subprocesos caché, grupo de subprocesos más tiempo que si las necesidades de tratamiento, la flexibilidad para recuperar hilo vacío, si no es reciclable, el nuevo hilo.
// 无限大小线程池 jvm自动回收
ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
final int temp = i;
newCachedThreadPool.execute(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(100);
} catch (Exception e) {
// TODO: handle exception
}
System.out.println(Thread.currentThread().getName() + ",i:" + temp);
}
});
}Resumen : la agrupación de hebras es infinito, la primera tarea se ha completado cuando la segunda tarea, el hilo utilizado para realizar la primera tarea será compleja, en lugar de cada vez que un nuevo hilo.
1.2.newFixedThreadPool crear un grupo de subprocesos de tamaño fijo, se puede controlar el número máximo de subprocesos simultáneos, el exceso de las discusiones van a esperar en la cola.
ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(5);
for (int i = 0; i < 10; i++) {
final int temp = i;
newFixedThreadPool.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getId() + ",i:" + temp);
}
});
}Resumen: Debido a que el tamaño del grupo de subprocesos de 3, cada tarea salidas índice del sueño 2 segundos, 3 de impresión digital de cada dos segundos. El tamaño de la rosca de longitud fija Piscina el mejor conjunto de acuerdo con los recursos del sistema. El Runtime.getRuntime (). AvailableProcessors ()
1.3.newScheduledThreadPool crear un grupo de subprocesos de tamaño fijo para apoyar la ejecución de la tarea regular y periódica.
ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(5);
for (int i = 0; i < 10; i++) {
final int temp = i;
newScheduledThreadPool.schedule(new Runnable() {
public void run() {
System.out.println("i:" + temp);
}
}, 3, TimeUnit.SECONDS);
}Resumen: representa un retardo de tres segundos para llevar a cabo.
1.4.newSingleThreadExecutor crear una piscina de un solo subproceso hilo, usarlo sólo para realizar la tarea sólo subprocesos de trabajo para asegurar que todas las tareas se llevan a cabo en un orden especificado (FIFO, LIFO, prioridades).
ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
newSingleThreadExecutor.execute(new Runnable() {
@Override
public void run() {
System.out.println("index:" + index);
try {
Thread.sleep(200);
} catch (Exception e) {
// TODO: handle exception
}
}
});
}Nota: Los resultados de salida de forma secuencial, lo que equivale a la ejecución de cada orden de trabajo.
En quinto lugar, el principio de la agrupación de hebras
1.corePoolSize (hilos del núcleo): se refiere al número de hilos de aplicación práctica.
maximumPoolSize (número máximo de hilos): El número de hilos en el grupo de subprocesos para crear.
2. Si el número actual de las discusiones en el grupo de subprocesos es menor que corePoolSize, a continuación, cada uno para una tarea, creará un hilo para realizar esta tarea;
Si el número actual de las discusiones en el grupo de subprocesos> = corePoolSize, a continuación, cada uno para una tarea, va a tratar de agregarlo a la memoria intermedia de cola de tareas que, de ser agregado con éxito, la tarea será hebras en espera de espera para ejecutarlo a cabo, y si la adición falló ( en general, la cola de memoria intermedia está llena de tareas), que tratará de crear un nuevo hilo para realizar esta tarea;
Si la cola está llena, el número total de hilos en la premisa de no más de maximumPoolSize, a continuación, crear un nuevo hilo
Si el número actual de las discusiones en el grupo de subprocesos alcanza maximumPoolSize, tomará la tarea negar proceso de la política;
Si el número de hilos en la piscina es mayor que corePoolSize, si el tiempo de inactividad supera KeepAliveTime un hilo, el hilo se detendrá hasta que el número de hilos en la piscina no es mayor que corePoolSize; si se le permite poner en común el hilo de núcleo tiempo de supervivencia dispuestos, a continuación, la celda de núcleo el hilo está inactivo durante más de KeepAliveTime, el hilo se dará por terminado.
Seis encargo Código grupo de subprocesos
public class Test0007 {
public static void main(String[] args) {
// Executors.newCachedThreadPool();
//提交一个任务到线程池中，线程池的处理流程如下：
//1、判断线程池里的核心线程是否都在执行任务，如果不是（核心线程空闲或者还有核心线程没有被创建）则创建一个新的工作线程来执行任务。如果核心线程都在执行任务，则进入下个流程。
//2、线程池判断工作队列是否已满，如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下个流程。
//3、判断线程池里的线程是否都处于工作状态，如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给饱和策略来处理这个任务。
ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 2, 60L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(3));
for (int i = 1; i <= 6; i++) {
TaskThred t1 = new TaskThred("任务" + i);
executor.execute(t1);
}
executor.shutdown();
}
}
class TaskThred implements Runnable {
private String taskName;
public TaskThred(String taskName) {
this.taskName = taskName;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+taskName);
}
}
CONCLUSIÓN DE LA
¡¡¡Siempre mantén la fe!!!
