El concepto es sencillo de entender
- Programa (Programm)
- El concepto: es llevar a cabo una tarea específica, con la recogida de un conjunto de instrucciones escritas en un idioma. Se refiere a un periodo de código estático.
- El procedimiento (proceso)
- Concepto: proceso o un programa que se ejecuta una vez que la ejecución del programa.
- Descripción: A medida que el proceso de unidades de asignación de recursos en el sistema de tiempo de ejecución asignará un área de memoria diferente para cada proceso
- Thread (hilo)
- El concepto: El proceso puede ser refinado adicionalmente en hilos, es una ruta de ejecución de un programa interno.
- Descripción: Como las unidades de programación de subprocesos y de ejecución, cada hilo propiedad pila de ejecución y contador de programa (PC) independiente, pequeño hilo de conmutación por encima.
Añadido:
Estructura de la memoria:
El proceso puede ser refinado en varios subprocesos.
Cada hilo tiene su propia independiente: pila, contador de programa
múltiples hilos comparten la misma estructura proceso: distrito Método, montón.
- Comprender la CPU de un solo núcleo y CPU multi-core
CPU de un solo núcleo, de hecho, se trata de una falsa multi-roscado, porque en una unidad de tiempo, sólo se puede realizar tareas de un hilo. Por ejemplo: A pesar de múltiples carriles, pero sólo personal de la estación de peaje en una carga, sólo recibió una cuota para pasar, a continuación, la CPU es como el cajero. Si alguien no quiere pagar, puede cargar él "colgar" (colgándolo, por lo que descubrió, el dinero listo, vaya cuota.) Pero debido a que las unidades de tiempo de CPU son especialmente corto, por lo que no se sienten fuera .
Si este es el caso de varios núcleos, con el fin de un mejor juego a la eficiencia de multi-hilo. (Ahora los servidores son multinúcleo)
- A java.exe aplicación Java, de hecho, al menos tres hilos: main () hilo principal, gc () hilo recolección de basura, excepción hilo manipulación. Por supuesto, si se produce una excepción, que afectará el hilo principal.
- Paralela y concurrente comprensión
paralelo : múltiples CPU realizar simultáneamente múltiples tareas. Por ejemplo: más de una persona al mismo tiempo haciendo cosas diferentes.
Concurrencia : una CPU (con el intervalo de tiempo) realizan simultáneamente múltiples tareas. Por ejemplo: punto, más de una persona a hacer lo mismo
Dos formas de crear multi-roscado
Una forma: clase Thread herencia.
- Creación de una clase hereda hilo de una subclase
- clase de reescritura de ejecución de rosca () -> cuenta de resultados en este hilo de ejecución de ejecución () en
- Crear un objeto de una subclase de la clase Thread
- Este objeto llamadas start (): ① ② comienzan el subproceso actual que llama la carrera del hilo actual ()
Muestra dos cosas:
hay un problema: empezamos un hilo, se debe llamar al inicio (), no se puede llamar a la forma de ejecución () para iniciar el hilo.
Segunda pregunta: Si partimos de un hilo, se debe volver a crear una subclase del objeto Thread, llame inicio del objeto ().
Segunda manera: implementación de la interfaz Ejecutable.
- Crear una clase que implementa la interfaz Ejecutable
- Implementar la clase abstracta para implementar el método de Ejecutable: run ()
- Crear una clase de implementación de objetos
- Este objeto se pasa como argumento al constructor de la clase Thread, crear una clase de objeto Thread
- inicio de la llamada a través del objeto de la clase Thread ()
Comparación de dos maneras:
-
Desarrollo: preferencias: implementar manera Ejecutable
-
Motivo:
-
- Limitaciones de la herencia simple no es el camino para alcanzar la clase
-
- La forma de lograr más adecuado para tramitar los asuntos en que múltiples hilos comparten datos.
-
Contactarme: public class implementos hebra ejecutable
-
Similitudes: Ambos enfoques necesidad de ejecutar anulación (), una afirmación lógica se ejecutará en el plazo de rosca () en.
目前两种方式，要想启动线程，都是调用的Thread类中的start()。
clase thread
clase Thread métodos comúnmente utilizados:
1. start():启动当前线程；调用当前线程的run()
2. run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
3. currentThread():静态方法，返回执行当前代码的线程
4. getName():获取当前线程的名字
5. setName():设置当前线程的名字
6. yield():释放当前cpu的执行权
7. join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
8. stop():已过时。当执行此方法时，强制结束当前线程。
9. sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
10. isAlive():判断当前线程是否存活
Prioridad de los hilos:
1.
- MAX_PRIORITY: 10
- MIN _PRIORITY: 1
- NORM_PRIORITY: 5 -> prioridad por defecto
2. ¿Cómo obtener y definir la prioridad del hilo actual:
-
getPriority (): Obtener la prioridad del hilo
-
subproceso de prioridad: setPriority (int p)
-
Descripción: hilos de alta prioridad para ejecutar el derecho de apoderarse de la baja prioridad de la CPU hilo. Pero sólo en términos de probabilidad, que se lleva a cabo en prioridad alta hilo de alta probabilidad. Cuando eso no quiere decir único hilo de alta prioridad la ejecución del subproceso de prioridad baja antes de la ejecución.
la comunicación Tema: wait () / notify () / notify (): Este método se define en tres clases de objetos.
Añadido: hilos Clasificación
uno es un hilo de utilidad, se trata de subprocesos de usuario.
El hilo del ciclo de vida
Descripción:
- Ciclo de Vida se centran en dos conceptos: el Estado, el método apropiado
- Atención: Estado a-> b estados: ¿Qué método se ejecuta (método de devolución de llamada)
una iniciativa de invocación de método: Estado a-> b Estado - Obstrucción: un estado temporal, no como la situación final
de la muerte: el estado final.
mecanismo de sincronización Thread
Portal: aquí
la comunicación entre hilos
- Enhebrar método de comunicación en relación con tres :
- wait (): Al realizar este método, el hilo actual en el estado bloqueado, y la liberación de Monitores de sincronización.
- notificar (): Al realizar este método, se despertará un hilo de espera. Si hay varios subprocesos esperan, se despiertan la alta prioridad.
- notifyAll (): Al realizar este método, se despertará todo el hilo de espera.
- Descripción :
- 1.wait (), notificar (), el método notifyAll () debe ser utilizado en tres bloques o método de sincronización de código de sincronización.
- 2.Espere (), notificar (), el método notifyAll () se llama tres deben ser sincronizados sincronización bloque o método de supervisión de la sincronización.
- De lo contrario, habrá una excepción IllegalMonitorStateException
- 3.Espere (), notificar (), el método notifyAll () se define en tres clases java.lang.Object.
- preguntas de la entrevista :
preguntas de la entrevista: sueño () y wait () las similitudes y diferencias?
- 1. mismo punto: Una vez que se lleva a cabo el método, de modo que el hilo de corriente puede entrar en el estado de bloqueo.
- 2. Diferentes puntos: 1) la declaración del método dos posiciones diferentes: el sueño declaración de la clase Thread (), el objeto declaración de la clase de espera ()
-
2）调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中 -
3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。
- Resumen de la operación de desbloqueo :
Resumen no dará a conocer la operación de bloqueo:
JDK5 manera de crear nuevos temas
Una nueva forma: para lograr la interfaz invocable. - JDK 5.0 nuevo
//1.创建一个实现Callable的实现类
class NumThread implements Callable{
//2.实现call方法，将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 1; i <= 100; i++) {
if(i % 2 == 0){
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class ThreadNew {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
NumThread numThread = new NumThread();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask = new FutureTask(numThread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
new Thread(futureTask).start();
try {
//6.获取Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
Object sum = futureTask.get();
System.out.println("总和为：" + sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
Descripción:
- Crear manera multi-roscado para entender cómo lograr interfaz invocable, la interfaz Ejecutable multi-hilo para crear poderosos que logra?
- llamar () puede devolver un valor.
- llamar () puede lanzar una excepción, la parte exterior de la operación de captura, la información de anomalía adquirida
- genéricos de apoyo que se puede llamar
Nueva forma: el uso de un grupo de subprocesos
class NumberThread implements Runnable{
@Override
public void run() {
for(int i = 0;i <= 100;i++){
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
class NumberThread1 implements Runnable{
@Override
public void run() {
for(int i = 0;i <= 100;i++){
if(i % 2 != 0){
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
public class ThreadPool {
public static void main(String[] args) {
//1. 提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
//设置线程池的属性
// System.out.println(service.getClass());
// service1.setCorePoolSize(15);
// service1.setKeepAliveTime();
//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread());//适合适用于Runnable
service.execute(new NumberThread1());//适合适用于Runnable
// service.submit(Callable callable);//适合使用于Callable
//3.关闭连接池
service.shutdown();
}
}
Descripción:
- Beneficios:
1. Para mejorar la velocidad de respuesta (reducción en el tiempo para crear un nuevo hilo)
2. Reducir el consumo de recursos (subproceso del grupo de hilo para la reutilización, no es necesario para crear cada vez)
3. facilitar la gestión de hilo -
corePoolSize：核心池的大小 -
maximumPoolSize：最大线程数 -
keepAliveTime：线程没任务时最多保持多长时间后会终止
preguntas de la entrevista: crear multi-hilo de Java, hay varias maneras? Cuatro.
