Global shared optimum - almost ready

Graph.cpp

     // Implementacja: Jan Potocki 2019
     std::vector<unsigned> startVertexVector;
     std::vector<std::thread> threadsVector;
-    std::vector<std::vector<unsigned>> resultsVector(threadsNumber);
 
-    std::vector<int> resultsLength(threadsNumber);
-    std::vector<unsigned> optimalResult;
-    int optimalResultIndex;
-    int optimalResultLength;
+    std::mutex globalOptimumMutex;
+    std::vector<unsigned> globalOptimum;
+    unsigned globalOptimumLength = -1;
 
     std::random_device randomSrc;
     std::default_random_engine randomGen(randomSrc());
     std::uniform_int_distribution<> vertexDist(0, graph.vertexNumber - 1);
 
-    std::mutex globalOptimumMutex;
-    unsigned globalOptimum = -1;
-
     // Petla uruchamiajaca watki
     for(int i = 0; i < threadsNumber; i++)
     {
         }
 
         // Uruchomienie watku
-        threadsVector.push_back(std::thread(Graph::travellingSalesmanTabuSearchEngine, std::ref(graph), tabuSteps, diversification, iterationsToRestart, minStopTime, startRoute, std::ref(resultsVector.at(i)), std::ref(resultsLength.at(i)), std::ref(globalOptimum), std::ref(globalOptimumMutex)));
+        threadsVector.push_back(std::thread(Graph::travellingSalesmanTabuSearchEngine, std::ref(graph), tabuSteps, diversification, iterationsToRestart, minStopTime, startRoute, std::ref(globalOptimum), std::ref(globalOptimumLength), std::ref(globalOptimumMutex)));
     }
 
     // Petla potwierdzajaca zakonczenie watkow
     for(int i = 0; i < threadsNumber; i++)
         threadsVector.at(i).join();
 
-    // Przegladanie wszystkich rozwiazan i wybor optymalnego
-    optimalResultIndex = 0;
-    optimalResultLength = resultsLength.at(0);
-
-    for(int i = 0; i < threadsNumber; i++)
-    {
-        if(resultsLength.at(i) < optimalResultLength)
-        {
-            optimalResultIndex = i;
-            optimalResultLength = resultsLength.at(i);
-        }
-    }
-
-    optimalResult = resultsVector.at(optimalResultIndex);
-
-    return optimalResult;
+    return globalOptimum;
 }
 
-void Graph::travellingSalesmanTabuSearchEngine(Graph &graph, unsigned tabuSteps, bool diversification, int iterationsToRestart, unsigned minStopTime, std::vector<unsigned> startRoute, std::vector<unsigned> &result, int &resultLength, unsigned &globalOptimum, std::mutex &globalOptimumMutex)
+void Graph::travellingSalesmanTabuSearchEngine(Graph &graph, unsigned tabuSteps, bool diversification, int iterationsToRestart, unsigned minStopTime, std::vector<unsigned> startRoute, std::vector<unsigned> &globalOptimum, unsigned &globalOptimumLength, std::mutex &globalOptimumMutex)
 {
     // ALGORYTM oparty na metaheurystyce tabu search z dywersyfikacja i sasiedztwem typu swap
     // Rdzen przeznaczony do uruchamiania jako jeden watek
                     }
 
                     // Kryterium aspiracji...
-                    if(tabu == true && neighbourRouteLength >= optimalRouteLength)
+                    globalOptimumMutex.lock();
+                    if(tabu == true && neighbourRouteLength >= globalOptimumLength)
+                    {
+                        globalOptimumMutex.unlock();
+
                         // ...jezeli niespelnione - pomijamy ruch
                         continue;
+                    }
+                    else
+                        globalOptimumMutex.unlock();
 
                     if(nextRouteLength == -1)
                     {
             // Jan Potocki 2019
 
             globalOptimumMutex.lock();
-            if(globalOptimum == -1)
+            if(globalOptimumLength == -1)
             {
-                globalOptimum = nextRouteLength;
+                globalOptimumLength = nextRouteLength;
+                globalOptimum = nextRoute;
                 optimalRoute = nextRoute;
 
                 // Reset licznika
                 stopCounter = 0;
 
-                std::cout << "Nowa najlepsza trasa: " << globalOptimum << std::endl;
+                std::cout << "Nowa najlepsza trasa: " << globalOptimumLength << std::endl;
             }
-            else if(globalOptimum > nextRouteLength)
+            else if(globalOptimumLength > nextRouteLength)
             {
-                globalOptimum = nextRouteLength;
+                globalOptimumLength = nextRouteLength;
+                globalOptimum = nextRoute;
                 optimalRoute = nextRoute;
 
                 // Zaplanowanie intensyfikacji przy znalezieniu nowego optimum
                 // Reset licznika
                 stopCounter = 0;
 
-                std::cout << "Nowa najlepsza trasa: " << globalOptimum << std::endl;
+                std::cout << "Nowa najlepsza trasa: " << globalOptimumLength << std::endl;
             }
             globalOptimumMutex.unlock();
 
         stopCounter = 0;
     }
 
-    result = optimalRoute;
-    resultLength = optimalRouteLength;
+std::cout << std::endl;
 }

Graph.h

         unsigned vertexNumber;
 
     private:
-        static void travellingSalesmanTabuSearchEngine(Graph &graph, unsigned tabuSteps, bool diversification, int iterationsToRestart, unsigned minStopTime, std::vector<unsigned> startRoute, std::vector<unsigned> &result, int &resultLength, unsigned &globalOptimum, std::mutex &globalOptimumMutex);
+        static void travellingSalesmanTabuSearchEngine(Graph &graph, unsigned tabuSteps, bool diversification, int iterationsToRestart, unsigned minStopTime, std::vector<unsigned> startRoute, std::vector<unsigned> &globalOptimum, unsigned &globalOptimumLength, std::mutex &globalOptimumMutex);
 
         class RouteComparison
         {