スタックオーバーフロー対策

[shimodateakira]

Walk系のメソッドでスタックオーバーフローの対策をする。固有のスレッドで実行する方式を模索する。

[shimodateakira]

public sealed class WalkThreadWorker
{
    private readonly Thread _thread;
    private readonly AutoResetEvent _workReady = new(false);
    private readonly AutoResetEvent _workDone = new(false);
    private Action? _workAction;
    private Func<object?>? _workFunction;
    private object? _result;
    private Exception? _capturedException;
    private bool _isStackOverflow;

    public WalkThreadWorker(int stackSizeBytes = 4 * 1024 * 1024)
    {
        _thread = new Thread(ThreadLoop, stackSizeBytes);
        _thread.IsBackground = true;
        _thread.Start();
    }

    public void Execute(Action action)
    {
        _workAction = action;
        _workFunction = null;
        RunWorker();
    }

    public T Execute<T>(Func<T> function)
    {
        _workFunction = () => function();
        _workAction = null;
        RunWorker();
        return (T)_result!;
    }

    private void RunWorker()
    {
        _isStackOverflow = false;
        _capturedException = null;
        _result = null;

        _workReady.Set();
        _workDone.WaitOne();

        if (_isStackOverflow)
        {
            throw new StackOverflowException("スタックオーバーフローが検出されました（Workerスレッド内）");
        }

        if (_capturedException != null)
        {
            throw _capturedException;
        }
    }

    private void ThreadLoop()
    {
        while (true)
        {
            _workReady.WaitOne();

            try
            {
                if (_workAction != null)
                {
                    _workAction.Invoke();
                }
                else if (_workFunction != null)
                {
                    _result = _workFunction.Invoke();
                }
            }
            catch (StackOverflowException)
            {
                _isStackOverflow = true;
            }
            catch (Exception ex)
            {
                _capturedException = ex;
            }
            finally
            {
                _workAction = null;
                _workFunction = null;
                _workDone.Set();
            }
        }
    }
}

[shimodateakira]

public sealed class WalkThreadWorker
{
    private readonly Thread _thread;
    private readonly AutoResetEvent _workStart = new(false);
    private readonly AutoResetEvent _workDone = new(false);

    private Func<object?>? _task;
    private object? _result;
    private Exception? _capturedException;
    private bool _isStackOverflow;

    public WalkThreadWorker(int stackSizeBytes = 4 * 1024 * 1024)
    {
        _thread = new Thread(ThreadLoop, stackSizeBytes)
        {
            IsBackground = true
        };
        _thread.Start();
    }

    private void ThreadLoop()
    {
        while (true)
        {
            _workStart.WaitOne();

            try
            {
                _capturedException = null;
                _isStackOverflow = false;

                if (_task != null)
                {
                    _result = _task.Invoke();
                }
            }
            catch (StackOverflowException)
            {
                _isStackOverflow = true;
            }
            catch (Exception ex)
            {
                _capturedException = ex;
            }

            _workDone.Set();
        }
    }

    public T Execute<T>(Func<T> function, int timeoutMilliseconds)
    {
        if (function == null) throw new ArgumentNullException(nameof(function));

        _task = () => function();
        _result = default;
        _capturedException = null;
        _isStackOverflow = false;

        _workStart.Set();

        if (!_workDone.WaitOne(timeoutMilliseconds))
        {
            throw new TimeoutException("操作がタイムアウトしました。スタックオーバーフローまたは無限ループの可能性があります。");
        }

        if (_isStackOverflow)
        {
            throw new StackOverflowException("スタックオーバーフローが検出されました。");
        }

        if (_capturedException != null)
        {
            throw new Exception("スレッド内処理で例外が発生しました。", _capturedException);
        }

        return (T)_result!;
    }
}