C#

class VectorSafeConcurency
    {
        int[] V;
        const int sizeV = 100000;
        //Stack<int> numbers = new Stack<int>();

        void push2(Stack<int> s, int a, int b)
        {
            s.Push(b);
            s.Push(a);
        }

        public VectorSafeConcurency()
        {
            V= new int[sizeV];

            int value= sizeV;

            for (int i = 0; i < sizeV; ++i)
                V[i] = value--;
        }

        void exchange(ref int x, ref int y)
        {
            int temp= x; 
            x= y;
            y= temp;
        }

        int partition(int[] A, int l, int r)
        {
            int i = l - 1;
            int j = r;
            int v= A[r];

            for(;;)
            {
                while(A[++i] <v);
                while (v < A[--j]) if (j == l) break;
                if (i >= j) break;
                exchange(ref A[i], ref A[j]);
            }
            exchange(ref A[i], ref A[r]);
            return i;
        }

        struct ThData
        {
            public int[] A;
            public int l;
            public int r;

            public ThData(int []a, int i, int j)
            {
                A = a; l = i; r = j;
            }
        }


        void thWorkerParititoner(object data)
        {
            int[] A = ((ThData)data).A;
            int l = ((ThData)data).l;
            int r = ((ThData)data).r;

            quicksort(A, l, r);
        }


        void StartQuicksort(int[] A, int l, int r)
        {
            if (r <= l) return;
            int i = partition(A, l, r);

            Thread t1 = new Thread(thWorkerParititoner);
            t1.Start(new ThData (A, l, i-1));

            Thread t2 = new Thread(thWorkerParititoner);
            t2.Start(new ThData(A, i+1, r));
            //start th 1
            //start th2
        }

        void quicksort(int[] A, int l, int r)
        {
            Stack<int> Indexes = new Stack<int>();
            push2(Indexes, l, r);

            while (Indexes.Count > 0)
            {
                l = Indexes.Pop(); r = Indexes.Pop();

                if (r <= l) continue;
                int i = partition(V, l, r);

                push2(Indexes, l, i - 1);
                push2(Indexes, i + 1, r);
            }
        }

        public void StartSort()
        {
            quicksort(V, 0, V.Length - 1);

            int d = 1;
        }
    }