Los hilos debe comenzar a la misma fracción de segundo. Entiendo que, si no thread1.start(), tomará algunos milisegundos antes de la próxima ejecución de thread2.start().

Siquiera es posible o imposible?

  • Split second es un tiempo muy largo a velocidades GHz.
  • No hay necesidad de downvote tan intensamente. No todo el mundo entiende roscado relacionadas con el no determinismo, y todos tenemos que empezar en algún lugar.
  • No entiendo la downvotes. La sincronización entre hilos es muy común la necesidad. Sí en java puede no ejecutar exactamente en paralelo (que, en otra plataforma puede ser un requisito válido por cierto), pero de vez en cuando es muy común que usted necesita para sincronizar sus acciones. Es por eso que el jdk tiene clases para hacer eso. Tal vez la redacción no es exacta, pero el infierno si se iba a saber, que él no hubiera hecho la pregunta..
  • bueno, supongo que yo entiendo su enojo. Era una pregunta me preguntó en una entrevista…probablemente era un truco P. Pero, me acabo de confundir y quería confirmarlo. por eso pregunté si era posible.
  • no es un «truco», pregunta. Más bien de una cuestión elegido para ver qué tan bien usted realmente entender multi-roscado de programación en general … así como en el de Java caso.
  • Semánticamente hablando, CyclicBarrier es el tipo de mecanismo de sincronización que puede empezar con dos hilos de ejecución «al mismo tiempo» (de nuevo, semánticamente hablando), evitando el costo de la creación de subprocesos en el tiempo. Físicamente hablando, una limitación de hardware y el cambio de contexto (y también Física) dicta dicha noción (si ser tomado literalmente) es ridículo.

InformationsquelleAutor figaro | 2010-07-31

