C#

static void Main(string[] args)
{
    List<int> test1 = DivideInt(10,1).ToList().OrderBy(s=> s).ToList();
    List<int> test2 = DivideInt(10, 2).ToList().OrderBy(s => s).ToList();
    List<int> test3 = DivideInt(10, 3).ToList().OrderBy(s => s).ToList();
    List<int> test4 = DivideInt(10, 4).ToList().OrderBy(s => s).ToList();
    List<int> test5 = DivideInt(10, 5).ToList().OrderBy(s => s).ToList();
    List<int> test6 = DivideInt(10, 6).ToList().OrderBy(s => s).ToList();
    List<int> test7 = DivideInt(10, 7).ToList().OrderBy(s => s).ToList();
    List<int> test8 = DivideInt(10, 8).ToList().OrderBy(s => s).ToList();
    List<int> test9 = DivideInt(10, 9).ToList().OrderBy(s => s).ToList();
    List<int> test10 = DivideInt(10, 10).ToList().OrderBy(s => s).ToList();

}

public static IEnumerable<int> DivideInt(int pagetotal, int userinput)
{
    if(userinput==0)
    {
        yield   return  0;
    }
    else
    {
        int rest =pagetotal % userinput;
        double  result =pagetotal / (double) userinput;

        for(int i=0; i< userinput;i++)
        {
            if(rest-- >0)
                yield return (int) Math.Ceiling(result);
            else
                yield return (int) Math.Floor(result);
        }
    }
}

AxMsRdpClient9NotSafeForScripting

public interface ITest
{
    TestResult PerformTest();
}

public class Test1 : ITest
{
    public TestResult PerformTest()
    {
        Thread.Sleep(60 * 10 * 1000);

        return TestResult.Failed;
    }
}

public class Test2 : ITest
{
    public TestResult PerformTest()
    {
        Thread.Sleep(60 * 2 * 1000);

        // Need to do some other stuff here. If Test1 is not finished, then wait for it to finish before continuing

        return TestResult.Passed;
    }
}

public enum TestResult
{
    Failed,

    Passed
}

class Program
{
    static List<Task> tasks = new List<Task>();

    static void Main(string[] args)
    {
        List<ITest> tests = new List<ITest>
        {
            new Test1(),
            new Test2()
        };

        foreach (var test in tests)
        {
            var task = Task.Factory.StartNew(() =>
            {
                TestResult testResult = test.PerformTest();
                return testResult;
            });

            tasks.Add(task);
        }

        try
        {
            Task.WaitAll(tasks.ToArray());
        }
        catch (Exception e)
        {
            throw e;
        }
    }
}

namespace threads
{
    class Program
    {

        public static int compteur;
        public static object ob = new object();
        public static SemaphoreSlim sem = new SemaphoreSlim(3);

        public static void Thread_test() {
            sem.Wait();
            for (int i = 0; i < 1000000; i++)
            {
                compteur++;
            }
            sem.Release();
            System.Console.WriteLine(compteur.ToString());
        }

        static void Main(string[] args)
        {
            Thread[] th = new Thread[10];
            for (int i = 0; i < th.Length; i++)
            {
                th[i] = new Thread(Thread_test)
                {
                    Name = "thread_" + i
                };
                th[i].Start();
            }

            System.Console.ReadLine();
        }
    }
}

thread_2 = 1264634
thread_0 = 1440996
thread_1 = 1645012
thread_3 = 2344585
thread_5 = 2694858
thread_4 = 2809001
thread_6 = 3628891
thread_8 = 3651918
thread_7 = 3991965
thread_9 = 4527904

thread_3 = 1893992
thread_1 = 2735536
thread_4 = 4274643
thread_2 = 4349873
thread_0 = 6248051
thread_5 = 7430503
thread_6 = 8107979
thread_7 = 8937401
thread_9 = 9815069
thread_8 = 10000000