怎样让多条线程顺序执行？？？

Question

 for (int i = 0; i < 10; i++)
            {
                new Thread(
                    delegate()
                    {
                       //MyCode;
                    }
                    ).Start();            }
//怎么让循环中的线程按照I的顺序先后执行，是用Lock锁吗？
//应该怎么锁，请大侠指点

Answer 1

顺序即：我的10个 //MyCode;
一个一个顺序的执行

Answer 2

简单啊,线程1... 线程10线程1执行完了给线程2执行 线程2.start
以此类推 不就行了吗

Answer 3

同步通知吧，其实你无须关心线程的执行顺序：你开启N个线程，然后等待直到这个N个线程执行完成，再取得结果就行了；如果是在线程的执行代码中顺序的执行，也是失去了线程的意义了，还不如把这N个线程合并为一个线程（后台线程），这样代码会很简洁；

Answer 4

加控制量设
 第一个线程控制 k=1
 第二个线程当 k =1时执行貌似C# 中有这样的方法 能直接用的！

Answer 5

如何控制好多个线程相互之间的联系，不产生冲突和重复，这需要用到互斥对象，即：System.Threading 命名空间中的 Mutex 类。 我们可以把Mutex看作一个出租车，乘客看作线程。乘客首先等车，然后上车，最后下车。当一个乘客在车上时，其他乘客就只有等他下车以后才可以上车。而线程与Mutex对象的关系也正是如此，线程使用Mutex.WaitOne()方法等待Mutex对象被释放，如果它等待的Mutex对象被释放了，它就自动拥有这个对象，直到它调用Mutex.ReleaseMutex()方法释放这个对象，而在此期间，其他想要获取这个Mutex对象的线程都只有等待

Answer 6

static void Main(string[] args)
{
    int order = 0;//, -1 for exit , 0 for initialize
    int ordermax = 0;//最大编号
    ParameterizedThreadStart threadProc = p =>
        {
            if (!(p is int)) return;
            int myOrder = (int)p;
            object sync = new object();
            while (true)
            {
                lock (sync)//同步线程
                {
                    if (order != myOrder)//判断状态机当前状态是否是到自己执行
                    {
                        Thread.Sleep(50);//阻塞自己线程50毫秒后继续下一次检测
                        continue;
                    }
                    Console.WriteLine(p);//实际操作
                    order++;//在lock块中，安全的操作状态
                    if (order > ordermax) order = 1;//循环状态
                }
                Thread.Sleep(50);
            }
        };
    new Thread(threadProc).Start(1);//启动1个线程，编号1
    new Thread(threadProc).Start(2);//启动1个线程，编号2
    new Thread(threadProc).Start(3);//启动1个线程，编号3
    new Thread(threadProc).Start(4);//启动1个线程，编号4
    ordermax = 4;//最大值4
    order = 1;//当前状态1，开始启动
    Console.ReadKey();
}

Answer 7

以上写的例子用到匿名方法、lambda、线程同步的简化写法。你仔细看应该就问题解决了。

Answer 8

给你一个很少人用的方法：用socket。

Answer 9

Task t = null;
for (int i = 0; i < 10; i++)
{
  Action a = delegate()
  {
  //MyCode;
  };  if (t != null) 
     t = t.ContinueWith(a);
  else
     t = Task.Factory.StartNew(a);
}

Answer 10

thread.Join(); 不就可以了么
        public const int Repetitions = 10000;        public static void Main()
        {
            //Thread thread = new Thread(DoWork);
            //thread.Start(".");
            //thread.Join();
            //for (int count = 0; count < Repetitions; count++)
            //{
            //    Console.Write('-');
            //}
            Thread thread;
            for (int i = 0; i < 3; i++)
            {
                thread = new Thread(DoWork);
                if (i == 0)
                {
                    thread.Start(".");
                }
                else if (i == 1)
                {
                    thread.Start("-");
                }
                else if (i == 2)
                {
                    thread.Start("*");
                }
                else {
                    thread.Start("&");
                }
                thread.Join();
            }
            
            Console.ReadLine();
        }        public static void DoWork(object state)
        {
            for (int count = 0; count < Repetitions; count++)
            {
                Console.Write(state);
            }
        }
    }

Answer 11

thread.Join()
一旦线程启动，就可以通过调用thread.Join()来造成一个“等待完成”(wait for completion)情形。调用线程会一直等待，直到thread实例终止。

Answer 12

Thread t =new Thread(
  delegate()
  {
  //MyCode;
  }
  ).Start();改成这样  然后加一句
t.Join();
就可以了但是如果是这样 那你为什么不做一个方法呢？ 让那个方法循环执行 线程里的方法？
搞那么多线程看的都麻烦