cómo iniciar dos hilos al mismo tiempo (o en el momento de cierre)

Question

Tengo una clase Note y una clase Meeting. Hay un ArrayList llamado noteList en la clase Note. Cuando se crea un objeto de Meeting, se registra en el noteList.

Solo quiero demostrar en la clase principal que se pueden crear dos objetos de Meeting al mismo tiempo (o en el momento de cerrarlo). Mi programa es:

public class Note{ 
    //some field and method hier 
    public void add(Meeting m){ 
     notes.add(m); 
    } 
    private static final List<Entry> notes = 
     Collections.synchronizedList(new ArrayList<Entry>()); 
} 

public class Meeting implements Runnable{ 
    public Meeting(Note note_1,Note note_2,Calendar calendar){ 
     note_1.add(this); 
     note_2.add(this);} 
     //some method 
    } 

    public class Test implements Runnable{ 
     public static void main(String[] args) { 
      Note note_1 = new Note();     
      Note note_2 = new Note(); 
      Meeting m_1 = new Meeting(note_1,note_2); 
      Meeting m_2 = new Meeting(note_2,note_1) 
      Thread t1 = new Thread(m_1); 
      Thread t2 = new Thread(m_2) 
      t1.start(); 
      t2.start(); 
     } 
     //t1,t2 are two thread and they start one to one(not at the same time). 

He leído en cualquier lugar que wait(), notify() o notifyAll() se puede utilizar, pero debe ser utilizado en un método sincronizado. No tengo métodos sincronizados en mi programa.

Answer 1

Esto es lo más cerca que podrá llegar a comenzar los dos hilos.

Lo que podría hacer para sincronizar los métodos de ejecución aún más es tenerlos esperando en un CountDownLatch en la parte superior de sus métodos de ejecución.

Lo que hace es quitar la sobrecarga de crear e iniciar Threads (la parte que ocurre antes de que se ejecute su método de ejecución), y tal vez también algunas extravagancias de programación anormales. Sin embargo, no tiene garantía de cuán concurrente se ejecutará el código después del enganche.

CountDownLatch latch = new CountDownLatch(2); 

Runnable r1 = new Meeting(latch); 
Runnable r2 = new Meeting(latch); 


// in Meeting 

private final CountDownLatch latch; 

public void run(){ 

    latch.countDown(); 
    latch.await(); 

    // other code 
} 

Answer 2

Desafortunadamente, no hay manera de comenzar dos hilos al mismo tiempo.

Déjame explicarte mejor: en primer lugar, la secuencia t1.Start(); y t2.Start(); se ejecuta primero con t1 y, después de eso, t2. Significa solo que el hilo t1 está programado antes de hilo 2, realmente no iniciado. Los dos métodos toman fracciones de segundo cada uno, por lo que el hecho de que estén en secuencia no puede ser visto por un observador humano.

Más, los hilos de Java son programado, es decir. asignado para ser eventualmente ejecutado. Incluso si tiene una CPU multinúcleo, no está seguro de que 1) los hilos se ejecuten en paralelo (otros procesos del sistema puedan interferir) y 2) los hilos comiencen justo después de que se llame al método Start().

Answer 3

Están comenzando desde "cerrar" al mismo tiempo. El punto es que su código no está bloqueando al t1.start().

Es posible que pueda ver esto agregando una instrucción de impresión en la parte superior del método run() de la clase Meeting, y otra instrucción de impresión justo después de t2.start(). Algo como esto:

public class Meeting implements Runnable { 
    private String name; 
    public Meeting(String name) { 
     this.name = name; 
    } 
    public void run() { 
     System.out.println(name + " is running"); 
    } 
} 

public class Test { 
    public static void main(String[] args) { 
     Meeting m_1 = new Meeting("meeting 1"); 
     Meeting m_2 = new Meeting("meeting 2") 
     Thread t1 = new Thread(m_1); 
     Thread t2 = new Thread(m_2) 
     t1.start(); 
     t2.start(); 
     System.out.println("this might print first!"); 
    } 
} 

// possible output: 
> this might print first! 
> meeting 1 is running 
> meeting 2 is running