Почему моя многопоточная программа выполняется последовательно?

Question

Следующая программа не должна выполняться последовательно, но она по-прежнему делает это.

class A extends Thread 
{ 

    public void run() 
    { 
     for(int i=0; i<=5; i++) 
     { 
      System.out.println("Thread A : "+i); 
     } 
     System.out.println("exit from A"); 
    } 
} 

class B extends Thread 
{ 
    public void run() 
    { 
     for(int j=0; j<=5; j++) 
     { 
      System.out.println("Thread B: "+j); 
     } 
     System.out.println("exit from B"); 
    } 
} 

class C extends Thread 
{ 
    public void run() 
    { 
     for(int k=0; k<=5; k++) 
     { 
      System.out.println("Thread C : "+k); 
     } 
     System.out.println("exit from C"); 
    } 
} 

class ThreadCounter 
{ 
    public static void main(String arg[]) 
    { 
     new A().start(); 
     new B().start(); 
     new C().start(); 
    } 
} 

Выход я получаю:

Thread A start 
Thread A : 1 
Thread A : 2 
Thread A : 3 
Thread A : 4 
Thread A end 
Thread B start 
Thread B : 1 
Thread B : 2 
Thread B : 3 
Thread B : 4 
Thread B end 
Thread C start 
Thread C : 1 
Thread C : 2 
Thread C : 3 
Thread C : 4 
Thread C end 

Можете ли вы сказать мне, почему исполнение таким образом? Не выполнение должно быть последовательным только при запуске

Answer 1

Нити делают так мало работы, что они заканчиваются перед переключением на следующую нить.

Попробуйте увеличить количество циклов до 100000 или более.

Answer 2

Создание и запуск нити имеют себестоимость, это не простая операция освещения. В результате он потребляет некоторые ресурсы.

В вашем примере методы запуска очень просты (цикл для печати 5 для печати). Этот код очень легкий, и выполнение выполняется очень быстро.

Я думаю, что выполнение каждого цикла было выполнено до того, как был создан следующий поток. Попытайтесь добавить Thread.sleep() в цикл, увеличить количество приращений или сделать более сложные вещи.

Answer 3

Когда вызывается новый вызов A(). Start(), создается новый поток и запускается его выполнение. Затем возвращается новый элемент A(). Start(). Когда новый B(). Start() называется потоком, создается поток. В течение этого времени поток A завершит выполнение и вернется, потому что создание нового потока является дорогостоящим и блокирующим вызовом. То же самое происходит с потоком C, потому что поток B уже заканчивается до запуска Thread C. Таким образом, они все еще выполняются параллельно. Но один заканчивается до следующего запуска. Попробуйте запустить A, B и C параллельно не последовательно, как вы делали выше. Тогда вы сможете увидеть разные результаты.