class Program {
    static void Main(string[] args) {

        // 使用无参数委托ThreadStart
        Thread t = new Thread(Go);
        t.Start();

        // 使用带参数委托ParameterizedThreadStart
        Thread t2 = new Thread(GoWithParam);
        t2.Start("Message from main.");

        t2.Join();// 等待线程t2完成。

        Console.WriteLine("Thread t2 has ended!");
        Console.ReadKey();
    }

    static void Go() {
        Console.WriteLine("Go!");
    }

    static void GoWithParam(object msg) {
        Console.WriteLine("Go With Param! Message: " + msg);
        Thread.Sleep(1000);// 模拟耗时操作
    }
}

class Program {
    static void Main(string[] args) {

        Thread t1 = new Thread(Working);
        t1.Name = "Thread1";
        Thread t2 = new Thread(Working);
        t2.Name = "Thread2";
        Thread t3 = new Thread(Working);
        t3.Name = "Thread3";

        // 依次启动3个线程。
        t1.Start();
        t2.Start();
        t3.Start();

        Console.ReadKey();
    }

    // 每个线程都同时在工作
    static void Working() {
        // 模拟1000次写日志操作
        for (int i = 0; i < 1000; i++) {
            Logger.Write(Thread.CurrentThread.Name + " writes a log: " + i + ", on " + DateTime.Now.ToString() + ".\n");
        }// 做一些其它的事件
        for (int i = 0; i < 1000; i++) { }
    }
}

class Program {
    static bool done;
    static void Main(string[] args) {

        new Thread(Go).Start(); // 在新的线程上调用Go
        Go(); // 在主线程上调用Go

        Console.ReadKey();
    }

    static void Go() {
        if (!done) {
            Thread.Sleep(500); // 模拟耗时操作
            Console.WriteLine("Done"); 
            done = true;
        }
    }
}

class Program {

    static bool done;
    static object locker = new object(); // ！！

    static void Main(string[] args) {

        new Thread(Go).Start(); // 在新的线程上调用Go
        Go(); // 在主线程上调用Go

        Console.ReadKey();
    }

    static void Go() {
        lock (locker) {
            if (!done) {
                Thread.Sleep(500); // Doing something.
                Console.WriteLine("Done");
                done = true;
            }
        }
    }
}

static void Main(string[] args) {

    var signal = new ManualResetEvent(false);

    new Thread(() => {
        Console.WriteLine("Waiting for signal...");
        signal.WaitOne();
        signal.Dispose();
        Console.WriteLine("Got signal!");
    }).Start();
    Thread.Sleep(2000);

    signal.Set();// 打开“信号”

    Console.ReadKey();
}

// 方式1：Task.Run，.NET Framework 4.0 才有
Task.Run (() => Console.WriteLine ("Hello from the thread pool"));

// 方式2：ThreadPool.QueueUserWorkItem
ThreadPool.QueueUserWorkItem (t => Console.WriteLine ("Hello from the thread pool"));

Task task = Task.Factory.StartNew (() => ...,TaskCreationOptions.LongRunning);

public class Logger {

    // 用于存放写日志任务的队列
    private Queue<Action> _queue;

    // 用于写日志的线程
    private Thread _loggingThread;

    // 用于通知是否有新日志要写的“信号器”
    private ManualResetEvent _hasNew;

    // 构造函数，初始化。
    public Logger() {
        _queue = new Queue<Action>();
        _hasNew = new ManualResetEvent(false);

        _loggingThread = new Thread(Process);
        _loggingThread.IsBackground = true;
        _loggingThread.Start();
    }

    // 使用单例模式，保持一个Logger对象
    private static readonly Logger _logger = new Logger();
    private static Logger GetInstance() {
        /* 不安全代码
        lock (locker) {
            if (_logger == null) {
                _logger = new Logger();
            }
        }*/
        return _logger;
    }

    // 处理队列中的任务
    private void Process() {
        while (true) {
            // 等待接收信号，阻塞线程。
            _hasNew.WaitOne();

            // 接收到信号后，重置“信号器”，信号关闭。
            _hasNew.Reset(); 

            // 由于队列中的任务可能在极速地增加，这里等待是为了一次能处理更多的任务，减少对队列的频繁“进出”操作。
            Thread.Sleep(100);

            // 开始执行队列中的任务。
            // 由于执行过程中还可能会有新的任务，所以不能直接对原来的 _queue 进行操作，
            // 先将_queue中的任务复制一份后将其清空，然后对这份拷贝进行操作。

            Queue<Action> queueCopy;
            lock (_queue) {
                queueCopy = new Queue<Action>(_queue);
                _queue.Clear();
            }

            foreach (var action in queueCopy) {
                action();
            }
        }
    }

    private void WriteLog(string content) {
        lock (_queue) { // todo: 这里存在线程安全问题，可能会发生阻塞。
            // 将任务加到队列
            _queue.Enqueue(() => File.AppendAllText("log.txt", content));
        }

        // 打开“信号”
        _hasNew.Set();
    }

    // 公开一个Write方法供外部调用
    public static void Write(string content) {
        // WriteLog 方法只是向队列中添加任务，执行时间极短，所以使用Task.Run。
        Task.Run(() => GetInstance().WriteLog(content));
    }
}