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

[sdkl100]

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace 任务调度算法
{
    class Program
    {
        static void Main(string[] args)
        {
            Renwu rw = new Renwu();
            rw.main();
            Thread.Sleep(20000);

        }
    }
    public class Renwu
    {
        public enum state
        {
            ready, //就绪
            execute, //执行
            block, //阻塞
            finish, //完成
        }
        public struct pcb
        {
            public string name;
            public int TimeComing; //到达时间
            public int TimeServer; //服务时间
            public int TimeBegin; //开始时间
            public int TimeEnd; //结束时间
            public int TimeCycle; //周转时间
            public double rate;
            public bool finish;
        }
        #region //成员变量
        private int TimeEnd = 0;
        public pcb pcb1 = new pcb();
        #endregion
        public Renwu()
        {
 
        }
        public void main()
        {
            display_menu(); //显示菜单
            int k;
            int NumPcb = 0;
            k = int.Parse(Console.ReadLine());
            switch(k)
            {
                case 1:
                Console.Clear();
                Console.WriteLine("请输入进程的个数");
                NumPcb = int.Parse(Console.ReadLine());
                pcb[] m_pcb = new pcb[NumPcb];
                DYZ(ref m_pcb);//调用第一种方法
                break;
                case 2:
                    Console.Clear();
                Console.WriteLine("请输入进程的个数");
                NumPcb = int.Parse(Console.ReadLine());
                pcb[] m_pcb1 = new pcb[NumPcb];
                DRZ(ref m_pcb1);//调用第二种方法
                break;
                case 3:
                   break;
                default:
                    Console.WriteLine("Input error");
                    break;


            }
        }
        public void display_menu() //显示菜单
        {
            Console.WriteLine("请选择调度算法:" + "\n");
            Console.WriteLine("1 无序插入");//第一种方法
            Console.WriteLine("2 空位插入");
            Console.WriteLine("3 退出");
        }
        public void display(pcb[] m_pcb)
        {
            Console.WriteLine("进程" + "\t"+"到达"+"\t"+"服务"+"\t"+"开始"+"\t"+"结束"+"\t"+"周转时间"+"\t");
            for (int i = 0; i < m_pcb.Length; i++)
            {
                Console.WriteLine(m_pcb[i].name + "\t" + m_pcb[i].TimeComing+"\t"+m_pcb[i].TimeServer
                    + "\t" + m_pcb[i].TimeBegin + "\t" + m_pcb[i].TimeEnd
                    + "\t" + m_pcb[i].TimeCycle);
            }
        }
        /// <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);
                 }
            }
           
        }
        /// <summary>
        /// 第二种方法
        /// </summary>
        /// <param name="m_pcb"></param>
        private void DRZ(ref pcb[] m_pcb)
        {
            Time(ref m_pcb);  //数据输入函数
            int n = 0; //保存小赖的服务的索引
            for (int j = 0; j < m_pcb.Length; j++)
            {
                n = RYWZ(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);
                }
            }
        }
        /// <summary>
        /// 数据输入函数
        /// </summary>
        /// <param name="m_pcb"></param>
        public void Time(ref pcb[] m_pcb)
        {
            for (int i = 0; i < m_pcb.Length; i++)
            {
                int m = i + 1;
                Console.WriteLine("输入第" + m + "个进程名称、到达时间、服务时间");
                m_pcb[i].name = Console.ReadLine(); // 输入进程名
                m_pcb[i].TimeComing = int.Parse(Console.ReadLine()); // 输入进程到达时间
                m_pcb[i].TimeServer = int.Parse(Console.ReadLine()); // 输入进程服务时间
            }
            Console.Clear();
        }
        /// <summary>
        /// 求任意任务 且最多10个同时运行
        /// </summary>
        /// <param name="m_pcb">进程控制块信息数组</param>
        /// <returns></returns>
        private int RYRW(ref pcb[] m_pcb)
        {
            int n = 0;
            int m = 1000;//设置最大服务时间1000个单位
            for (int j = 0; j < m_pcb.Length; j++)
            {
                if (m >= m_pcb[j].TimeComing&&!m_pcb[j].finish)
                {
                    m = m_pcb[j].TimeComing;
                    n = j;
                }
            }
                 return n;
        }
        /// <summary>
        /// 求任意任务且运行的任务位置以固定 任务完成其他任务顶替完成任务的位置
        /// 最多10个任务同时运行
        /// </summary>
        /// <param name="m_pcb"></param>
        /// <returns></returns>

        private int RYWZ(ref pcb[] m_pcb)
        {
            int n = 0;
            int p = 1000; //设置最大服务时间1000个单位
              for (int j = 0; j < m_pcb.Length; j++)
            {
                if (p >= m_pcb[j].TimeComing&&!m_pcb[j].finish)
                {
                    p = m_pcb[j].TimeComing;
                    n = j;
                }
            }
                 return n;
        
        }
    }

}

