Una breve comprensión de la diferencia entre procesos y hilos en el sistema operativo:
Proceso: cada proceso tiene código independiente y espacio de datos (contexto del proceso), y el cambio entre procesos tendrá una sobrecarga grande. Un proceso contiene hilos 1-N. (El proceso es la unidad más pequeña de asignación de recursos)
Tema: El mismo tipo de hilos comparten código y espacio de datos. Cada hilo tiene una pila de ejecución independiente y contador de programa (PC), y la sobrecarga de cambio de hilo es pequeña. (El hilo es la unidad más pequeña de programación de CPU)
Al igual que un proceso, los hilos se dividen en cinco etapas: creación, lista, ejecutándose, bloqueando y terminando.
Multiprocess significa que el sistema operativo puede ejecutar múltiples tareas (programas) al mismo tiempo.
Multithreading se refiere a múltiples secuencias secuenciales que se ejecutan en el mismo programa. En primer lugar, la operación de ahorrar dinero y retirar dinero debe estar enhebrado, y puede haber muchos clientes. Esto significa que debe haber múltiples hilos, y múltiples hilos operan conjuntamente un banco, y el monto del banco debe sincronizarse. Solo asegurando la seguridad del hilo.
Entonces, pongamos este ejemplo de este código aquí. Si hay algo mal, apírtelo. Porque un anciano preguntó sobre este código múltiple.
En primer lugar, el banco, la creación de este modelo de objeto.
paquete com.lxk.threadtest.bank;/*** modelo bancario, un atributo de cantidad total. * <p> * * @Author LXK en 2017/6/26 */public class Bank {/** * Déle al banco un capital inicial, de lo contrario, ¿cómo puede hacer negocios? */private int sum = 200; // Esto nunca se usa así, pero también es un mecanismo de bloqueo correcto: sincronizar bloques de código. // object obj = new Object (); /*** Ahorre dinero* Si no agrega [función sincronizada-sincronizada], se producirán problemas de seguridad multiproceso. */public Synchronized void add (int n) {// sincronizado (obj) {sum = sum + n; try {thread.sleep (10);} capt (excepción ignore) {} // Cuando el número de tiempos de ahorro de dinero se vuelve más, puede encontrar que los hilos de dinero de ahorro están realmente realizando la acción de ahorro. System.out.println (Thread.CurrentThread (). GetName () + "... sum =" + sum); //}}/*** Retirar dinero* Si no agrega [sincronizado-función sincronizada], se producirán problemas de seguridad multithread. */public sincronizado void reduce (int n) {if (sum - n> = 0) {sum = sum - n;} else {system.out.println ("¡El dinero del banco no es suficiente!");} try {Thread.SeLep (30);} Catch (Exception ignore) {} // Cuando el número de tiempos de ahorro se convierte en el dinero que se convierte más, usted puede encontrar que los hilos que hilos son los hilos que hilados son los hilos que se salvan al alternativas que son de hecho de que los dos hilos son los dos alternativos que salen los dos. ahorrando dinero. System.out.println (thread.currentThread (). GetName () + "... sum =" + sum);}}Hay dos métodos en el código: guardar y buscar, estos dos métodos y una cantidad total, y algunos comentaron el código. Eso es simple y fácil de entender, bloqueo de múltiples subprocesos mutuamente excluyentes, y garantiza la sincronización entre hilos.
Sin embargo, este es un método infrecuente. El método de uso común es usar la palabra clave sincronizada para modificar el método de sincronización.
Modelo de objeto cliente
paquete com.lxk.threadtest.bank;/*** cliente, implementa la interfaz runnable (), y varias personas pueden ahorrar dinero juntas** @author lxk en 2017/6/26*/public class Customer Implements Runnable {/*** Tipo de ahorro*/static final type_add = "add";/*** Tipo de retiro*/static straty type _rede "; Bank*/private Bank Bank;/***Tipo de operación por dinero, ahorro o retiro*/private string type;/***El número de operaciones es teóricamente un número positivo*/private int tiempo;/***cuánto ahorrar o retirar*/private int dinero; público customer () {} Customer (bancario bancario, tipo de cadena, TIME, int, int Money) {this.bank = bank; this.typePe; type; = dinero;}@anular public void run () {for (int x = 0; x <time; x ++) {if (type_add.equals (type)) {bank.add (dinero);} else if (type_reduce.equals (type)) {bank.reduce (dinero);}}}}Como objeto del cliente, dado que muchos clientes pueden acceder a un banco al mismo tiempo, la operación de ahorrar y retirar dinero se implementa utilizando hilos.
El atributo está construido para pasar el valor.
Método principal
paquete com.lxk.threadtest.bank;/** * Instancia multiprocesada de dinero depositando dinero * <p> * [requisitos:] * El banco tiene una bóveda. * Hay dos depositantes que depositan o retiran n * 100 respectivamente. * Propósito: ¿Hay algún problema de seguridad con este programa? Si es así, ¿cómo resolverlo? * <p> * [Cómo encontrar el problema:] * 1. Borre qué códigos son códigos multiproceso. * 2. Claramente compartir datos. * 3. Borre qué declaraciones en código multiproceso funcionan con datos compartidos. * * @author lxk on 2017/6/26 */public class Main {public static void main(String[] args) {//One bank and multiple customers Bank bank = new Bank();int time = 10000;int money = 100;//This customer saves money Customer c1 = new Customer(bank, Customer.TYPE_ADD, time, money);//This customer withdraws money Customer c2 = new Customer(bank, Customer.type_reduce, tiempo, dinero); hilo t1 = nuevo hilo (c1); hilo t2 = nuevo hilo (c2); t1.start (); t2.start ();}}El efecto de operación real del código anterior se muestra en la figura a continuación.
Si el número de veces de depósito y retiro de dinero es pequeño, puede ver que los dos hilos tienen una secuencia. Por lo tanto, tenemos un mayor número de veces. Luego, veremos la situación como se muestra en la figura. El hilo 1 retira dinero, y cuando el hilo 0 ahorra dinero, puede ver que los dos hilos se ejecutan entrelazados, con almacenamiento y retiro, y no hay patrón.
Esto garantiza la sincronización de datos.
En cuanto a cómo estar fuera de sincronización, es decir, fenómenos anormales,
Puede eliminar la palabra clave sincronizada del método Agregar, reducir el número de veces y cambiarla a 3 veces y establecer el valor inicial de la suma a 0. Intente el código nuevamente,
Encontrará el llamado fenómeno de asíncrono.
El resultado de la sincronización fuera del lado derecho de la figura anterior es que las dos personas ahorran 100 cada vez, tres veces. ¿Se obtiene el número total? 100,200,300,400,500,600. Lleva mucho tiempo.
Sin embargo, el resultado de la operación no es
En este momento, si se agrega sincronizado al método Agregar, aparecerá el resultado del gráfico a la izquierda, que es el resultado correcto.
Agregué otro método por el bien de la existencia y la retirada. El código se convierte en lo que parece arriba.
Estos son casi todos los ejemplos de sincronización entre hilos.
Grabaré el código brevemente. Cuando se usa, puede sacarlo en minutos.
Resumir
Lo anterior es el código completo de este artículo sobre la simulación de un problema de sincronización multiproceso de Java utilizando el retiro bancario como ejemplo. Espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a este sitio:
Ejemplo de programación multiproceso de Java
El principio y la implementación del temporizador de temporizador multithreaded Java
Java comprende múltiples subprocesos vendiendo boletos
Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!