Работа с потоками идет не так, как надо. Почему?

#include "stdafx.h"
#include "iostream"
#include "windows.h"
#include "stdlib.h"
#include "time.h"
#include "fstream"
#include "winbase.h"
using namespace std;
 
const int ARR_LEN = 86; // длина массивa
int *arr = new int[ARR_LEN];
//ofstream outFile;
 
void CreateTwoProcesses(DWORD priority1, DWORD priority2);  // создает 2 процесса с указанными приоритетами
char* PrToStr(DWORD priority);                              // преобразует переменную DWORD в строку char
void PrintCurrentTime(char *str);                           // выводит текущее время
void insert_sorting(int *a, int count);                     // сортировка массива вставками
void PrintTimeDiff(SYSTEMTIME start, SYSTEMTIME end);       // рассчитывает разницу между интеравалами времени
void CreateTwoThreads(DWORD pr1, DWORD pr2);                // создание двух потоков
DWORD WINAPI print (void *parg);                            // поток печати
DWORD WINAPI sort (void *parg);                             // поток сортировки
 
int _tmain(int argc, _TCHAR* argv[])
{
    CreateTwoThreads(THREAD_PRIORITY_NORMAL, THREAD_PRIORITY_NORMAL);
    CreateTwoThreads(THREAD_PRIORITY_IDLE, THREAD_PRIORITY_HIGHEST);
    CreateTwoThreads(THREAD_PRIORITY_IDLE, THREAD_PRIORITY_IDLE);
    CreateTwoThreads(THREAD_PRIORITY_NORMAL, THREAD_PRIORITY_IDLE);
    system("pause");
    
    return 0;
}
 
//---------------------------------------------------------------------------
void PrintCurrentTime(char *str)
{
   SYSTEMTIME time;
   GetSystemTime(&time); // начало выполнения
   cout << str << time.wMinute << "m:"
               << time.wSecond << "s:"
               << time.wMilliseconds << "ms\n";
}
//---------------------------------------------------------------------------
void PrintTimeDiff(SYSTEMTIME start, SYSTEMTIME end)
{
   FILETIME      ft1, ft2;
   LARGE_INTEGER li1, li2;
   LARGE_INTEGER delta;        // t2-t1
 
   // вычисляем разницу во времени
   SystemTimeToFileTime(&start, &ft1);
   SystemTimeToFileTime(&end, &ft2);
   li1.LowPart  = ft1.dwLowDateTime;
   li1.HighPart = ft1.dwHighDateTime;
   li2.LowPart  = ft2.dwLowDateTime;
   li2.HighPart = ft2.dwHighDateTime;
   // разница
   delta.QuadPart = li2.QuadPart - li1.QuadPart;
   cout << "Vremya sortirovki: " << delta.QuadPart/10000 << "ms" << endl;
}
//---------------------------------------------------------------------------
char *PrToStr(DWORD priority)
{
   char *s;
   switch (priority) {
      case THREAD_PRIORITY_IDLE   : s = strdup("THREAD_PRIORITY_IDLE");   break;
      case THREAD_PRIORITY_NORMAL : s = strdup("THREAD_PRIORITY_NORMAL"); break;
      case THREAD_PRIORITY_HIGHEST: s = strdup("THREAD_PRIORITY_HIGHEST");break;
      default: s = strdup("");
   }
   return s;
}
//---------------------------------------------------------------------------
void CreateTwoThreads(DWORD pr1, DWORD pr2)
{
   HANDLE print_thread;       // поток печати
   HANDLE sort_thread;        // поток сортировки
   DWORD  print_id;
   DWORD  sort_id;
   DWORD  exitcode;
   SYSTEMTIME start_time, end_time;  // время начала и конца работы для определения разницы
 
   GetSystemTime(&start_time);
 
   // заполняем массив
   for (int i = 0; i < ARR_LEN; i++)
      arr[i] = rand() % 10000;
 
   PrintCurrentTime("Nachalo raboty: ");
 
   // создаём поток сортировки
   sort_thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)sort, NULL, CREATE_SUSPENDED, &sort_id);
   cout << "Sozdan potok sort. Prioritet: " << PrToStr(pr1) << endl;
   //outFile << "Sozdan potok sort. Prioritet: " << PrToStr(pr1) << endl;
   
   // создаём поток печати
   print_thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)print, NULL, CREATE_SUSPENDED, &print_id);
   cout << "Sozdan potok print. Prioritet: " << PrToStr(pr2) << endl;
   //outFile << "Sozdan potok print. Prioritet: " << PrToStr(pr2) << endl;
 
   // устанавливаем приоритет pr1, pr2 для обоих потоков соответственно
   SetThreadPriority(sort_thread, pr1);
   SetThreadPriority(print_thread, pr2);
 
   // активизируем потоки
   ResumeThread(print_thread);
   ResumeThread(sort_thread);
 
   // ждём окончания работы потоков
   while (WaitForSingleObject(sort_thread, INFINITE) != WAIT_OBJECT_0 || 
          WaitForSingleObject(print_thread, INFINITE) != WAIT_OBJECT_0);
        GetSystemTime(&end_time);
   PrintCurrentTime("\nKonec raboty: ");
 
   // выводим разницу во времени
   PrintTimeDiff(start_time, end_time);
   cout << endl;
}
//---------------------------------------------------------------------------
DWORD WINAPI print(void *parg)
{
   cout << "Soderjimoe massiva: \n";
   int i;
   for (i = 0; i < ARR_LEN; i++)
   {
        cout << arr[i] << ' ';
   }
   return 0;
}
//---------------------------------------------------------------------------
DWORD WINAPI sort(void *parg)
{
   insert_sorting(arr, ARR_LEN);
   return 0;
}
//---------------------------------------------------------------------------
void insert_sorting(int *a, int count)
{
    int i, j, tmp;
    for (i = 1; i < count; ++i)                     
    {
        tmp = a[i]; 
        for (j = i - 1; j >= 0 && a[j] < tmp; --j)  
        {
            a[j + 1] = a[j];                        
        }
        a[j + 1] = tmp;                             
    }
 
}