【C#】项目常使用模块记录

多线程：

使用任务：Task实现（使用表达式去实现），与方法2差距不大，推荐Task,会自动管理线程池【Task做菜】【相较于Thread】

Task.Run(() =>
            {
                Thread.Sleep(3000);
                Console.WriteLine("素菜做好了");
                Thread.Sleep(5000);
                Console.WriteLine("荤菜做好了");
            });

Task实现（使用表达式去实现），同时开启多个Task【同时做多道菜】

Task.Run(() =>
            {
                Thread.Sleep(3000);
                Console.WriteLine("素菜做好了");
            });
            Task.Run(() =>
            {
                Thread.Sleep(5000);
                Console.WriteLine("荤菜做好了");
            });

等待完成之后再执行下一句话【菜都做好了吃饭】

	private async void test5()
        {
            //练习5：菜都做好了吃饭
            await Task.Run(() =>			//await Task.Run里面的这些线程会同时执行
            {
                Thread.Sleep(3000);
                Console.WriteLine("素菜做好了");
                Thread.Sleep(5000);
                Console.WriteLine("荤菜做好了");
            });

            Console.WriteLine("菜都做好了，大家快来吃饭");		//知道Task.Run全部执行完之后才会执行完到这句
        }

线程同步：

C#提供线程同步机制来防止资源访问的冲突，其中主要用到Lock关键字，Monitor关键字，Mutex关键字。

Lock关键字实现线程同步
通过为给定对象获取互斥锁来实现的。提供给Lock语句的参数必须为基于引用类型的对象，用来定义锁的范围

class Program
{
    int num =10;
    void Ticket()
    {
        while (true)
        {
            lock (this)		//这里有线程调用时会锁住，其他线程就无法进行同时调用
            {
                if (num > 0)
                {
                    num--;
                }
            }
        }
    }
    static void main(string[] args)
    {
        Program p = new Program();
        Thread tA = new Thread(new ThreadStart(p.Ticket));
        Thread tB = new Thread(new ThreadStart(p.Ticket));
        Thread tC = new Thread(new ThreadStart(p.Ticket));
        Thread tD = new Thread(new ThreadStart(p.Ticket));
        tA.Start();
        tB.Start();
        tC.Start();
        tD.Start();
    }
}

Monitor关键字实现线程同步

//上一段代码的Ticket函数改成：
void Ticket()
{
    while (true)
    {
        Monitor.Enter(this);	//锁定代码块
        if (num > 0)
        {
            num--;
        }
        Monitor.Exit(this);		//解锁代码块
    }
}

使用Mutex类实现线程同步
Mutex类可以用来使跨经常的线程同步。

void Ticket()
{
    while (true)
    {
        Mutex mymutex = new Mutex(false);       //构造函数参数指定了创建该对象的线程是否希望立即获取其所有权，在一个资源得到保护的类中创建常设置成false
        mymutex.WaitOne();          //阻塞当前线程
        if (num > 0)
        {
            num--;
        }
        mymutex.ReleaseMutex();     //释放Mutex对象
    }
}

socketTCPIP通信：

服务端：

public class TCPServerClass
{
    private static readonly object _lock = new object(); // 用于加锁
    private static TcpListener _listener;
    private static TcpClient client;

    // 启动服务器（同步）
    public static void StartServerSync()
    {
        IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
        int port = 12345;
        _listener = new TcpListener(ipAddress, port);

        _listener.Start();
        Console.WriteLine("服务器已启动，等待客户端连接...");
        client = _listener.AcceptTcpClient();
        Console.WriteLine("客户端已连接！");
        
    }

    // 处理客户端请求（同步）
    public static void HandleClientSync()
    {
        NetworkStream stream = client.GetStream();
        byte[] buffer = new byte[1024];

        lock (_lock) // 加锁
        {
            int bytesRead = stream.Read(buffer, 0, buffer.Length);
            string message = Encoding.UTF8.GetString(buffer, 0, bytesRead);
            Console.WriteLine("收到客户端消息: " + message);

            string response = "服务器已收到你的消息！";
            byte[] responseData = Encoding.UTF8.GetBytes(response);
            stream.Write(responseData, 0, responseData.Length);
            Console.WriteLine("已发送响应消息给客户端");
        }
        //client.Close();
    }

    public static void CloseClientSync()
    {
        client.Close();
    }
}

客户端

public class TCPClientClass
{
    private static readonly object _lock = new object(); // 用于加锁
    static TcpClient client;

    //static NetworkStream stream;

    // 连接到服务器（同步）
    public static bool ConnectToServerSync()
    {
        string serverIp = "127.0.0.1";
        int port = 12345;
        client = new TcpClient(serverIp, port);


        Console.WriteLine("已连接到服务器！");

        return true;
    }


    public static void SendMesToServerSync()
    {
        NetworkStream stream = client.GetStream();

        lock (_lock) // 加锁
        {
            string message = "你好，服务器！";
            byte[] data = Encoding.UTF8.GetBytes(message);
            stream.Write(data, 0, data.Length);
            Console.WriteLine("已发送消息给服务器: " + message);

            byte[] buffer = new byte[1024];
            int bytesRead = stream.Read(buffer, 0, buffer.Length);
            string response = Encoding.UTF8.GetString(buffer, 0, bytesRead);
            Console.WriteLine("收到服务器响应: " + response);

            
        }
        //client.Close();
    }

    public static void DisConnectToServerSync()
    {
        client.Close();
    }
}