public class TaskItem
{
    public int Priority { get; set; }
    public Action TaskAction { get; set; }
}
public class PriorityQueue<T> where T : IComparable<T>
{
    private List<T> heap;
    public PriorityQueue()
    {
        heap = new List<T>();
    }
    public void Enqueue(T item)
    {
        heap.Add(item);
        int index = heap.Count - 1;
        while (index > 0)
        {
            int parentIndex = (index - 1) / 2;
            if (heap[parentIndex].CompareTo(heap[index]) >= 0)
                break;
            Swap(parentIndex, index);
            index = parentIndex;
        }
    }
    public T Dequeue()
    {
        if (heap.Count == 0)
            throw new InvalidOperationException("Queue is empty");
        T result = heap[0];
        int lastIndex = heap.Count - 1;
        heap[0] = heap[lastIndex];
        heap.RemoveAt(lastIndex);
        int index = 0;
        while (true)
        {
            int leftChildIndex = 2 * index + 1;
            int rightChildIndex = 2 * index + 2;
            int largestIndex = index;
            if (leftChildIndex < heap.Count && heap[leftChildIndex].CompareTo(heap[largestIndex]) > 0)
                largestIndex = leftChildIndex;
            if (rightChildIndex < heap.Count && heap[rightChildIndex].CompareTo(heap[largestIndex]) > 0)
                largestIndex = rightChildIndex;
            if (largestIndex == index)
                break;
            Swap(index, largestIndex);
            index = largestIndex;
        }
        return result;
    }
    private void Swap(int i, int j)
    {
        T temp = heap[i];
        heap[i] = heap[j];
        heap[j] = temp;
    }
}

public class TaskScheduler
{
    private Dictionary<TaskItem, long> taskExecutionTimeMap;
    private int defaultTimeSlice;
    public TaskScheduler()
    {
        taskExecutionTimeMap = new Dictionary<TaskItem, long>();
        defaultTimeSlice = 100; // 初始默認(rèn)時(shí)間片
    }
    public int GetTimeSlice(TaskItem task)
    {
        if (taskExecutionTimeMap.TryGetValue(task, out long executionTime))
        {
            if (executionTime < 50) // 假設(shè)執(zhí)行時(shí)間小于50ms為短任務(wù)
                return defaultTimeSlice / 2;
            else if (executionTime > 200) // 假設(shè)執(zhí)行時(shí)間大于200ms為長(zhǎng)任務(wù)
                return defaultTimeSlice * 2;
        }
        return defaultTimeSlice;
    }
    public void UpdateTaskExecutionTime(TaskItem task, long executionTime)
    {
        if (taskExecutionTimeMap.ContainsKey(task))
            taskExecutionTimeMap[task] = executionTime;
        else
            taskExecutionTimeMap.Add(task, executionTime);
    }
}

using System;
using System.Runtime.CompilerServices;
public static class UnsafeMemoryUtil
{
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static unsafe byte* AllocateMemory(int size)
    {
        byte* ptr = (byte*)System.Runtime.InteropServices.Marshal.AllocHGlobal(size).ToPointer();
        return ptr;
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void FreeMemory(byte* ptr)
    {
        System.Runtime.InteropServices.Marshal.FreeHGlobal((IntPtr)ptr);
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static unsafe void CopyMemory(byte* source, byte* destination, int length)
    {
        for (int i = 0; i < length; i++)
        {
            destination[i] = source[i];
        }
    }
}

using System;
using System.Runtime.CompilerServices;
using System.Threading;
public class LockFreeQueue<T>
{
    private class Node
    {
        public T Value { get; set; }
        public Node Next { get; set; }
        public Node(T value)
        {
            Value = value;
        }
    }
    private volatile Node head;
    private volatile Node tail;
    public LockFreeQueue()
    {
        Node dummy = new Node(default(T));
        head = tail = dummy;
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void Enqueue(T value)
    {
        Node newNode = new Node(value);
        while (true)
        {
            Node currentTail = tail;
            Node next = currentTail.Next;
            if (currentTail == tail)
            {
                if (next == null)
                {
                    if (Interlocked.CompareExchange(ref currentTail.Next, newNode, null) == null)
                    {
                        Interlocked.CompareExchange(ref tail, newNode, currentTail);
                        return;
                    }
                }
                else
                {
                    Interlocked.CompareExchange(ref tail, next, currentTail);
                }
            }
        }
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public bool TryDequeue(out T value)
    {
        while (true)
        {
            Node currentHead = head;
            Node currentTail = tail;
            Node next = currentHead.Next;
            if (currentHead == head)
            {
                if (currentHead == currentTail)
                {
                    if (next == null)
                    {
                        value = default(T);
                        return false;
                    }
                    Interlocked.CompareExchange(ref tail, next, currentTail);
                }
                else
                {
                    value = next.Value;
                    if (Interlocked.CompareExchange(ref head, next, currentHead) == currentHead)
                    {
                        return true;
                    }
                }
            }
        }
    }
}