Программа в четыре потока работает медленнее, чем ожидалось

public class ThreadManager
    {
        private Grid _grid;
 
        private Grid _grid1;
        private Grid _grid2;
        private Grid _grid3;
        private Grid _grid4;
 
 
        private Stack<Grid> _grids;
 
        private Stack<Grid> _grids1;
        private Stack<Grid> _grids2;
        private Stack<Grid> _grids3;
        private Stack<Grid> _grids4;
 
 
        public bool IsUnique { get; private set; }
 
        private bool _isUnique1 = true;
        private bool _isUnique2 = true;
        private bool _isUnique3 = true;
        private bool _isUnique4 = true;
 
        public ThreadManager(Grid grid, IEnumerable<Grid> grids):
            this()
        {
            _grid = grid;
 
            _grid1 = (Grid)_grid.Clone();
            _grid2 = (Grid)_grid.Clone();
            _grid3 = (Grid)_grid.Clone();
            _grid4 = (Grid)_grid.Clone();
 
            _grids = new Stack<Grid>(grids);
            if (_grids.Count > 3)
            {
                var seporator = _grids.Count / 4;
                var list = new List<Grid>(grids);
 
                var list1 = new List<Grid>();
                var list2 = new List<Grid>();
                var list3 = new List<Grid>();
                var list4 = new List<Grid>();
                
                list1.AddRange(list.GetRange(0, seporator));
                _grids1 = new Stack<Grid>(list1);
                list2.AddRange(list.GetRange(seporator, seporator));
                _grids2 = new Stack<Grid>(list2);
                list3.AddRange(list.GetRange(seporator * 2, seporator));
                _grids3 = new Stack<Grid>(list3);
                list4.AddRange(list.GetRange(seporator * 3, list.Count - (seporator*3)));
                _grids4 = new Stack<Grid>(list4);
            }      
        }
 
        public ThreadManager()
        {
            _grids1 = new Stack<Grid>();
            _grids2 = new Stack<Grid>();
            _grids3 = new Stack<Grid>();
            _grids4 = new Stack<Grid>();
            IsUnique = true;
        }
 
        public void StartChecking()
        {
            if (_grids.Count > 3)
            {
                var th1 = new Thread(workFunc1);
                th1.Start();
                var th2 = new Thread(workFunc2);
                th2.Start();
                var th3 = new Thread(workFunc3);
                th3.Start();
                var th4 = new Thread(workFunc4);
                th4.Start();
                
                th1.Join();
                th2.Join();
                th3.Join();
                th4.Join();
                
                IsUnique = _isUnique1 & _isUnique2 & _isUnique3 & _isUnique4;
            }
            else
            {
                workFunc();
            }
        }
 
        private void workFunc()
        {
            while (_grids.Any())
            {
                if (!_grid.Equals(_grids.Pop()))
                    continue;
                IsUnique = false;
                return;
            }
        }
 
        private void workFunc1()
        {
            while (_grids1.Any())
            {
                if (!_grid1.Equals(_grids1.Pop())) 
                    continue;
                _isUnique1 = false;
                return;
            }           
        }
 
 
        private void workFunc2()
        {
            while (_grids2.Any())
            {
                if (!_grid2.Equals(_grids2.Pop()))
                    continue;
                _isUnique2 = false;
                return;
            }
        }
 
        private void workFunc3()
        {
            while (_grids3.Any())
            {
                if (!_grid3.Equals(_grids3.Pop()))
                    continue;
                _isUnique3 = false;
                return;
            }
        }
 
        private void workFunc4()
        {
            while (_grids4.Any())
            {
                if (!_grid4.Equals(_grids4.Pop()))
                    continue;
                _isUnique4 = false;
                return;
            }
        }
    }

            var numbers = Enumerable.Range(0, 100000000);
 
            var flag = true;
 
            Parallel.ForEach(numbers, (i, s) =>
            {
                if (i == 100499999)
                {
                    flag = false;
                    s.Break();
                }
            });