4 Comentarios

  1. 123

    Para iniciar los hilos en exactamente el mismo tiempo (al menos tan buena como sea posible), puede utilizar un CyclicBarrier:

    //We want to start just 2 threads at the same time, but let's control that 
    //timing from the main thread. That's why we have 3 "parties" instead of 2.
    final CyclicBarrier gate = new CyclicBarrier(3);
    
    Thread t1 = new Thread(){
        public void run(){
            gate.await();
            //do stuff    
        }};
    Thread t2 = new Thread(){
        public void run(){
            gate.await();
            //do stuff    
        }};
    
    t1.start();
    t2.start();
    
    //At this point, t1 and t2 are blocking on the gate. 
    //Since we gave "3" as the argument, gate is not opened yet.
    //Now if we block on the gate from the main thread, it will open
    //and all threads will start to do stuff!
    
    gate.await();
    System.out.println("all threads started");

    Esto no tiene que ser un CyclicBarrier, también se podría utilizar un CountDownLatch o incluso un bloqueo.

    Esto todavía no puede asegurarse que se inician exactamente al mismo tiempo estándar de la Jvm, pero usted puede conseguir bastante de cerca. Haciendo bastante cerca todavía es útil cuando usted hace, por ejemplo, las pruebas de rendimiento. E. g., si usted está tratando de medir el rendimiento de una estructura de datos con diferente número de hilos de golpearlo, desea hacer uso de este tipo de construcción para obtener el resultado más preciso posible.

    En otras plataformas, a partir de hilos de exactamente puede ser muy válido requisito btw.

    • +1 buen pensamiento 😉 Aunque, por supuesto, no tiene los hilos de inicio en exactamente a la misma hora en tiempo real (al menos no en un single-core chip, y no se garantiza incluso en un multi-core chip), pero no puedo pensar en alguna manera de hacerlo mejor.
    • Será este el gancho en el medio ambiente específicas esperar asas?
    • Atención a elaborar?
    • La API de Win32, por ejemplo, ofrecen diferentes tipos primitivos. Una de las más útiles es la del tipo de rearme manual evento devuelve al llamar a CreateEvent. msdn.microsoft.com/en-us/library/ms686364%28VS.85%29.aspx
    • Bueno, sea lo que sea, esta es la respuesta que tendrían de haber sido un Java gurú.
    • +1 yo recuerde hacer la barrera problema en mi clase de sistema operativo para varios nodos distribuidos en C. fue un desastre.
    • El primer ejemplo que se proporciona en el CountDownLatch podría dar la impresión de un inicio sincronizados. Que no es cierto, pero fácilmente podría ser parcheado (ver mi propia blog al respecto).
    • Si lo entiendo correctamente, usted está hablando acerca de la demora en la preparación de los hilos antes de que el bloque en el pestillo. Veo cómo eso puede ser un problema. Supongo que es un problema más general en lugar de ser específicos para CountDownLatch. En el mundo real, la gente probablemente hacer los ejercicios de calentamiento para hacer frente con otros factores, como la compilación JIT, que también podría resolver este problema.
    • Realmente me pregunto si ponemos un alto número de hilos que permite decir de 10.000 subprocesos podría ejecutar en el mismo tiempo o no?
    • No, en ese número que usted tendrá un montón de cambio de contexto que arrastra todo el rendimiento y verás mayor varianza (al menos en comunes hoy en día, el hardware..).
    • Gracias. Estoy pensando de la misma. Pero tengo los requisitos para la prueba de 10k hilos en paralelo/simultáneamente/al mismo tiempo y no de manera simultánea para las pruebas de rendimiento. Cómo lograr eso? Alguna idea?
    • Depende de lo que quieras hacer. Si usted desea hacer un montón de red simultáneas llamadas por ejemplo, puede utilizar no el bloqueo de IO.
    • Si usted tiene 2 hilos, ¿se podría hacer que funcione con la puerta = new CyclicBarrier(2) ? la segunda await() llamada desencadenaría la que ambos hilos
    • Esta solución depende de conocer el número de subprocesos. La solución por @aNish el uso de un CountDownLatch es mejor en este aspecto, ya que es más sencillo y menos propenso a errores o más resistente al cambio. Además, no hay nada ‘cíclico’ aquí, por lo que el uso de un CyclicBarrier es todo, pero intuitiva.

  2. 14

    No es posible, al menos en un solo núcleo equipo. Pero ¿por qué quieres eso? Incluso si se puede iniciar de dos hilos en exactamente el mismo segundo, se avanzará de manera diferente, porque la programación no está en tu control.

    Edición: (En respuesta a algunos de los comentarios) es perfectamente válido requisito para sincronizar el estado o progreso de múltiples hilos y CyclicBarrier es una gran herramienta. He respondido a la pregunta de si es posible empezar a varios subprocesos en exactamente el mismo tiempo. CyclicBarrier garantizará que los hilos de proceder cuando están exactamente en el estado deseado, pero no es garantía de que van a iniciar o reanudar en exactamente el mismo tiempo, aunque podría estar muy cerca. No hay ninguna mención de la sincronización de las necesidades en cuestión.

    • Usted puede conseguir bastante maldito cerca de aunque. Todo depende de la sincronización de técnicas que y, por supuesto, tener más de 1 cpu o núcleo.
    • La idea es que este es el mal de cabeza, enfoque y no debe ser necesario en cualquier no-duro-en tiempo real del entorno, no se que es «bastante cerca».
    • Incluso en una simple prueba de rendimiento de los módulos, la sincronización del inicio del tratamiento» es muy necesario para obtener datos válidos.. Y muy cerca de es preferible en estos casos.
    • Es también imposible, porque el thread de Java de programación no te da una precisión de milisegundos.
    • Estoy totalmente de acuerdo. Y el OP no quiere muy cerca. OP quiere mismo fracción de segundo
    • usted puede conseguir probablemente «muy cerca» la mayoría del tiempo en una de inactividad de la máquina. Pero si usted lo necesita todo el tiempo, usted necesita programar en un lenguaje como C, en una máquina con disco duro en tiempo real soporte en el sistema operativo. Hay que considerar también que la JVM puede estar ejecutando un total de GC en la «fracción de segundo» desea iniciar sus hilos.
    • Exactamente. Creo que incluso el sueño no es garantizado para ser exacta a una milésima de segundo.
    • Sí, estoy de acuerdo. Pero todavía hay valor en hacer esto, porque por lo menos usted puede evitar tener completo GC entre el inicio de la t1/t2, etc. Que tipo de preparación es necesaria para hacer que los datos de rendimiento tan fiable como sea posible. Pero, de nuevo estoy de acuerdo en que debemos estar alerta de la OP sobre su punto.. Así que +1 para la respuesta!
    • Es perfectamente válido problema de sincronización. Hilos necesario para inicializar algunos datos, asegúrese de que nadie entra en una región crítica sin una validación adecuada. Y el hecho de que CyclicBerrier se incluye en javas concurrente paquete significa que este un problema importante.
    • estás describiendo la principal intención de CyclicBarrier, que, después de todo, no es para «iniciar hilos en «exactamente» el mismo tiempo», pero para asegurarse de que no el hilo se inicia antes de un evento determinado. Que afortunadamente no requiere la garantía de que cada hilo procede exactamente a la misma hora, como no hay tal garantía existe.

  3. 12

    Usted podría utilizar un CountDownLatch para esto.
    A continuación encontrará una muestra.
    A pesar de que t1 y t2 son iniciado, estos hilos seguir esperando hasta que el hilo principal cuenta el pestillo hacia abajo. El número de cuenta atrás requiere que se menciona en el constructor. Latch de cuenta atrás puede también ser utilizada para esperar por los hilos para finalizar la ejecución, de modo que el hilo principal puede seguir adelante(el caso inverso). Esta clase se incluye desde Java 1.5.

    import java.util.concurrent.CountDownLatch;
    
    
    public class ThreadExample
    {
        public static void main(String[] args) 
        {
            CountDownLatch latch = new CountDownLatch(1);
            MyThread t1 = new MyThread(latch);
            MyThread t2 = new MyThread(latch);
            new Thread(t1).start();
            new Thread(t2).start();
            //Do whatever you want
            latch.countDown();          //This will inform all the threads to start
            //Continue to do whatever
        }
    }
    
    class MyThread implements Runnable
    {
        CountDownLatch latch;
        public MyThread(CountDownLatch latch) 
        {
            this.latch = latch;
        }
        @Override
        public void run() 
        {
            try 
            {
                latch.await();          //The thread keeps waiting till it is informed
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //Do the actual thing
        }
    }
    • Esta respuesta podría beneficiarse de una menor repetitivo en el ejemplo de código.
  4. 6
    1. Como yo lo entiendo, la JVM mayoría de los delegados de este material para el sistema operativo. Así será la respuesta específica del sistema operativo.
    2. Es claramente imposible en un único procesador máquinas.
    3. Es más complicado con respecto a un sistema de multi-procesador de la máquina. De acuerdo a la La relatividad de la simultaneidad, «es imposible decir en un sentido absoluto, si dos eventos ocurren al mismo tiempo, si los eventos están separados en el espacio.» No importa qué tan cerca de sus procesadores son, que están separadas en el espacio.
      1. Si usted puede aceptar simultaneidad relativa, entonces es probable que sea más fácil para simular el uso de las técnicas discutidas en otras respuestas.
    • +1 necesita más referencias en el espacio-tiempo ASÍ
    • …e incluso si asumimos un arranque simultáneo, cada hilo tiene su propia línea de tiempo, todos ellos concurrente, pero no necesariamente en paralelo, de modo que sea alguien que se supone acerca de la simultaneidad de los hilos (será) vacío en el siguiente nanosegundos (de cualquier línea de tiempo)…

Dejar respuesta

Please enter your comment!
Please enter your name here