Question

我正在创建一个字典来管理线程，当我在字典中添加一些线程后尝试清除死线程时，我遇到了这个异常。

using System;
using System.Collections.Generic;
using System.Threading;

namespace SysCat {
    public class ThreadManager {
        public static readonly ThreadManager GlobalThreadManager = new ThreadManager( );

        /// <summary>
        /// Initializes a new instance of the <see cref="SysCat.ThreadManager"/> class.
        /// </summary>
        public ThreadManager( ) {

        }

        /// <summary>
        /// Create a new ThreadManager with all the Threads within baseTM and deinitializes baseTM
        /// </summary>
        public ThreadManager( ThreadManager baseTM ) {
            this.threads = baseTM.threads;
            baseTM.threads.Clear( );
        }

        private Dictionary<Guid,Thread> threads = new Dictionary<Guid, Thread>( );

        /// <summary>
        /// Attempts to obtain an unused ThreadID within an attempt limit
        /// </summary>
        /// <returns>The unused ThreadID, if found</returns>
        /// <param name="attempts">The number of iterations to try.</param>
        public Guid getUnusedThreadID( int attempts ) {
            lock( threads ) {
                Guid threadID;
                int totalAttempts = attempts;
                while( threads.ContainsKey( ( threadID = Guid.NewGuid( ) ) ) ) {
                    attempts--;
                    if( attempts == 0 )
                        throw new NoOpenThreadIDException( totalAttempts );
                }
                return threadID;
            }
        }

        /// <summary>
        /// Attempts to get a Thread via its ThreadID, if it exists
        /// </summary>
        /// <returns>The Thread</returns>
        /// <param name="threadID">The ThreadID to use</param>
        public Thread getThread( Guid threadID ) {
            lock( threads ) {
                Thread tryGet;
                if( !threads.TryGetValue( threadID, out tryGet ) )
                    throw new ArgumentException( "Specified ThreadID does not exist in this ThreadManager" );
                return tryGet;
            }
        }

        /// <summary>
        /// Attempts to get a ThreadID via the Thread
        /// </summary>
        /// <returns>The ThreadID</returns>
        /// <param name="thread">The Thread to use</param>
        public Guid getThreadID( Thread thread ) {
            lock( threads ) {
                if( threads.ContainsValue( thread ) ) {
                    foreach( Guid id in threads.Keys ) {
                        Thread t;
                        threads.TryGetValue( id, out t );
                        if( t.Equals( thread ) )
                            return id;
                    }
                    // I should never get here
                    return Guid.Empty;
                }
                else
                    throw new ArgumentException( "Specified Thread does not exist in this ThreadManager" );
            }
        }

        /// <summary>
        /// Adds the Thread, unless it cannot find an open ThreadID
        /// </summary>
        /// <returns>The ThreadID used to register the Thread</returns>
        /// <param name="thread">The Thread to register</param>
        public Guid addThread( Thread thread ) {
            lock( threads ) {
                Guid id;
                try {
                    id = getUnusedThreadID( 500 );
                }
                catch( NoOpenThreadIDException e ) {
                    throw e;
                }
                threads.Add( id, thread );
                return id;
            }
        }

        /// <summary>
        /// Attempts to clear all stopped and null Threads
        /// </summary>
        /// <returns>The number of dead Threads cleared</returns>
        public int clearDeadThreads() {
            int cleared = 0;
            lock(threads) {
                foreach( Guid id in threads.Keys ) {
                    Thread thread;
                    threads.TryGetValue( id, out thread );
                    if( thread == null ) {
                        // Does not exist, Thread is dead
                        cleared++;
                        threads.Remove( id );
                        continue;
                    }
                    if( !thread.IsAlive ) {
                        // Not alive, Thread is dead
                        cleared++;
                        threads.Remove( id );
                        continue;
                    }
                }
            }

            return cleared;
        }

        public class NoOpenThreadIDException : Exception {
            public NoOpenThreadIDException( int attempts )
                : base( string.Format( "Unable to find an open ThreadID within the attempt limit of {0}", attempts ) ) {
            }
        }
    }
}

我收到此异常：System.InvalidOperationException 随着消息：集合被修改;枚举操作可能无法执行

我不确定为什么会这样，任何帮助都会受到赞赏。

这是我用来测试它的代码：

using System;
using System.Collections;
using System.IO;
using System.Collections.Generic;
using System.Threading;

using _TM = SysCat.ThreadManager;

namespace SysCat {
    public class SysCat {
        Thread T = new Thread( new ThreadStart( delegate {
            while(true) Thread.Sleep(250);
        } ) );
        Thread T2 = new Thread( new ThreadStart( delegate {

        } ) );
        Thread T3 = new Thread( new ThreadStart( delegate {

        } ) );
        _TM.GlobalThreadManager.addThread( T );
        _TM.GlobalThreadManager.addThread( T2 );
        _TM.GlobalThreadManager.addThread( T3 );
            Console.WriteLine( _TM.GlobalThreadManager.clearDeadThreads( ) );
            Console.ReadLine( );
        }
    }
}

Answer 1

在您对其进行枚举时，无法修改IEnumerable。

你可以做一个简单的黑客攻击并获得你所枚举的内容的副本，因此其中的更改不会导致System.InvalidOperationException。

例如，

而不是

foreach( Guid id in threads.Keys)

使用

foreach( Guid id in threads.Keys.ToList())

请注意，您可以使用data structures that supports concurrency

尝试修改Dictionary时出现异常

1 个答案: