在CLR中使用托管线程和光纤

好的，下面的链接有一个警告，说明讨论使用了不受支持和未记录的api。好吧，我试着用任何方式的代码样本。它基本上是有效的。关于下面有关例外的具体问题有什么想法吗?

http://msdn.microsoft.com/en-us/magazine/cc164086.aspx

仅供参考，我对原始样品进行了改进。它正在维护一个指向"前一个纤维"的指针。相反，下面更新的示例使用了一个传递给每个光纤类的"mainfiber"指针。通过这种方式，它们总是屈服于主纤维。这允许主光纤处理所有其他光纤的调度。其他纤维总是"屈服"回主纤维。

发布这个问题的原因与在光纤中抛出异常有关。根据文章，通过使用带有CreateLogicalThreadState()、SwitchOutLogicalThreadState()等的CorBindToRunTime API，框架将为每个光纤创建一个托管线程，并正确处理异常。

然而，在包含的代码示例中，它有一个UUnit测试，该测试在一个光纤中抛出一个托管异常，并在同一个光纤中捕获它。那软的很管用。但是在通过记录消息来处理它之后，似乎堆栈处于不良状态，因为如果光纤调用任何其他方法，甚至是空方法，整个应用程序都会崩溃。

这对我来说意味着SwitchOutLogicalThreadState()和SwitchInLogicalThreadState()可能没有被正确使用，或者可能他们没有做他们的工作。

注意:这个问题的一个线索是托管代码注销了thread . currentthread . managedthreaddid，对于每个光纤都是一样的。这表明CreateLogicalThreadState()方法并没有像宣传的那样真正创建一个新的托管线程。

为了更好地分析这一点，我制作了一个伪代码清单，列出了用于处理光纤的低级api的顺序。记住，所有的纤维都在同一个线程上运行所以没有同时发生的事情，这是线性逻辑。当然，必要的技巧是保存和恢复堆栈。这似乎就是问题所在。

它开始是一个简单的线程，然后它转换成一个纤维:

1. ConvertThreadToFiber (objptr);
2. CreateFiber()//创建多个win32光纤

现在第一次调用一个纤维，它的启动方法这样做:

1. corhost -> SwitchOutLogicalThreadState(和饼干);主要的饼干是
2. SwitchToFiber ();//第一次调用光纤启动方法
3. corhost -> CreateLogicalThreadState ();
4. 运行主光纤抽象方法

最终纤维需要返回到主纤维:

1. corhost -> SwitchOutLogicalThreadState(和饼干);
2. SwitchToFiber(纤维);
3. corhost -> SwitchInLogicalThreadState(和饼干);//主光纤饼干,对吧?

主纤维也将恢复先前存在的纤维:

1. corhost -> SwitchOutLogicalThreadState(和饼干);
2. SwitchToFiber(纤维);
3. corhost -> SwitchInLogicalThreadState(和饼干);//主纤维饼干，对吧?

下面是fibers.cpp，它为托管代码封装了光纤api。

