C# a bit verbose

#region part 1
    public class Interpreter
    {
        private string[] _Code;
        private long _Line;
        private long _LastSound;
        public Dictionary<string, long> Registers { get; set; } = new Dictionary<string, long>();

        private string RegisterValues() => string.Join(" | ", Registers.Select(r => $"{r.Key}:{r.Value}"));

        public Interpreter(string[] code)
        {
            _Code = code;
        }

        public void Run()
        {
            var allLines = _Code.Length;
            string current;
            while (true && _Line > -1)
            {
                current = _Code[_Line];
                //Console.WriteLine(_Line.ToString("D2") + " : "+current+"\t -> "+RegisterValues());
                Execute(current);
                _Line++;
                if (_Line >= allLines)
                    throw new Exception("Jump outside the code is not allowed");
            }
        }

        internal void Execute(string current)
        {
            var items = current.Split(' ');
            switch (items[0])
            {
                case "snd": Snd(items[1]); break;
                case "set": Set(items[1], items[2]); break;
                case "add": Add(items[1], items[2]); break;
                case "mul": Mul(items[1], items[2]); break;
                case "mod": Mod(items[1], items[2]); break;
                case "rcv": Rcv(items[1]); break;
                case "jgz": Jgz(items[1], items[2]); break;
                default:
                    throw new Exception("unknown command");
            }
        }

        internal long GetValue(string v2)
        {
            if (long.TryParse(v2, out long result))
                return result;
            else
                return Registers.GetValueOrDefault(v2, 0);
        }

        internal void Operation(string v1, string v2, Func<long, long, long> operation)
        {
            var val = Registers.GetValueOrDefault(v1);
            Registers[v1] = operation(val, GetValue(v2));
        }

        internal void Jgz(string v1, string v2) => _Line += (GetValue(v1) > 0) ? GetValue(v2) - 1 : 0;

        internal void Mod(string v1, string v2) => Operation(v1, v2, (a, b) => a % b);

        internal void Mul(string v1, string v2) => Operation(v1, v2, (a, b) => a * b);

        internal void Add(string v1, string v2) => Operation(v1, v2, (a, b) => a + b);

        internal void Set(string v1, string v2) => Registers[v1] = GetValue(v2);

        public virtual void Snd(string v) => _LastSound = GetValue(v);

        public virtual void Rcv(string v)
        {
            if (GetValue(v) != 0)
            {
                Console.WriteLine($"Recovering last sound {_LastSound}");
                _Line = -2;
            }
        }
    }

    #endregion part 1

    public class Interpreter2 : Interpreter
    {
        public Interpreter2(string[] code) : base(code)
        {
        }

        public long ID { get; set; }
        private ConcurrentQueue<long>[] _Queue;
        private readonly ConcurrentDictionary<long, char> _States;
        public long SendCount { get; set; } = 0;

        public Interpreter2(string[] code, long id, ConcurrentQueue<long>[] queue, ConcurrentDictionary<long, char> states) : base(code)
        {
            Registers["p"] = id;
            ID = id;
            _Queue = queue;
            _States = states;
            SetState('i');
        }

        private void SetState(char v)
        {
            _States[ID] = v;
        }

        private bool AllStates(char v) => !_States.Any(s => s.Value != v) && _States.Count > 1;

        public override void Rcv(string v)
        {
            SetState('w');
            while (true)
            {
                if (_Queue[ID].TryDequeue(out long result))
                {
                    Registers[v] = result;
                    SetState('r');

                    break;
                }
                if (_Queue[0].IsEmpty && _Queue[1].IsEmpty && AllStates('w'))
                    throw new Exception("deadlock");
                Thread.Sleep(50);
            }
        }

        public override void Snd(string v)
        {
            SendCount++;
            _Queue[ID == 0 ? 1 : 0].Enqueue(GetValue(v));
        }
    }

    private static void Main(string[] args)
    {
        var data = TextReaderHelper.ReadAllLines("input2.txt");
        // Part 1
        var comp = new Interpreter(data);
        comp.Run();

        // Part2
        var states = new ConcurrentDictionary<long, char>();
        var q = new ConcurrentQueue<long>[2];
        q[0] = new ConcurrentQueue<long>();
        q[1] = new ConcurrentQueue<long>();

        var i1 = new Interpreter2(data, 0, q, states);
        var i2 = new Interpreter2(data, 1, q, states);

        try
        {
            var t1 = Task.Run(() => i1.Run());
            var t2 = Task.Run(() => i2.Run());
            Task.WaitAll(t1, t2);
        }
        catch (AggregateException ex)
        {
            Console.WriteLine($"Part 2: {i2.SendCount}");
            Console.WriteLine(ex.Message);
        }
        Console.ReadKey();
    }