Quicksort wielowątkowo

0

Witam
Mam za zadanie przerobić quicksorta na wiele wątków. Próbowałem naśladować rozwiązania z internetu, jednak program działał dłużej niż normalna wersja albo nie do końca sortował.
Aktualna wersja wygląda tak:

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.*;



class SortowanieM implements Runnable
{
   public static int[] tablica;
   public static int[] tablica2;
   public static int wielkosc;
   
   public static int wczytaj() throws FileNotFoundException, IOException
   {
       BufferedReader odczyt = new BufferedReader(new FileReader("sort.txt"));
       int licznik=0;
       
       String s;
       s = odczyt.readLine();
       wielkosc = Integer.parseInt(s.trim());
       tablica = new int[wielkosc];
       tablica2 = new int[wielkosc];
       while ((s = odczyt.readLine()) != null)
       {
           
           tablica[licznik] = Integer.parseInt(s.trim());
           licznik++;
       } 
       return wielkosc;
   }
   
    @Override
   public void run()
   {
    System.out.println("Watekow "+Thread.activeCount());
    
   }
   
   public static void quicksort(int tablica[], int x, int y) 
   {    
       int i,j,v,temp;
       final int a,b,c,d;
       //System.out.println("Watek "+Thread.activeCount());
        i=x;
        j=y;
        v=tablica[(x+y) / 2];
        do 
        {
            while (tablica[i]<v)
                i++;
            while (v<tablica[j])
                j--;
            if (i<=j) 
            {
                temp=tablica[i];
                tablica[i]=tablica[j];
                tablica[j]=temp;
                i++;
                j--;
            }
        }
        while (i<=j);
        a=i;
        b=j;
        c=x;
        d=y;
        if (x<j)
        {
            new Thread()
            {
                public void run()
                {
                    quicksort(SortowanieM.tablica,c,b);
                }
            }.start();
        }
            
        if (i<y)
        {
            new Thread()
            {
                public void run()
                {
                   quicksort(SortowanieM.tablica,a,d); 
                }
            }.start();
        }
            
    
}
}




class Start
{

public static void main(String[] args) throws FileNotFoundException, IOException 
{
    long startQsort, stopQsort;
    int zakres = SortowanieM.wczytaj();
    SortowanieM.tablica2 = SortowanieM.tablica;
    long startQsortM, stopQsortM;
    startQsortM = System.currentTimeMillis();
       SortowanieM.quicksort(SortowanieM.tablica,0,zakres-1);
    stopQsortM = System.currentTimeMillis() - startQsortM;
    System.out.println("Qsort: " + stopQsortM + " milisekund.");
    
    /*SortowanieM w1 = new SortowanieM();
    (new Thread(w1)).start();*/
    
    
    /*try {
    Thread.sleep(1000);
    } catch(InterruptedException ex) {
    Thread.currentThread().interrupt();
    }*/
    System.out.println("Tablica po posortowaniu:");
    for(int i=0; i<zakres-1; i++)
    System.out.println(SortowanieM.tablica[i]);
        
}
}

Do generowania pliku z danymi używam takiego czegoś :

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.*;

class Generator
{

    public static void main(String[] args)  throws FileNotFoundException, IOException
    {
        int ile;
        Random rand = new Random();
        PrintWriter zapis= new PrintWriter("sort.txt");
        Scanner odczyt = new Scanner(System.in);
        System.out.println("Ile liczb wygenerować ?" );
        ile = odczyt.nextInt();
        zapis.println(ile);
        for (int i=0; i<ile;i++)
        {
            zapis.println(rand.nextInt(1000000000));
        }
        zapis.close();
    }
    
    
    
}

Próbowałem podejść do tematu z różnych stron, dlatego w kodzie panuje lekki bałagan, ale myślę, że da się z tego rozczytać :)

2

Jeśli możesz używać Javy 7 to użyj Fork/Join framework: http://docs.oracle.com/javase/tutorial/essential/concurrency/forkjoin.html

Podstawowy błąd w twoim algorytmie to to, że tworzysz i odpalasz nowe wątki dla bardzo małych podproblemów. Tworzenie i odpalanie wątku zajmuje dużo więcej niż posortowanie tablicy składającej się z kilku liczb. Dlatego musisz ustawić pewien próg poniżej którego sortujesz podtablicę jednowątkowo.

Poza tym struktura kodu to jeden wielki WTF.

1 użytkowników online, w tym zalogowanych: 0, gości: 1