多个线程访问一个返回方法是带锁的线程安全吗？

Question

我正在尝试从多个线程访问一个方法，我不确定这是否是线程安全的。如果不是，那么确保其安全的最有效方法是什么？

我考虑了每个人的见解，我的最终产品如下所示，我还选择了对数据包本身调用回收。

我的数据包池类

using System.Collections.Generic;

namespace Networking
{
    public class PacketPool
    {
        private Queue<Packet> pool = new Queue<Packet>();
        private readonly object instance = new object();

        public Packet CreatePacket(string method)
        {
            lock (instance)
                return pool.Count == 0 ? new Packet() { Pool = this } : 
                       pool.Dequeue();
        }

        public void Recycle(Packet packet)
        {
            lock(instance)
               pool.Enqueue(packet);
        }
    }
}

数据包类

using System;
using System.Net;

namespace Networking
{
    public class Packet 
    {
        public Protocol Proto = Protocol.Sequenced;
        public PacketFlags Flag = PacketFlags.None;
        public Fragment Fragmented = Fragment.NotFragged;
        public SendType SendType = SendType.Raw;
        public EndPoint RemoteEp = new IPEndPoint(IPAddress.Any, 0);
        public byte[] Buffer = new byte[512];
        public int Count = 0;
        public int Ptr = 8;
        public int Bits { get; set; } = 0;
        public ushort Id = 0;
        public ushort Lead = 0;
        public PacketPool Pool;

        public void Recycle()
        {
            Bits = 0;

            if (Buffer.Length > 512)
                Array.Resize(ref Buffer, 512);

            Count = 0;
            Flag = PacketFlags.None;
            Fragmented = Fragment.NotFragged;
            Proto = Protocol.Sequenced;
            Ptr = 8;
            Lead = 0;
            SendType = SendType.Raw;
            Pool.Recycle(this);
        }
    }
}

希望上述解决方案能让生活更轻松。

Answer 1

您展示的代码看起来是线程安全的，只要数据包本身没有在单独的线程上进行修改。您也可以考虑让 PacketPool 类线程安全，以节省一些宝贵的锁定时间。

您可以通过将Queue 替换为ConcurrentQueue 来简化它。

请注意，您正在修改发送到Recycle 方法的数据包。我建议使数据对象不可变，以避免意外行为。

public class PacketPool
{
    public ConcurrentQueue<Packet> pool = new ConcurrentQueue<Packet>(2000);

    public Packet CreatePacket(string method)
    {
        if (pool.TryDequeue(out Packet packet))
        {
            return packet;
        }

        return new Packet();
    }

    public void Recycle(Packet packet)
    {
        packet.Bits = 0;

        if (packet.Buffer.Length > 512)
            Array.Resize(ref packet.Buffer, 512);

        packet.Count = 0;
        packet.Flag = PacketFlags.None;
        packet.Fragmented = Fragment.NotFragged;
        packet.Proto = Protocol.Sequenced;
        packet.Ptr = 8;
        packet.Lead = 0;
        packet.SendType = SendType.Raw;
        pool.Enqueue(packet);
    }
}

Answer 2

如果数据包不是跨线程共享的，那么由于锁，这是线程安全的。

小心公共场池。您也可以在不安全的线程上编辑它。

请注意，建议使用专用的锁对象，否则可能会出现死锁 - 例如，另一个进程锁定了公共属性 Pool。建议将锁对象设为私有并仅在该类中使用它（所以上一级）

同步线程访问共享资源时，锁定一个专用对象实例（例如，私有只读对象 balanceLock = new object();）或另一个不太可能被无关部分用作锁定对象的实例的代码。避免对不同的共享资源使用相同的锁对象实例，因为这可能会导致死锁或锁争用。

https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/lock-statement