How does Garbage collector know when to clean the objects ?

Part -2 

Supporting code in c#:

using System;
using System.Collections.Concurrent;
using System.Diagnostics;
using System.Threading.Tasks;

public class DataProcessor
{
    // Concurrent queue to simulate high-volume data processing
    private ConcurrentQueue _dataQueue = new ConcurrentQueue();

    // Simulates creating large number of objects
    public async Task ProcessLargeDataSetAsync(int totalObjects)
    {
        Console.WriteLine($"Starting to process {totalObjects} objects");
        
        // Measure memory and time
        var startMemory = Process.GetCurrentProcess().WorkingSet64;
        var stopwatch = Diagnostics.Stopwatch.StartNew();

        // Parallel processing to create objects quickly
        await Task.Run(() =>
        {
            Parallel.For(0, totalObjects, i =>
            {
                // Create a new data point and add to queue
                var dataPoint = new DataPoint
                {
                    Id = i,
                    Timestamp = DateTime.Now,
                    Value = CalculateComplexValue(i)
                };

                _dataQueue.Enqueue(dataPoint);
            });
        });

        // Process and potentially remove references
        ProcessQueue();

        stopwatch.Stop();
        var endMemory = Process.GetCurrentProcess().WorkingSet64;

        Console.WriteLine($"Processing complete:");
        Console.WriteLine($"Total Time: {stopwatch.ElapsedMilliseconds} ms");
        Console.WriteLine($"Memory Used: {(endMemory - startMemory) / 1024 / 1024} MB");
    }

    private void ProcessQueue()
    {
        while (_dataQueue.TryDequeue(out var dataPoint))
        {
            // Process the data point
            ProcessDataPoint(dataPoint);
        }
    }

    private double CalculateComplexValue(int index)
    {
        // Simulate complex calculation
        return Math.Sqrt(index) * Math.Sin(index) * Math.Cos(index);
    }

    private void ProcessDataPoint(DataPoint dataPoint)
    {
        // Simulate processing
        // This method creates an opportunity for garbage collection
        var processedValue = dataPoint.Value * 2;
    }
}

// Simple data structure to represent processed data
public class DataPoint
{
    public int Id { get; set; }
    public DateTime Timestamp { get; set; }
    public double Value { get; set; }
}

class Program
{
    static async Task Main()
    {
        var processor = new DataProcessor();
        
        // Process 1 million objects
        await processor.ProcessLargeDataSetAsync(1_000_000);

        // Explicitly trigger garbage collection (not typically needed)
        GC.Collect();
        GC.WaitForPendingFinalizers();
    }
}