Thread Programmierung

blurry333

Ok danke. Das war der sehr peinliche Fehler

blurry333

Sobald ich ein array mit mehr als 1 Element anlege, dann endet nur der 1.Thread aber nicht der 2.Thread. Kann sich einer vorstellen warum ?

Thread1 starting..
Thread2 starting..
Thread1 ending..
Aber Thread2 ending fehlt eben.

class Program
    {

        static void Main(string[] args)
        { 
            int[] arr;
            arr = new int[2];
            for (int i = arr.Length - 1, j = 0; i >= 0; i--, j++)
            {
                arr[j] = i;
            }

            Thread myThread1 = new Thread(delegate()
            {
                bubbleSort(arr);
            });

            Thread myThread2 = new Thread(delegate()
            {
                bubbleSort(arr);
            });

            Thread myThread3 = new Thread(delegate()
            {
                bubbleSort(arr);
            });

            Thread myThread4 = new Thread(delegate()
            {
                bubbleSort(arr);
            });
 myThread2.Start();
            myThread1.Start();

            // myThread3.Start();
            //myThread4.Start();

        }

        static private void bubbleSort(int[] arr)
        {
            bool flag = false;
            int tmp;
            int id = Thread.CurrentThread.GetHashCode();
            Console.WriteLine("Thread{0} starting ...", id);

            for (int j = arr.Length; j > 1; j--)
            {
                for (int i = 0; i < j - 1; i++)
                {

                    for (int z = 0; z < 100000; z++) ;
                    if (arr[i] > arr[i + 1])
                    {
                        tmp = arr[i];
                        arr[i] = arr[i + 1];
                        arr[i + 1] = tmp;

                        flag = true;
                    }
                }
                if (flag == false) return;

                flag = false;
            }

            Console.WriteLine("Thread{0} terminating ...", id); // hier endet der Thread
}
}
}

blurry333 schrieb:

Kann sich einer vorstellen warum ?

Ja.

Verpiss Dich endlich Du Depp.

blurry333

sorry ich kanns mir halt nicht erklären. Vielleicht hatte schon mal einer ein ähnliches Problem.

dot

if (flag == false) return;

hmmmmmm

blurry333

Warum stell ich mich manchmal so extrem doof an

blurry333

Aber Threads zu verwenden zahlt sich wirklich aus. Je mehr Sortieraufwand umso mehr Performancegewinn durch Threads. Bei 5000 Zahlen braucht 1 Thread alleine ca 80 Sekunden und 4 Threads sind beinahe doppelt so schnell.

blurry333

Obwohl ich keinerlei Synchronisationsmechanismen verwende gibt es bei der Sortierung keinerlei Probleme. Laut meinem Buch sollte es aber so sein. Schon komisch....

class Program
    {

        static void Main(string[] args)
        { 
            int[] arr;
            arr = new int[10000];
            for (int i = arr.Length - 1, j = 0; i >= 0; i--, j++)
            {
                arr[j] = i;
            }

            Thread myThread1 = new Thread(delegate()
            {
                bubbleSort(arr);
            });

            Thread myThread2 = new Thread(delegate()
            {
                bubbleSort(arr);
            });

            Thread myThread3 = new Thread(delegate()
            {
                bubbleSort(arr);
            });

            Thread myThread4 = new Thread(delegate()
            {
                bubbleSort(arr);
            });

            myThread1.Start();
            myThread2.Start();
            myThread3.Start();
            myThread4.Start();

        }

        static private void bubbleSort(int[] arr)
        {
            bool flag = false;
            int tmp;
            int id = Thread.CurrentThread.GetHashCode();
            Console.WriteLine("Thread{0} starting ...", id);

                for (int j = arr.Length; j > 1; j--)
                {
                        for (int i = 0; i < j - 1; i++)
                        {

                            for (int z = 0; z < 10; z++) ;
                            if (arr[i] > arr[i + 1])
                            {
                                tmp = arr[i];
                                arr[i] = arr[i + 1];
                                arr[i + 1] = tmp;

                                flag = true;
                            }
                        }
                        if (flag == false) break;

                        flag = false;

                }

            Console.WriteLine("Thread{0} terminating ...", id); // hier endet der Thread

            for (int i = 0; i < arr.Length - 1; i++)
            {
                if (arr[i] > arr[i + 1]) Console.Write("Wrong Order: {0} {1}, ", arr[i], arr[i + 1]);
            }
        }
    }

luker

Zu "ohne Synchronisation trotzdem keine Fehler": Das kann 100 mal gutgehen. Aber Du kannst Dich eben nicht darauf verlassen. Programme müssen aber so geschrieben werden, dass man sich darauf verlassen kann.

Zu "Geschwindigkeitsgewinn durch Parallelisierung":
Die vier Threads sortieren jeweils die Ganze Liste?
Und der eine Thrad sortiert auch die ganze Liste? Einmal? Oder Viermal?

Ein naheliegender Ansatz wäre der:
Vier Threads sortieren jeweils 1/4 der Liste.
Das Resultat sind vier in sich sortierte Listen. Im gegebenen Spezialfall (monoton fallende Werte in Eingangsdaten) könnte man die vier Teilergebnisse in umgekehrter Reihenfolge aneinanderhängen. Aber, wie oben, kann man sich auch hierauf nicht verlassen. Könnte man das, bräuchte man ja keine Sortierfunktion.

Du musst also die vier Listen noch in eine zusammensortieren. Der Algorithmus dafür beginnt mit einer leeren Ergebnisliste und hängt immer den kleinsten Wert der vier Werte an, mit denen die vier Teillisten beginnen (alle anderen Werte einer liste sind ja schon garantiert größer als der erste).

Dieses Zusammensortieren ist natürlich "Overhead". Aber bei genügend großem Geschwindigkeitsvorteil des verteilten Vorsortierens kann sich der lohnen.

PuppetMaster2k

Welchen Zweck verfolgt bitte folgende Zeile?

for (int z = 0; z < 10; z++) ;

blurry333

lol keinen mehr Nur ein Zeitfüller