Cuando compramos una computadora, a menudo prestamos especial atención a cuántos núcleos e hilos tiene la CPU de la computadora. Porque esto a menudo determina la velocidad de la computadora.

, y todo esto se puede encontrar en el administrador de tareas.

En este momento, a pesar de que ha estado expuesto a operaciones de subprocesos múltiples, es posible que tenga dudas sobre qué es un subproceso.

Según la Enciclopedia de Baidu: Thread (inglés: thread) es la unidad más pequeña que el sistema operativo puede realizar la programación de operaciones . Está incluido en el proceso y es la unidad operativa real en el proceso . Un subproceso se refiere a un único flujo secuencial de control en un proceso Múltiples subprocesos pueden ejecutarse simultáneamente en un proceso, y cada subproceso realiza diferentes tareas en paralelo. En Unix System V y SunOS , también se denominan procesos ligeros (lightweight processs), pero los procesos ligeros se refieren a los subprocesos del núcleo (kernel threads), y los subprocesos de usuario (subprocesos de usuario) se denominan subprocesos.

Entonces, ¿cuándo necesitamos usar subprocesos múltiples?

1 : Procesar múltiples tareas diferentes al mismo tiempo

Por ejemplo, un sistema de videoconferencia:

1 : transmitir audio

2 : Transmitir vídeo

3 : Compartir escritorio

2 : Procesar múltiples tareas idénticas al mismo tiempo (también conocido como simultaneidad )

Pelota pequeña 5000

1 : Un subproceso sondea todas las operaciones, como sacar y mover la bola.

Cuando el número de bolas aumenta: el sondeo lleva mucho tiempo

Multi-hilo para manejar estas bolas:

Un solo hilo solo es responsable de una parte: digamos que un hilo solo ejecuta mil

3: modo de canalización

Una completa cadena de misiones que tiene

Tarea 1 :

Tarea 2 : requiere que se complete la tarea 1

Tarea 3 : Requiere que se complete la Tarea 2

Si lo hace, permite el uso más eficiente de cada subproceso.

Entonces, ¿qué es la seguridad de concurrencia de subprocesos?

Cuando se trata de tareas concurrentes, dado que varios subprocesos operan en el mismo recurso, el tiempo de operación no se escalona, lo que hace que la operación en la memoria se repita, lo que genera confusión de datos y genera problemas de seguridad.

Por ejemplo: Hemos arreglado tareas para cada hilo, es decir, sumando 1000 veces a num.

Pasos de la operación de la pila de subprocesos: obtenga num de la memoria del montón -->> copie la copia num a la pila de subprocesos -->> realice la operación num++

——>>Retorna num y asígnalo a num en la memoria del montón.

¿Parece estar esto en orden, pero observamos que no necesariamente solo un subproceso obtiene num de la memoria del montón al mismo tiempo?

Si varios hilos lo obtienen, se repetirá la operación num++, de modo que el número final sea inferior a 3000 ++ y los datos sean incorrectos.

Situaciones comunes:

1 : Leer y leer no causará problemas de seguridad de subprocesos

2: La lectura y la escritura generarán

3 : Escribir escribir generará

¿Y cómo solucionamos este problema?

Después de todo, si estos datos representan la cantidad en su banco, ¡no querrá que estén equivocados! ! !

Uso de bloqueos ( sincronizados) :

Sincronice bloques de código, bloquee recursos y solo permita que los subprocesos que actualmente tienen bloqueos de monitor accedan a los recursos

Puede entenderse como: cuando un subproceso copia num en la memoria del montón, la memoria del montón se "bloquea" temporalmente y no se puede acceder a ella.

Solo cuando el subproceso complete la operación de num y asigne num a la memoria del montón, se "desbloqueará" para que otros subprocesos continúen compitiendo para acceder a la memoria del montón.

Esto no solo puede garantizar que la operación no se repita, los datos no serán incorrectos y, al mismo tiempo, debido al mecanismo de acceso competitivo, la velocidad de la tarea se acelerará considerablemente.

Los ejemplos son los siguientes:

Clase de tarea:

public class Task{

     static int num=0;//静态变量，处于堆内存中

    public static void main(String[] args) {

        Task tt = new Task();
        Thread t1=new Thread(new Threadsy(tt));
        t1.start();
        Thread t2=new Thread(new Threadsy(tt));
        t2.start();
        Thread t3=new Thread(new Threadsy(tt));
        t3.start();//创建并启动三个线程

        try {
            t1.join();
            t2.join();
            t3.join();
        } catch (InterruptedException e) {
            throw new RuntimeException (e);
        }//阻塞，直到线程全部完成，便于得到最终结果

        System.out.println(tt.num);//检验结果
        
    }
}

Clase hilada:

public class Threadsy implements Runnable {

    Task tt = new Task();
    public Threadsy(Task tt) {
        this.tt = tt;
    }//构析方法，便于取堆内存中的num。

    static Object object = new Object();//值得注意的是，Object要保证是静态变量，存在堆内存中，才可以通过它“锁住”堆内存的num

    public void run() {
            for (int i = 0; i < 1000; i++) {

                synchronized (object/*只能“锁”对象*/) {
                    tt.num++;
                }//给堆内存上锁，保证线程安全

        }
    }//线程操作方式
}

Los resultados son ambos:

¡todo es normal! ! !

Y si quitamos el bloqueo de recursos:

es decir, error de datos:

Para tareas concurrentes, el uso de subprocesos múltiples puede mejorar en gran medida la eficiencia, ¡pero preste mucha atención a los problemas de seguridad de los subprocesos!

Escenarios que utilizan subprocesos: causas y soluciones para la seguridad de la concurrencia de subprocesos