static void Main(string[] args)
{
    System.Net.IPHostEntry iPHostEntry = System.Net.Dns.GetHostEntry("www.chicai.group");
    System.Net.IPAddress[] address = iPHostEntry.AddressList;
    Console.WriteLine(address[0].ToString());

    Console.WriteLine(System.Net.Dns.GetHostAddresses("www.chicai.group")[0]);

    Console.ReadKey();
}

集合类通常不是线程安全的,多个阅读器可以安全的读取集合.但是对集合的任何修改都将为访问集合的所有线程生成不明确的结果.使用以下任何方法都可以令集合类是线程安全的
(1)    使用Synchronized 方法, 则从该类派生包装, 并通过该包装以独占方式访问集合
(2)    如果该类没有Synchronized 方法, 则从该类派生并使用SyncRoot属性实现Synchronized 方法.
(3)    在访问该集合时对SyncRoot属性使用锁定机制
 大家可以看看以下代码:
class Program
{
    static void Main(string[] args)
    {
        Program pg = new Program();
        //写线程
        Thread t1 = new System.Threading.Thread(new ThreadStart(pg.t1fun));
        // 读线程
        Thread t2 = new System.Threading.Thread(new ThreadStart(pg.t2fun));
        //删线程
        Thread t3 = new System.Threading.Thread(new ThreadStart(pg.t3fun));
        t1.Start();
        t2.Start();
        t3.Start();
    }
    ArrayList arraylist = new ArrayList();
    public void t1fun()
    {
        while (true)
        {
            arraylist.Add("t1--写入");
            System.Console.Out.WriteLine("写入");
            System.Threading.Thread.Sleep(1000);
        }
    }
    public void t2fun()
    {
        while (true)
        {
            for (int i = arraylist.Count - 1; i >= 0; i--)
            {
                System.Console.Out.WriteLine("t2读取:" + (string)arraylist[i]);
            }
            System.Threading.Thread.Sleep(1000);
        }
    }
    public void t3fun()
    {
        while (true)
        {
            for (int i = arraylist.Count - 1; i >= 0; i--)
            {
                arraylist.RemoveAt(i);
                System.Console.Out.WriteLine("t3删除:t1" + i.ToString());
            }
            System.Threading.Thread.Sleep(1000);
        }
    }
}
这个测试程序得简单,大家一看就明白了你可以运行一下看看,程序一会就挂了,揭示异常:
未处理的异常: System.ArgumentOutOfRangeException: 索引超出范围。必须为非负值并
小于集合大小。
这就是因为多线程中对共享的集合资源同步引起的

下面是改后的代码:
class Program
{
    static void Main(string[] args)
    {
        Program pg = new Program();
        //写线程
        Thread t1 = new System.Threading.Thread(new ThreadStart(pg.t1fun));
        // 读线程
        Thread t2 = new System.Threading.Thread(new ThreadStart(pg.t2fun));
        //删线程
        Thread t3 = new System.Threading.Thread(new ThreadStart(pg.t3fun));
        t1.Start();
        t2.Start();
        t3.Start();
    }
    ArrayList arraylist = new ArrayList();
    public void t1fun()
    {
        while (true)
        {
            lock (arraylist.SyncRoot)
            {
                arraylist.Add("t1--写入");
            }
            System.Console.Out.WriteLine("写入");
            System.Threading.Thread.Sleep(1000);
        }
    }
    public void t2fun()
    {
        while (true)
        {
            lock (arraylist.SyncRoot)
            {
                for (int i = arraylist.Count - 1; i >= 0; i--)
                {
                    System.Console.Out.WriteLine("t2读取:" + (string)arraylist[i]);
                }
            }
            System.Threading.Thread.Sleep(1000);
        }
    }
    public void t3fun()
    {
        while (true)
        {
            lock (arraylist.SyncRoot)
            {
                for (int i = arraylist.Count - 1; i >= 0; i--)
                {
                    arraylist.RemoveAt(i);
                    System.Console.Out.WriteLine("t3删除:t1" + i.ToString());
                }
            }
            System.Threading.Thread.Sleep(1000);
        }
    }
}

public class Base64Helper
{
    public static string encode(string str)
    {
        try
        {
            System.Text.Encoding encode = System.Text.Encoding.ASCII;
            byte[] bytedata = encode.GetBytes(str);
            string strBase64 = Convert.ToBase64String(bytedata, 0, bytedata.Length);
            return strBase64;
        }
        catch
        {
            return null;
        }
    }

    public static string decode(string str)
    {
        try
        {
            byte[] bytedata = Convert.FromBase64String(str);
            string strText = System.Text.ASCIIEncoding.Default.GetString(bytedata);
            return strText;
        }
        catch
        {
            return null;
        }
    }
}

可以将方法前面声明为async表明这个方法有需要异步（分配线程）来执行，所以一定要有await，它表明了它这条语句是需要异步执行的。

using System;
using System.Net;
using System.Threading.Tasks;

namespace Async
{
    class Program
    {
        static void Main(string[] args)
        {
            Task<string> ss = DownLoadStr();
            Console.WriteLine(1);
            Console.WriteLine(ss.Result.Substring(100,100));
            Console.WriteLine(2);

            Console.ReadKey();
        }

        async static Task<string> DownLoadStr()
        {
            Console.WriteLine("异步开始！");
            WebClient wc = new WebClient();
            //await表明下载网页是异步执行的，可以返回到Main中继续执行，同时它也在执行
            string s = await wc.DownloadStringTaskAsync("http://www.chicai.group");
            Console.WriteLine("完成异步方法");
            return s;
        }
    }
}

async的返回值必须是void、Task、Task<>类型的，string表示return（返回）的类型。

但是方法体返回的其实还是Task<T>，可以通过task的Result方法获取到方法中return的结果

获取结果时，如果异步方法没有完成，Main将会等待方法完成，知道获取到结果。