#define _WIN32_WINNT 0x400
#using <mscorlib.dll>
#include <windows.h>
#include <mscoree.h>
#include <iostream>
using namespace std;
#if defined(Yield)
#undef Yield
#endif
#define CORHOST
namespace Fibers {
typedef System::Runtime::InteropServices::GCHandle GCHandle;
VOID CALLBACK unmanaged_fiberproc(PVOID pvoid);
__gc private struct StopFiber {};
enum FiberStateEnum {
    FiberCreated, FiberRunning, FiberStopPending, FiberStopped
};
#pragma unmanaged
#if defined(CORHOST)
ICorRuntimeHost *corhost;
void initialize_corhost() {
    CorBindToCurrentRuntime(0, CLSID_CorRuntimeHost,
        IID_ICorRuntimeHost, (void**) &corhost);
}
#endif
void CorSwitchToFiber(void *fiber) {
#if defined(CORHOST)
    DWORD *cookie;
    corhost->SwitchOutLogicalThreadState(&cookie);
#endif
    SwitchToFiber(fiber);
#if defined(CORHOST)
    corhost->SwitchInLogicalThreadState(cookie);
#endif
}
#pragma managed
__gc __abstract public class Fiber : public System::IDisposable {
public:
#if defined(CORHOST)
    static Fiber() { initialize_corhost(); }
#endif
    Fiber() : state(FiberCreated) {
        void *objptr = (void*) GCHandle::op_Explicit(GCHandle::Alloc(this));
        fiber = ConvertThreadToFiber(objptr);
        mainfiber = fiber;
        //System::Console::WriteLine( S"Created main fiber.");
}
    Fiber(Fiber *_mainfiber) : state(FiberCreated) {
        void *objptr = (void*) GCHandle::op_Explicit(GCHandle::Alloc(this));
        fiber = CreateFiber(0, unmanaged_fiberproc, objptr);
        mainfiber = _mainfiber->fiber;
        //System::Console::WriteLine(S"Created worker fiber");
    }
    __property bool get_IsRunning() {
        return state != FiberStopped;
    }
    int GetHashCode() {
        return (int) fiber;
    }

    bool Resume() {
        if(!fiber || state == FiberStopped) {
            return false;
        }
        if( state == FiberStopPending) {
            Dispose();
            return false;
        }
        void *current = GetCurrentFiber();
        if(fiber == current) {
            return false;
        }
        CorSwitchToFiber(fiber);
        return true;
    }
    void Dispose() {
        if(fiber) {
            void *current = GetCurrentFiber();
            if(fiber == current) {
                state = FiberStopPending;
                CorSwitchToFiber(mainfiber);
            }
            state = FiberStopped;
            System::Console::WriteLine( S"'nDeleting Fiber.");
            DeleteFiber(fiber);
            fiber = 0;
        }
    }
protected:
    virtual void Run() = 0;

    void Yield() {
        CorSwitchToFiber(mainfiber);
        if(state == FiberStopPending)
            throw new StopFiber;
    }
private:
    void *fiber, *mainfiber;
    FiberStateEnum state;
private public:
    void main() {
        state = FiberRunning;
        try {
            Run();
        } catch(System::Object *x) {
            System::Console::Error->WriteLine(
                S"'nFIBERS.DLL: main Caught {0}", x);
        }
        Dispose();
    }
};
void fibermain(void* objptr) {
    //System::Console::WriteLine(   S"'nfibermain()");
    System::IntPtr ptr = (System::IntPtr) objptr;
    GCHandle g = GCHandle::op_Explicit(ptr);
    Fiber *fiber = static_cast<Fiber*>(g.Target);
    g.Free();
    fiber->main();
    System::Console::WriteLine( S"'nfibermain returning");
}
#pragma unmanaged
VOID CALLBACK unmanaged_fiberproc(PVOID objptr) {
#if defined(CORHOST)
    corhost->CreateLogicalThreadState();
#endif
    fibermain(objptr);
#if defined(CORHOST)
    corhost->DeleteLogicalThreadState();
#endif
}
}

上面的fibers.cpp类文件是Visaul c++项目中唯一的类。它是作为一个支持CLR的DLL构建的，使用/CLR:oldstyle switch。

using System;
using System.Threading;
using Fibers;
using NUnit.Framework;
namespace TickZoom.Utilities
{
    public class FiberTask : Fiber 
    {
        public FiberTask()
        {
        }
        public FiberTask(FiberTask mainTask)
            : base(mainTask)
        {
        }
        protected override void Run()
        {
            while (true)
            {
                Console.WriteLine("Top of worker loop.");
                try
                {
                    Work();
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Exception: " + ex.Message);
                }
                Console.WriteLine("After the exception.");
                Work();
            }
        }
        private void Work()
        {
            Console.WriteLine("Doing work on fiber: " + GetHashCode() + ", thread id: " + Thread.CurrentThread.ManagedThreadId);
            ++counter;
            Console.WriteLine("Incremented counter " + counter);
            if (counter == 2)
            {
                Console.WriteLine("Throwing an exception.");
                throw new InvalidCastException("Just a test exception.");
            }
            Yield();
        }
        public static int counter;
    }
    [TestFixture]
    public class TestingFibers
    {
        [Test]
        public void TestIdeas()
        {
            var fiberTasks = new System.Collections.Generic.List<FiberTask>();
            var mainFiber = new FiberTask();
            for( var i=0; i< 5; i++)
            {
                fiberTasks.Add(new FiberTask(mainFiber));
            }
            for (var i = 0; i < fiberTasks.Count; i++)
            {
                Console.WriteLine("Resuming " + i);
                var fiberTask = fiberTasks[i];
                if( !fiberTask.Resume())
                {
                    Console.WriteLine("Fiber " + i + " was disposed.");
                    fiberTasks.RemoveAt(i);
                    i--;
                }
            }
            for (var i = 0; i < fiberTasks.Count; i++)
            {
                Console.WriteLine("Disposing " + i);
                fiberTasks[i].Dispose();
            }
        }
    }
}

上面的单元测试给出以下输出，然后严重崩溃:

Resuming 0
Top of worker loop.
Doing work on fiber: 476184704, thread id: 7
Incremented counter 1
Resuming 1
Top of worker loop.
Doing work on fiber: 453842656, thread id: 7
Incremented counter 2
Throwing an exception.
Exception: Just a test exception.
After the exception.