Hilos cada uno tiene su propia pila, pero que comparten un montón.

Su claro para todos que la pila es para local/método de variables & montón, es por ejemplo,/las variables de la clase.

¿Cuál es el beneficio de compartir montón de entre subprocesos.

Hay varios número de subprocesos que se ejecutan simultáneamente, por lo que compartir la memoria puede conducir a problemas tales como la simultánea modificación, exclusión mutua, etc sobrecarga.
¿Qué contenidos son compartidos por los hilos en el montón.

¿Por qué es este el caso? ¿Por qué no tener cada hilo tiene su propio montón así? ¿Alguien puede proporcionar un ejemplo real de esto, la cantidad de memoria que se utiliza por los hilos?

  • Esta pregunta realmente podría utilizar algunas aclaraciones. Por ejemplo, ¿qué se entiende por «idea» y «tiempo real ejemplo»? También, suena como tarea… por Favor etiqueta como tal si es que.
  • He reescrito, pero si esta no es la intención de la pregunta, de rodar de nuevo o modificarla.
  • No, No es claro para todos que la pila es, por ejemplo,/las variables de la clase. Hay otras variables útiles para ser almacenados en la pila, y en muchos idiomas instancia/variables de clase se producen en la pila.
  • Si usted no desea compartir el montón puede así fork().

