本人新手 求高手帮忙做成多进程同时进行的模式

Question

意思就是要异步编程吧，用委托可以实现。把需要移到后台运行的函数程序交给委托做，这样就可以跟主线程异步进行，不会阻塞主线程。委托关键字是delegate，使用方法也很简单，百度一下吧。

Answer 1

http://zhidao.baidu.com/link?url=cT22QBWJPvRdeHs_ihM8BjljCW7ePgwo0vC-k-3Hp3SZJIHKJufsmmJp2XBRolcc8cXw-KzNcZxmajwEeEkOxpRC5sFHdr1xlFAhAe1Rwhi
看一下这个，保证能明白。
再看一下这个博文，http://blog.csdn.net/u012999424/article/details/17963131

Answer 2

现在是只有s4在执行 我想让s1-s3同时执行 s4 s5等待其他执行完成 就是有3个任务同时执行 其他等待执行完成

Answer 3

好像要用lock关键字进行同步 我也不是太懂 应该有很多人会吧

Answer 4

虽然不太明白你的代码，要几个线程一起跑？，随便帮你写点吧private void DYZ(ref pcb[] m_pcb)
{
    for (int j = 0; j < m_pcb.Length; j++)
    {
        var thread = new Thread(Run) { IsBackground = true };
        thread.Start(j);
    }
}private void Run(object args)
{
    try
    {
        int no = (int)args;
        int index = 0;
        while (index < 10)
        {
            Console.WriteLine("No:{0}    index:{1}", no, index++);
            Thread.Sleep(1000);
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }
}

Answer 5

恩 就要这种效果的 但是能不能做成我上面图中做的那个样子的 让s1-s5中3个或者n个同时进行 而不是index0-10的同时进行

Answer 6

恩 就要这种效果的 但是能不能做成我上面图中做的那个样子的 让s1-s5中3个或者n个同时进行 而不是index0-10的同时进行

Answer 7

多进程 ...是可以的，不过对你来说太难，给你个关键词 命名管道、进程通信、NamedPipe 自己百度，就有很多例子讲多进程的

Answer 8

现在的要求是这样的设计一个任务调度算法 如果有10个stack 其中最多只允许5个同时运行 每完成1个stack未完成的stack随机任意补充上 第二种算法就是10个stack中最多只允许同时运行5个 然后允许运行的是有位置的例如s1 s2 s3 s4 s5 要是s1完成了 s6-s10中的就去补充上s1的位置 每次完成的时候要知道哪个位置完成了 我之前的做法是不是不对啊 掉坑里了

Answer 9

你这个不一定要用到多线程，你不能n个同时进行是因为你每次只取到了1个，只能操作1个（看代码中的注释）
而且你循环内部的循环也要放到外面独立循环，定义一个集合List<pcb>,将要开始服务的都添加进来，进行你循环内部的那个循环。finish的项目，从List中移除/// <summary>
        /// 第一种方法
        /// </summary>
        /// <param name="m_pcb1"></param>
        private void DYZ(ref pcb[] m_pcb)
        {
            Time(ref m_pcb);  //数据输入函数
            int n = 0; //保存小赖的服务的索引
            for (int j = 0; j < m_pcb.Length; j++)
            {
 //你需要顶一个一个外层变量，表示时间变化，同时在函数中，取出这个时间到达的所有项，然后进行后续操作
                n = RYRW(ref m_pcb);//这里只取到了最先执行的。。
               
                int k = m_pcb[n].TimeServer; //服务时间
                if (j != 0) //不是第一个来的
                {
                    m_pcb[n].TimeBegin = TimeEnd;
                    TimeEnd += m_pcb[n].TimeServer;
                    m_pcb[n].TimeEnd = m_pcb[n].TimeBegin + m_pcb[n].TimeServer;
                }
                else if (j == 0)
                {
                    m_pcb[n].TimeBegin = m_pcb[n].TimeComing;
                    m_pcb[n].TimeEnd = m_pcb[n].TimeComing + m_pcb[n].TimeServer;
                    TimeEnd = m_pcb[n].TimeEnd;
                }                m_pcb[n].TimeCycle = m_pcb[n].TimeEnd - m_pcb[n].TimeComing;
                m_pcb[n].finish = true;
                for (int i = 0; i < k; i++)
                {
                    Thread.Sleep(500);
                    Console.Clear();
                    m_pcb[n].TimeServer--; //还需要的服务时间，循环一次，自减
                    display(m_pcb);
                }
            }        }

Answer 10

看一下多线程编程，非常简单的，给你发一段参考代码
模拟火车售票程序。
01. using System;
02. using System.Threading;
03. namespace Example9_10
04. {
05.   class Example9_10
06.   {
07.      static void Main(string[] args)
08.      {
09.         TicketAgency ta = new TicketAgency();
10.         Thread[] ts = new Thread[4];
11.         for (int i = 0; i < 4; i++)
12.         {
13.            ts[i] = new Thread(new ThreadStart(ta.RandomSell));
14.            ts[i].Name = "窗口" + i;
15.            ts[i].Start();
16.         }
17.         Console.Read();
18.     }
19.   }
20.   public class TicketAgency
21.   {
22.      private int m_num = 0;
23.      private Random rand = new Random();
24.      public void Sell()
25.      {
26.         lock(this)
27.         {
28.             if (m_num < 66)
29.             {
30.                int tmp = m_num + 1;
31.                Thread.Sleep(1);
32.                m_num = tmp;
33.                Console.WriteLine("{0}:售出{1}号车票", Thread.CurrentThread. Name, tmp);
34.             }
35.             else
36.             {
37.                 Console.WriteLine("{0}：车票已售罄", Thread. CurrentThread. Name);
38.             }
39.         }
40.      }
41.      public void RandomSell()
42.      {
43.         int time=rand.Next(20);
44.         for(int i=0;i<20;i++)
45.         {
46.             Thread.Sleep(time);
47.             this.Sell();
48.         }
49.      }
50.   }
51. }

Answer 11

好像不是这种的因为 卖出的票也是一个一个执行的 sleep（1000）的话能看的出来 我想要同时执行的

Answer 12

现在的要求是这样的设计一个任务调度算法 如果有10个stack 其中最多只允许5个同时运行 每完成1个stack未完成的stack随机任意补充上 第二种算法就是10个stack中最多只允许同时运行5个 然后允许运行的是有位置的例如s1 s2 s3 s4 s5 要是s1完成了 s6-s10中的就去补充上s1的位置 每次完成的时候要知道哪个位置完成了 求大神帮我做出来 自己做了好多天都没弄出来 本人新手我现在就是要弄个C#控制台程序 之前做的感觉算法什么的都不太对 但是样子有了点 就像上面我想要3个任务同时执行 但是现在只能一个任务在执行 这个图里是s4在执行中 第一种就是任意3（这个是任意数就好像网际快车下载的时候可以自定义线程）个执行 第二种就是比如s2执行完成了 s4执行的时候跳到s2的位置上 谢谢 帮忙做一下我实在弄不出来了

Answer 13

委托的话我想清楚了可能是想叫我方法1和方法2 同步执行 但是我现在 用switch case 语句让他一个一个的运行就成了 不考虑两个方法同时的问题 只要满足算法和多个stack一起执行就成

Answer 14

代码我给出来了 现在​
  /// <summary>
        /// 第一种方法
        /// </summary>
        /// <param name="m_pcb1"></param>       
        private void DYZ(ref pcb[] m_pcb)
        {
            Time(ref m_pcb);  //数据输入函数
            int n = 0; //保存小赖的服务的索引
            for (int j = 0; j < m_pcb.Length; j++)
            {
               /* var thread = new Thread(Run) { IsBackground = true };
                thread.Start(j);*/
               n = RYRW(ref m_pcb);
                int k = m_pcb[n].TimeServer; //服务时间
                if(j != 0) //不是第一个来的
                {
                    m_pcb[n].TimeBegin = TimeEnd;
                    TimeEnd += m_pcb[n].TimeServer;
                    m_pcb[n].TimeEnd = m_pcb[n].TimeBegin + m_pcb[n].TimeServer;
                }
                else if(j==0)
                {
                    m_pcb[n].TimeBegin = m_pcb[n].TimeComing;
                m_pcb[n].TimeEnd = m_pcb[n].TimeComing+m_pcb[n].TimeServer;
                TimeEnd = m_pcb[n].TimeEnd;
                }                 m_pcb[n].TimeCycle = m_pcb[n].TimeEnd - m_pcb[n].TimeComing;            for (int i=0;i<k;i++)
                 {
                Thread.Sleep(500);
                Console.Clear();
                m_pcb[n].TimeServer--; //还需要的服务时间，循环一次，自减
                    display(m_pcb);
                 }
            m_pcb[n].finish = true;
            }
           
        }这里被我超同步化了 能不能把我给他解体用5个stread分别控制起来

Answer 15

兄弟，你太有恒心了，小弟佩服~~再帮你随便写点，你自己再改改吧~~
public struct Task
{
    public int No;
    public int Current;
    public int Max;
}readonly List<Task> _taskList = new List<Task>();private void DYZ()
{
    Random ran = new Random();
    for (int i = 0; i < 10; i++)
    {
        _taskList.Add(new Task { Current = 0, Max = ran.Next(10, 20), No = i });
    }
    var list = new List<Thread>();
    for (int j = 0; j < 5; j++)
    {
        var thread = new Thread(Run) { IsBackground = true };
        thread.Start(_taskList[j]);
        list.Add(thread);
    }
    list.ForEach(x => x.Join());
    for (int j = 5; j < 10; j++)
    {
        var thread = new Thread(Run) { IsBackground = true };
        thread.Start(_taskList[j]);
        thread.Join();
    }
    Console.WriteLine("it's over");
}private void Run(object args)
{
    try
    {
        Task task = (Task)args;
        while (task.Current < task.Max)
        {
            task.Current++;
            Thread.Sleep(200);
            lock (_taskList)
            {
                Console.Clear();
                _taskList[task.No] = task;
                _taskList.ForEach(x => Console.WriteLine("No:{0}    current:{1}   max:{2}", x.No, x.Current, x.Max));
            }
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }
}这个是5个线程先一起跑，都跑完了之后，后面一个接着一个跑，每个的线程的终止值设的随机数~~

Answer 16

以前用过个Semaphore，帮你改了下~~总共10个，5个先跑，当其中有跑完了的，后5个随机上~~细节没有多考虑，你自己改吧~~等放假，好无聊~~using System;
using System.Collections.Generic;
using System.Threading;namespace ConsoleApplication1
{
    class Program
    {
        private const int MaxRunNumber = 5;
        private static RunTask[] _runTasks;
        static readonly List<Task> TaskList = new List<Task>();
        public static Semaphore Sp = new Semaphore(MaxRunNumber, MaxRunNumber);        static void Main()
        {
            Random ran = new Random();
            for (int i = 0; i < 10; i++)
            {
                TaskList.Add(new Task { Current = 0, Max = ran.Next(10, 30), No = i });
            }            _runTasks = new RunTask[MaxRunNumber];
            for (int i = 0; i < MaxRunNumber; i++)
                _runTasks[i] = new RunTask();            foreach (var task in TaskList)
            {
                Thread user = new Thread(Run);
                user.Start(task);
                Thread.Sleep(10);
            }
            Console.ReadLine();
        }        static void Run(Object task)
        {
            Sp.WaitOne();
            RunTask runTask = null;
            for (int i = 0; i < MaxRunNumber; i++)
                if (_runTasks[i].IsOccupied == false)
                {
                    runTask = _runTasks[i];
                    break;
                }
            if (runTask != null) runTask.Use((Task)task);
            Sp.Release();
        }        class RunTask
        {
            public bool IsOccupied;
            public void Use(Task task)
            {
                IsOccupied = true;
                while (task.Current < task.Max)
                {
                    task.Current++;
                    Thread.Sleep(500);
                    lock (TaskList)
                    {
                        Console.Clear();
                        TaskList[task.No] = task;
                        TaskList.ForEach(x => Console.WriteLine("No:{0}    current:{1}   max:{2}", x.No, x.Current, x.Max));
                    }
                }
                IsOccupied = false;
            }
        }        public struct Task
        {
            public int Current;
            public int Max;
            public int No;
        }
    }
}

Answer 17

你所谓的第二种有什么区别么？你的意思是前面的完成了，要在页面显示上删掉，然后把后面那个显示到之前那个被删掉的位置上，仅仅就是为了让你能看出后面的是“插”到前面来了？
差不多 不过是这样的 s1 s2 s3 这样的任务 s2完成了 就变成s1 s3 s2 当然s2 位置上的时间也要变成s3的