最好第二种方法可以设置位置后边的执行职能插入到前面的进程的位置执行

[sdkl100]

[xuguv]

学习，帮顶。等大神来。

[sdkl100]

麻烦大神吃完饭了帮忙调试调试

[本拉灯]

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

[娃都会打酱油了]

你这个不就是分布式计算么。。。。 你是确认要一个进程多个线程同时计算 还是多个进程同时计算，同时多个进程的话那涉及进程间的通信，比上面一个复杂的多的多了

[sdkl100]

[wg5945]

以前用过个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;
        }
    }
}

[sdkl100]

[sdkl100]

求大神帮忙将代码拆开做成多线程的

[wg5945]

兄弟，你太有恒心了，小弟佩服~~ 再帮你随便写点，你自己再改改吧~~

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个线程先一起跑，都跑完了之后，后面一个接着一个跑，每个的线程的终止值设的随机数~~

[sdkl100]

引用 43 楼 wg5945 的回复:

兄弟，你太有恒心了，小弟佩服~~ 再帮你随便写点，你自己再改改吧~~

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个线程先一起跑，都跑完了之后，后面一个接着一个跑，每个的线程的终止值设的随机数~~

恩我试着用这个改成我用的那种吧 学了10天C#了 不努力也行啊 真不会

[sdkl100]

谁能再帮我想想第二种方法的插队应该用什么方法啊 需要看看哪一块的资料

[wg5945]

引用 51 楼 u013501312 的回复:

现在这10个就是 前五个的位置由后五个去填充 但是也要带着数据去填充不能光改下名称

怎么说呢，我觉得你还是理解一下我前面写的src吧~~ 你这句话说的我感觉我前面的都白写了~~ 你的需求大致就是对TaskList的一些排序，过滤处理~~ 我也没兴趣再写了~~

[sdkl100]

没白写 第一种除了完成顺序我还没写出来其他基本都出来了 第二个是根据下标换位置我在想怎么调换下标

[sdkl100]

谁能再帮我想想第二种方法的插队应该用什么方法啊 需要看看哪一块的资料 谢谢楼上的大神们 太给力了

[wg5945]

引用 48 楼 u013501312 的回复:

谁能再帮我想想第二种方法的插队应该用什么方法啊 需要看看哪一块的资料 谢谢楼上的大神们 太给力了

你所谓的第二种有什么区别么？ 你的意思是前面的完成了，要在页面显示上删掉，然后把后面那个显示到之前那个被删掉的位置上，仅仅就是为了让你能看出后面的是“插”到前面来了？

[sdkl100]

引用 49 楼 wg5945 的回复:

[quote=引用 48 楼 u013501312 的回复:] 谁能再帮我想想第二种方法的插队应该用什么方法啊 需要看看哪一块的资料 谢谢楼上的大神们 太给力了

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

[sdkl100]

现在这10个就是 前五个的位置由后五个去填充 但是也要带着数据去填充不能光改下名称

[sdkl100]

[sdkl100]