Explicación detallada de los hilos Java y la diferencia entre hilos y procesos
1. Procesos e hilos
Cada proceso tiene un espacio de memoria único, y una aplicación puede iniciar múltiples procesos al mismo tiempo. Por ejemplo, en el navegador IE, abrir un navegador IE es equivalente a comenzar un proceso.
Un hilo se refiere a un proceso de ejecución en un proceso, y un proceso puede contener múltiples hilos.
Cada proceso necesita el sistema operativo para asignarle espacio de memoria independiente, y múltiples hilos en el mismo proceso comparten este espacio, es decir, memoria compartida y otros recursos.
Cada vez que se llama a Java.exe, el sistema operativo iniciará un proceso de máquina virtual Java. Cuando se inicia el proceso de máquina virtual Java, la máquina virtual Java creará un hilo principal, que comenzará a ejecutar desde el método principal de entrada del programa.
Cada vez que una máquina virtual Java inicia un subproceso, asignará una pila de método de subproceso al hilo para almacenar información relevante (como variables locales, etc.), y el hilo se ejecuta en esta pila. Por lo tanto, las variables locales en los objetos Java son seguras de hilo, pero las variables de instancia y las variables de clase no se almacenan en la pila, por lo que no son seguras de hilo.
Hay tres estados del proceso: listo, ejecución y bloqueo.
2. Método de creación de hilos
Método ejecutable: (este método es flexible, recomendado)
public class Thread02 implementa Runnable {public static void main (string [] args) {runnable r = new <strong> thread02 </strong> (); Hilo t1 = nuevo hilo (<strong> r </strong>, "t1"); /*** Código fuente de hilo* Public Thread (Runnable Target, String Name) {init (null, target, nombre, 0); } */ Hilo t2 = nuevo hilo (r, "t2"); t1.start (); // Iniciar el hilo T1, en estado listo, esperando CPU T2.Start (); // Iniciar el hilo T2, en estado listo, esperando CPU T1.run (); // El hilo principal llama el método de ejecución del objeto t1} public void run () {System.out.println ("El nombre del hilo es" + Thread.CurrentThread (). GetName ()); }}El resultado de la operación puede ser:
El nombre de Thread es el nombre de T1Thread es el nombre de MainThread es T2
El camino de la cabeza
public class Thread03 extiende el hilo {public static void main (string [] args) {thread03 t1 = new <strong> thread03 </strong> (); // escríbalo como hilo t1 = new Thread () Nota: Thread03 es un hilo en este momento t1.start (); } public void run () {System.out.println ("El nombre del hilo es" + Thread.CurrentThread (). getName ()); }}Resultado de ejecución: el nombre del hilo es Thread-0
Nota: Además de los hilos personalizados, también hay un hilo principal cada vez que se ejecuta el programa.
integral:
public class Thread01 {public static void main (string [] args) {Thread Thread = new Thread (); thread.start (); // Lo que realmente funciona es ejecutar ()/** y ejecutar en Thread* public void run () {if (target! = null) {target.run (); }} Entonces el hilo que creó debe reescribir el método Ejecutar y poner el contenido para ejecutarse en ejecución (), por lo que debe implementar la interfaz o la herencia y luego generar subclases*// cómo crear el método subclass de subclases de hilo de hilo (inherance) thread thread1 = new thread () {public void run () {while) {try {try {try shread.sleep (500); (InterruptedException e) {E.PrintStackTrace (); } //Thread.currentThread () obtiene el hilo actual system.out.println ("El nombre de hilo 1 es"+Thread.CurrentThread (). GetName ()); }}}}; // thread1.start (); // no puede comenzar sin escribir el hilo // cómo crear el método de hilo 2 ejecutable (implementación) se recomienda usar hilo hescinte2 = new Thread (new runnable () {public void run () {while (true) {try {thread.ssleep (300);} capt (interruptedException e) {e.printStackTrace "+Thread.currentThread (). GetName ());}}}); // thread2.start (); // Ejecutar Thread New Thread (new runnable () {public void run () {system.out.println ("runnable"+thread.currentThread (). getName ());}}) {public void run () {// El método de ejecución en el método de subclass anula el método de ejecución en el plato parentable, por lo que no se ejecutará el sistema ejecutado. "+Thread.currentThread (). GetName ()); } }.comenzar(); } /****Es muy probable que la ejecución de la lectura múltiple en una sola CPU reduzca la eficiencia de la ejecución en lugar de mejorar una persona que hace lo mismo en diferentes lugares* /}Gracias por leer, espero que pueda ayudarte. ¡Gracias por su apoyo para este sitio!