8 Comentarios

  1. 38

    ¿Qué haces cuando quieres pasar los datos de un hilo a otro? (Si usted nunca hizo que estaría escribiendo programas separados, no una multi-threaded programa.) Hay dos enfoques principales:

    • El enfoque que parecen dar por sentado es de memoria compartida: a excepción de los datos que tiene una razón de peso para subprocesos específicos (tales como la pila), todos los datos son accesibles para todos los subprocesos. Básicamente, hay un montón. Que le da velocidad: en cualquier momento un hilo cambia algunos datos, otros hilos pueden ver. (Limitación: esto no es cierto si los hilos se ejecutan en diferentes procesadores: allí el programador necesita para trabajar especialmente duro para el uso de la memoria compartida correctamente y de manera eficiente.) La mayoría de los principales lenguajes imperativos, en particular, Java y C#, a favor de este modelo.

      Es posible tener un montón por el hilo, además de una compartido montón. Esto requiere que el programador decida qué datos poner donde, y que a menudo no encajó bien con lenguajes de programación existentes.

    • El enfoque dual es paso de mensajes: cada hilo tiene su propio espacio de datos; cuando un hilo quiere comunicarse con otro hilo que necesita explícitamente enviar un mensaje a otro hilo, así como para copiar los datos del remitente del montón para el destinatario del montón. En este contexto muchas comunidades prefieren llamar a las roscas de los procesos. Que le da de seguridad: dado que un hilo no puede sobrescribir algún otro hilo de la memoria en un capricho, un montón de errores se evitan. Otro de los beneficios es distribución: usted puede hacer que los hilos se ejecutan en máquinas separadas sin tener que cambiar ni una sola línea en su programa. Usted puede encontrar bibliotecas de paso de mensajes para la mayoría de las lenguas, sino la integración tiende a ser menos buena. Bueno idiomas para entender el paso de mensajes son Erlang y JoCaml.

      De hecho, el paso de mensajes en entornos generalmente el uso de memoria compartida detrás de la escena, al menos tan largo como los hilos se ejecutan en la misma máquina/procesador. Esto ahorra un montón de tiempo y la memoria ya que el paso de un mensaje de un hilo a otro, no requiere la realización de una copia de los datos. Pero desde la memoria compartida no está expuesta al programador, su inherente complejidad se limita a la lengua/implementación de la biblioteca.

    • Excelente respuesta. De hecho, algunos sistemas operativos antiguos tratados todos los programas en el sistema esencialmente como hilos en un gran proceso del sistema (creo que el Sistema/360 hizo esto?). La diferencia filosófica entre la memoria compartida y paso de mensajes se encuentra en el corazón de las diferencias de diseño entre Windows y Unix incluso hoy en día.
    • muchos sistemas embebidos hacer todavía, porque aplicando el proceso de separación es caro cuando el recuento de la memoria en kB, y se requiere un soporte de hardware (normalmente a través de una MMU). No entiendo donde Windows y Unix difieren en su tratamiento de la concurrencia, podrías elaborar un poco más?
    • Lo que quiero decir es que la plataforma de Windows favorece la memoria compartida de soluciones, con OS-nivel de apoyo para las operaciones de roscado. Por otro lado, Unix, tradicionalmente, ha preferido la comunicación a través de tuberías y tomas de corriente de más de memoria compartida de soluciones. Es por ningún medio de un duro y rápido distinción, ya que ambas soluciones están disponibles en ambas plataformas, pero cada uno tiene su «preferido», y que conduce a la «diferencia filosófica» que he descrito en mi comentario.
  2. 12

    Porque de lo contrario se estaría procesos. Esa es toda la idea de los hilos, para compartir la memoria.

  3. 3

    Procesos no –en general– compartir el espacio de montón. Hay API para permitir esto, pero el defecto es que los procesos son independientes

    Los hilos comparten el espacio de montón.

    Que es la «idea» — dos maneras de utilizar la memoria — compartidos y no compartidos.

    • los procesos pueden compartir montón de espacio de memoria compartida APIs que proporcionan. Ah, y Windows 3.1 -> Windows Me compartido montones 🙂
    • Requiere especial de la API para cumplir, no el valor predeterminado.
    • En Linux puedes compartir lo que te gusta usar clone().
  4. 2

    En muchos idiomas/tiempos de ejecución de la pila es (entre otras) que se utiliza para mantener la función/método de parámetros y variables. Si el hilo compartido una pila, las cosas iban a poner muy complicado.

    void MyFunc(int a) //Stored on the stack
    {
       int b; //Stored on the stack
    }

    Cuando la llamada a ‘MyFunc’ es de hecho, el apilado se apareció y a y b ya no está en la pila. Porque los hilos no compartir las pilas, no hay ningún problema subprocesamiento para las variables a y b.

    Debido a la naturaleza de la pila (empujar/popping) no es realmente adecuado para mantener a ‘largo plazo’ estado o estado compartido a través de las llamadas de función. Como este:

    int globalValue; //stored on the heap
    
    void Foo() 
    {
       int b = globalValue; //Gets the current value of globalValue
    
       globalValue = 10;
    }
    
    void Bar() //Stored on the stack
    {
       int b = globalValue; //Gets the current value of globalValue
    
       globalValue = 20;
    }
    
    
    void main()
    {
       globalValue = 0;
       Foo();
       //globalValue is now 10
       Bar();
       //globalValue is now 20
    }
  5. 1

    El Montón está por todas de memoria fuera de la pila que se asigna de forma dinámica. Ya que el sistema operativo proporciona un único espacio de direcciones, a continuación, se hace evidente que el heap es, por definición compartida por todos los subprocesos en el proceso. En cuanto a por qué las pilas no son compartidos, esto es debido a que un subproceso de ejecución tiene su propia pila de ser capaz de gestionar su árbol de llamadas (contiene información acerca de qué hacer cuando se sale de una función, por ejemplo!).

    Ahora usted podría, por supuesto, escribir un administrador de memoria que se asigna a los datos desde diferentes áreas de su espacio de direcciones dependiendo del subproceso de llamada, pero otros hilos todavía podría ser capaz de ver los datos (como si de alguna manera la pérdida de un puntero a algo en la pila del subproceso a otro hilo, que el otro hilo se podría leer, a pesar de ser esta una idea horrible)

    • Para ser pedante, muchos de los administradores de memoria hecho asignar memoria a partir de las diferentes áreas (arenas), sino que lo hacen para mejorar el rendimiento. Por supuesto, el resultado de la memoria todavía está compartida.
  6. 1

    El problema es que tener a montones añade una complejidad significativa de muy poco valor.

    Hay una pequeña ventaja en el rendimiento y esto es bien manejada por el TLAB (Subproceso de Asignación Local de Búfer), que le da la mayoría de la ventaja de forma transparente.

  7. 1

    En una aplicación multiproceso cada hilo tiene su propia pila, pero comparten el mismo montón. Esta es la razón por la que debe tenerse cuidado en su código para evitar cualquier acceso simultáneo problemas en el montón de espacio. La pila de subprocesos (cada hilo tiene su propia pila), pero el montón no es seguro para subprocesos menos vigilado con sincronización a través de su código.

  8. 0

    Que es porque la idea de los hilos es «compartir todo». Por supuesto, hay algunas cosas que no se pueden compartir, como contexto del procesador y de la pila, pero todo lo demás es compartido.

Dejar respuesta

Please enter your comment!
Please enter your name here