精华内容
下载资源
问答
  • C# 网络编程之套编程基础知识

    千次阅读 2013-07-13 22:08:28
    最近阅读了周存杰编写的《C#网络编程实例教程》并阅读了很多相关方面的资料,同时自己也做了一些套编程方面的C#...套字(Winsock)是一种独立于协议的网络编程接口,OSI中集中会话层和传输层 (补充知识) 简单

          最近阅读了周存杰编写的《C#网络编程实例教程》并阅读了很多相关方面的资料,同时自己也做了一些套接字编程方面的C#程序,所以根据它的知识总结了最近的套接字编程的一些知识点,方便自己的理解与他人的学习,同时也有一些自己以前学习的计算机网络、操作系统等相关知识。

    一.   套接字编程的概念

          套接字(Winsock)是一种独立于协议的网络编程接口,在OSI中集中在会话层和传输层。(补充知识)简单回归网络知识,计算机网络中的”五层协议的体系结构”和”OSI体系结构”如下图所示:

          其中它们每层实现的功能,构成的网络通信简单的示意图如下图所示:(“网际层”对应”网络层”,”网络接口层”对应底层的”数据链路层+物理层”)

          TCP/IP协议的第一个BSD UNIX提供了一个访问通信协议的调用——Socker。Socket类提供了对套接字的支持,提供了一整套属性和方法实现对端口的绑定、监听、连接、数据传输,其中套接字编程接口使用的命名空间为System.Net.Sockets

          (补充知识).Net网络中常用的类如下所示:
          Socket:实现构造一个新的套接字接口对象
          Dns:提供简单的域名解析功能
          IPAddress:提供网际协议(IP)地址的支持,其方法含定义获取主机的IP地址
          IPEndPoint:将网络端点表示为IP地址和端口号
          IPHostEntry:为网络主机地址信息提供容器类,构造一个主机对象
          NetworkStream:提供用于网络访问的基础数据流
          TcpLinster:从TCP网络客户端监听连接
          TcpClient:为TCP网络服务提供客户端连接
          UdpClient:提供用户数据报(UDP)网络服务

    二.Socket类属性

          Socket类常见属性如下所示:
          AddressFamily:定义套接字地址家族,常见的为InterNetwork
          Available:获取从网络已接受到的且可以读取的数据量的大小,存放网络缓冲区中还未处理的数据的大小
          Blocking:决定是否是套接字工作在阻塞模式,默认为False
          Connected:获取套接字是否连接成功的信息,True为连接成功,False为连接失败
          Handle:获取操作系统句柄
          LocalEndPoint:获取本地终端的信息
          ProtocolType:定义套接字使用的协议的类型,常见的为Tcp
          RemoteEndPoint:远程终端信息
          SocketType:定义套接字类型,数据流或数据包

          (补充知识)在网络编程中常使用的两种方法,socket类亦支持该两种基本模式——同步和异步。
          同步:对执行网络操作的函数的调用一只等到操作完成后才将控制返回给调用程序;
          异步:网络操作的函数调用立即返回。
          同步方法调用在程序继续执行之前需要等待同步方法执行完毕返回结果,异步方法则在被调用之后立即返回以便程序在被调用方法完成其任务的同时执行其它操作。
    因为同步方法调用会导致程序流程中途等待,所以采用同步方法的情况下往往会导致程序执行的延迟,相比来说。在某些条件下选择异步方法调用就可能更好一些。

          举个例子:(引用别人的例子http://zhidao.baidu.com/question/97924815.html
          Socket传输中拿TCP传输为例。假设服务器A客户机B进行通信传输。
          首先需要在A机建立监听线程。监听某一端口,那么B机可以向A机发送通讯请求,B机连接到A机以后。A机可以从他的监听队列中取的一个监听对象。在A端拿到了这个Socket对象就可以进行接收跟发送数据了。这里问题就出现了。假如B端在请求A端的时候请求成功就发送一条数据。那么 A端就可以直接拿Socket对象得到他的信息。但是假如B端并没有在连接成功后直接发送信息而是在后来不确定的时间这内发送的信息。那么A端就无法得到这条信息。通常的做法是用一个定时器去不短的扫描这个数据缓存区。看是不是有数据存在这样效率非常低下。那么如何解决这个问题呢。
          就用到了我们的异步传输。异步传输的原理是:在A端得到这个SOCKET对象以后并不是直接去接收数据而是建立一个回调函数。回调函数是由系统维护的。他在指定的时间自动去扫描数据存储区。假如有数据他就把数据存储到指定的字节数组中,不用用户自己去关心。

    三.Socket编程常用方法

    这里主要介绍几种常用的套接字编程方法:

    1.构造方法
    构造一个新的套接字对象,该方法调用时前面须添加new,返回值为套接字对象实例.
    public Socket(
        AddressFamilyaddressFamily, //网络类型
        SocketTypesocketType,           //套接字类型
        ProtocolTypeprotocolType);     //使用的协议
    )

    2.Bind()方法
    绑定特殊端口用于监听
    public void Bind(EndPoint loadEP) //本地主机,如IPEndPoint对象

    3.Listen()方法
    该方法用于监听端口
    public void Listen(int bcaklog)  //最大可处理的连接数

    4.Accept()方法
    该方法用于决定套接字的状态,用于新建一个套接字处理新建的连接
    public Socket Accept()    //返回值为新的套接字对象实例

    5.BeginAccpet()和EndAccept()方法
    该方法用于异步处理连接请求,与Accept()方法区别是Accept()立即处理连接请求,它是异步处理.
    public IAsyncResult BeginAccept(
    AsyncCallBack callback,  //异步回调
    objecet state  //自定义对象
    )
    EndAccpet()用于结束一个处理异步连接请求和BeginAccept()方法配合使用.
    public socket EndAccept(IAsynResult asyncResult)  //为处理的套接字请求,即BeginAccept()方法的请求.

          由于作者还在学习当中,还有很多方法,下面只提供方法名,具体的方法参数自己再去查找.包括Connect()、BeginConnect()\EndConnect()、Close()、send()、BeginSend()\EndSend()、SendTo()、BeginSendTo()\EndSendTo()、Receive()、BeginReceive()\EndReceive()、ReceiveFrom()、GetSocketOption()等方法.

    四.总结

          上面的叙述就是我最近学习的C#网络编程关于套接字的一些基础知识的理解,其中主要的内容是根据阅读的书。同时参考了一些网上资料及自己学过的网络知识和操作系统知识,这篇总结对我以后的网络编程的学习很有帮组,希望也能帮组大家。同时如果有错误或不足之处,希望大家原谅!最后感谢我看的周存杰同志编写《C#网络编程实例教程》书籍。

        (BY:Eastmount 2013-7-13-夜10点http://blog.csdn.net/eastmount/

     

     

     

    展开全文
  • TI-RTOS多任务编程

    2020-03-21 21:04:41
    本文主要叙述如何进行多任务编程,以及我在编程中遇到的一些不解。 Task组成部分:任务函数,任务参数(属性),任务堆栈. 实际上Task是sys/bios提供的一种并发编程手段,和我们常见到的线程是一个道理。 Task...

    最近在做一些关于一些驱动向TI板子的移植集成的事情,涉及操作系统为RTOS实时操作系统,在这里简单的记录一下。本文主要叙述如何进行多任务的编程,以及我在编程中遇到的一些不解。

    1. Task组成部分:任务函数,任务参数(属性),任务堆栈.
    实际上Task是sys/bios提供的一种并发编程手段,也是实时操作系统必备要素之一,
    和我们常见到的线程是一个道理,换了个说法。
    
    1. Task类型:硬中断HWI,软中断SWI,任务Task,空闲任务IDLE.
    2. 优先级排列:硬中断HWI>软中断SWI>任务Task>空闲任务IDLE.
    举个例子:
    同时存在四种任务,优先处理硬中断;
    如果只存在一种类型任务,优先处理该类型中优先级高的任务;
    如果只存在一种类型任务,且优先级相同,任务调度取决于系统调度程序;
    (特殊情况除外)
    
    1. 四种类型任务释义
    硬中断:实时环境中,它是响应外部触发的异步事件(中断)-----优先级不由sys/bios管理,由cpu的特性决定。
    虽然优先级最高,当然也可以被中断。
    
    软中断:软件中断服务例程 ------优先级可以达到 32 级,默认只有 16 级。
    SWI 可以被更高优先级的 SWI 和 HWI 抢占,但是 SWI 是不会阻塞的。
    
    任务:用户任务,运行过程中,可以被阻塞直到必要的资源可用;
    TASK 要求每个任务要有自己独立的栈空间。
    SYS/BIOS 提供了一些机制用于 TASK 间的同步和通信,它们有信号量(Semphore),事件(Events),队列(Queue)和邮箱(Mailboxes)。
    优先级也可以达到 32 级,默认是 16 级。
    Task 优先级数值越大,其优先级就越高,0 是优先级最低的。Task_setPri 函数动态的更改。新的优先级必须在 1 到 TnumPriorities – 1 之间。当新优先级数低于当前优先级时,可能会发生任务的切换。
    
    空闲任务:优先级最低的任务。
    当 SYS/BIOS 没有比空闲任务更高的任务运行时,SYS/BIOS 就会执行空闲任务,并且是连续执行,直到有更高的任务进入就绪状态。
    其运行在Task任务 0 优先级上。
    
    1. 创建一个task过程:
    #include <app.h>
    #include <utils/console_io/include/app_log.h>
    #include <xdc/runtime/Error.h>
    #include <ti/sysbios/BIOS.h>
    #include <ti/sysbios/knl/Task.h>
    #include <app_ipc_rsctable.h>
    
    static Void appMain(UArg arg0, UArg arg1){   //任务函数
    	//do something
    	printf("this is thread function\n");
    } 
    
    void StartupEmulatorWaitFxn (void){
        volatile uint32_t enableDebug = 0;
        do{
        }while (enableDebug);
    }
    
    static uint8_t gTskStackMain[4*1024]                 //任务使用的栈空间
    __attribute__ ((section(".bss:taskStackSection")))
    __attribute__ ((aligned(4096)))
    ;
    
    int main(void)
    {
        Task_Params tskParams;
        Error_Block eb;
        Task_Handle task;
        /* This is for debug purpose - see the description of function header */
        StartupEmulatorWaitFxn();
        Error_init(&eb);
        Task_Params_init(&tskParams);
    
        tskParams.arg0 = (UArg) NULL;
        tskParams.arg1 = (UArg) NULL;
        tskParams.priority = 10u;                //指定任务优先级
        tskParams.stack = gTskStackMain;         //指定任务使用的堆栈
        tskParams.stackSize = 4096;              //指定堆栈的大小
        task = Task_create(appMain, &tskParams, &eb); //动态创建一个task
        /*
    		You can continue to create other tasks from here......
    	*/
        if(NULL == task){
            BIOS_exit(0);
        }
        BIOS_start();                  //运行到这里程序不会退出,相当于是个死循环,操作系统将会调度执行任务
        return 0;
    }
    
    
    1. SDK版本以及引用路径
    /psdk_rtos_auto_j7_06_01_00_15/bios_6_76_03_01/packages/ti/sysbios/knl
    
    1. 如何在程序中获取任务的信息以及状态
    // bios_6_76_03_01/packages/ti/sysbios/knl/Task.h:105:struct  ti_sysbios_knl_Task_Stat ; 任务信息声明处
    //解释几个我用到的成员:
    struct ti_sysbios_knl_Task_Stat {
          xdc_Int priority;    //优先级
          xdc_Ptr stack;        //使用的堆栈地址
          xdc_SizeT stackSize;  //使用的堆栈的大小
          xdc_runtime_IHeap_Handle stackHeap;
          xdc_Ptr env;
          ti_sysbios_knl_Task_Mode mode;//休眠态,就绪态,运行态,挂起态,被中断态
          xdc_Ptr sp;
          xdc_SizeT used;               //已经使用了的堆栈空间大小
     };
    

    如何在一个任务中动态获取当前任务的状态信息:

        Task_Stat statbuf;
        Task_stat(Task_self(),&statbuf);
        printf("In appMain task,stack buff used = %d\n",statbuf.used);//查看当前任务已经使用的
        printf("In appMain task,stack total size = %d\n",statbuf.stackSize);//查看当前任务分配的总stack
        printf("In appMain task,task priority =%d\n",statbuf.priority); //查看当前任务的优先级
    
    1. 关于任务堆栈
      大小:
      尽量使用自定义数组来充当任务执行时的堆栈,不要依靠于系统的堆栈,如果内存不足,将发生致命错误;
      关于给任务分配多大内存为合适,我查看了一些资料,有说到一个任务最少需要分配512个字节,这是理论值,或者说这个任务的函数是一个空函数,啥都不干,这512是用来满足上下文的保存的,不符合实际开发,如果条件允许,简单的函数给予2k,稍微复杂的给予4k.(具体值还请各位尝试,这里作为参考)
      注意:我这里是跑在R5F mcu2_0上的,和使用的SDK版本也有关系。

    对齐方式:(不添加对齐应该也可以运行)
    我理解cpu为了提高取指速率,需要进行内存对齐。
    一般而言,选择对齐数num * n = stackSize,其中n%2 == 0,num可能更满足要求,如
    static uint8_t TskStackMain[4*1024]
    attribute ((section(".bss:taskStackSection")))
    attribute ((aligned(4096)));

    这个我并没有找到官方的文档的来解释说明,仅仅作为一种猜测,当然不是凭空猜测,是经过实验的。

    1. 任务阻塞方式:

    Task_sleep():使用:Task_sleep(5300 / Clock_tickPeriod);// 延时5.3ms Clock_tickPeriod定义在ti/sysbios/knl/Clock.h

    Task_yield():使得任务主动让出自己的时间片

    Semaphore_pend():信号量,获取临界资源

    1. 同步方式
      信号量、邮箱、事件等,如需要可以参考官方文档。实际上原理和用法与多线程同步方式一个道理,只不过换了个名字罢了。

    最后说一下我的遇到一个很奇怪的现象:

    相同优先级的任务存在某一个任务一直运行,不释放cpu的现象,只好通过一些接口
    让他主动释放,并没有像我们平时接触到的,类似于时间片轮转?
    

    解答:
    该操作系统不会像我们平时使用的操作系统那样回去分时间片的调度任务,而是想上面描述的现象:

    1. 如果有n个相同优先级的任务,这几个任务中假如任务A正在使用CPU,并且没有遇到阻塞(Task_sleep(),挂起,Task_yield(),同步原语)等,他就会一直占用cpu,不会释放;
    2. 假如此时来有一个任务优先级较高的任务需要使用CPU,那么优先级高的就会一直使用CPU,直到高优先级任务执行完毕,或者被阻塞被挂起才会让优先级较低的使用CPU。
    展开全文
  • 编程实现计划任务

    千次阅读 2005-04-11 13:53:00
    这里实现的任务计划是可以自己编程,可以很灵活,时间的精度为一秒,而且不是通过轮询时间实现的,效率比较高,。你可以Windows 服务中写一个服务,用它来管理所有的计划任务逻辑。类库源代码如下

    在一些需要定时执行的任务时,比如:定时备份数据库,定时的获取网络数据等都需要计划任务。Window也有计划任务但是有很多的缺点,必须手动配置,而且部署起来也很麻烦,时间的精度为一分钟,只能对应用程序配置任务。这里实现的任务计划是可以自己编程,可以很灵活,时间的精度为一秒,而且不是通过轮询时间实现的,效率比较高,。你可以在Windows 服务中写一个服务,用它来管理所有的计划任务逻辑。

    类库源代码如下:
    /********************************************************************************************
    * (C)2003-2005 C2217 Studio
    *  保留所有权利

    *  文件名称:    task.cs
    *  文件ID:   
    *  编程语言:    C#
    *  文件说明:    实现计划任务的调度机制。可以实现多种任务调度机制(定义时间精确到秒):
    *       1.立即执行(一次)
    *       2.计划执行(一次,可定义任务开始执行的日期)
    *       3.立即执行(循环执行,多次)
    *       4.计划执行(循环执行,多次,可定义任务开始执行的日期)
    *       可以通过实现接口ISchedule 制定自己的执行计划
    *      
    * 当前版本:     1.0
    * 替换版本:  
    *
    * 作者:      邓杨均
    * EMail:     dyj057@gmail.com
    * 创建日期:     2005-4-8
    * 最后修改日期:    2005-4-8
    *
    *历史修改记录:

    ********************************************************************************************/
    using System;
    using System.Collections;
    using System.Threading;
    //using NUnit.Framework;

    namespace Ibms.Utility.Task
    {

     #region 任务计划接口和一些标准实现
     /// <summary>
     /// 计划的接口
     /// </summary>
     public interface ISchedule
     {
      /// <summary>
      /// 返回最初计划执行时间
      /// </summary>
      DateTime ExecutionTime
      {
       get;
       set;
      }
      
      /// <summary>
      /// 初始化执行时间于现在时间的时间刻度差
      /// </summary>
      long DueTime
      {
       get;
      }

      /// <summary>
      /// 循环的周期
      /// </summary>
      long Period
      {
       get;
      }

      
     }


     /// <summary>
     /// 计划立即执行任务
     /// </summary>
     public class ImmediateExecution:ISchedule
     {
      #region ISchedule 成员

      public DateTime ExecutionTime
      {
       get
       {
        // TODO:  添加 ImmediatelyShedule.ExecutionTime getter 实现
        return DateTime.Now;
       }
       set
       {
        ;
       }
      }

      public long DueTime
      {
       get
       {
        return 0;
       }
      }

      
      public long Period
      {
       get
       {
        // TODO:  添加 ImmediatelyShedule.Period getter 实现
        return Timeout.Infinite;
       }
      }

      #endregion
     }


     /// <summary>
     /// 计划在某一未来的时间执行一个操作一次,如果这个时间比现在的时间小,就变成了立即执行的方式
     /// </summary>
     public class ScheduleExecutionOnce:ISchedule
     {

      /// <summary>
      /// 构造函数
      /// </summary>
      /// <param name="schedule">计划开始执行的时间</param>
      public ScheduleExecutionOnce( DateTime schedule)
      {
       m_schedule = schedule;
      }

      private DateTime m_schedule;

      #region ISchedule 成员

      public DateTime ExecutionTime
      {
       get
       {
        // TODO:  添加 ScheduleExecutionOnce.ExecutionTime getter 实现
        return m_schedule;
       }
       set
       {
        m_schedule = value;
       }
      }


      /// <summary>
      /// 得到该计划还有多久才能运行
      /// </summary>
      public long DueTime
      {
       get
       {
        long ms=( m_schedule.Ticks- DateTime.Now.Ticks)/10000;

        if( ms < 0 ) ms=0;
        return  ms;
       }
      }


      public long Period
      {
       get
       {
        // TODO:  添加 ScheduleExecutionOnce.Period getter 实现
        return Timeout.Infinite;
       }
      }


      #endregion
     }


     /// <summary>
     /// 周期性的执行计划
     /// </summary>
     public class CycExecution:ISchedule
     {
      /// <summary>
      /// 构造函数,在一个将来时间开始运行
      /// </summary>
      /// <param name="shedule">计划执行的时间</param>
      /// <param name="period">周期时间</param>
      public CycExecution(DateTime shedule,TimeSpan period)
      {
       m_schedule = shedule;
       m_period = period;
      }

      /// <summary>
      /// 构造函数,马上开始运行
      /// </summary>
      /// <param name="period">周期时间</param>
      public CycExecution(TimeSpan period)
      {
       m_schedule = DateTime.Now;
       m_period = period;
      }

      private DateTime m_schedule;
      private TimeSpan m_period;

      #region ISchedule 成员

      public long DueTime
      {
       get
       {
        long ms=( m_schedule.Ticks- DateTime.Now.Ticks)/10000;

        if( ms < 0 ) ms=0;
        return  ms;
       }
      }

      public DateTime ExecutionTime
      {
       get
       {
        // TODO:  添加 CycExecution.ExecutionTime getter 实现
        return m_schedule;
       }
       set
       {
        m_schedule = value;
       }

      
      }
     
      public long Period
      {
       get
       {
        // TODO:  添加 CycExecution.Period getter 实现
        return m_period.Ticks/10000;
       }
      }

      #endregion

     }

     
     #endregion

     #region 任务实现
     /// <summary>
     /// 计划任务基类
     /// 启动的任务会在工作工作线程中完成,调用启动方法后会立即返回。
     ///
     /// 用法:
     /// (1)如果你要创建自己的任务,需要从这个类继承一个新类,然后重载Execute(object param)方法.
     /// 实现自己的任务,再把任务加入到任务管理中心来启动和停止。
     /// 比如:
     /// TaskCenter center = new TaskCenter();
     /// Task newTask = new Task( new ImmediateExecution());
     /// center.AddTask(newTask);
     /// center.StartAllTask();

     /// (2)直接把自己的任务写入TimerCallBack委托,然后生成一个Task类的实例,
     /// 设置它的Job和JobParam属性,再Start就可以启动该服务了。此时不能够再使用任务管理中心了。
     /// 比如:
     /// Task newTask = new Task( new ImmediateExecution());
     /// newTask.Job+= new TimerCallback(newTask.Execute);
     /// newTask.JobParam = "Test immedialte task"; //添加自己的参数
     /// newTask.Start();
     /// 
     /// </summary>
     public class Task
     {
      /// <summary>
      /// 构造函数
      /// </summary>
      /// <param name="schedule">为每个任务制定一个执行计划</param>
      public Task(ISchedule schedule)
      {
       if(schedule==null)
       {
        throw (new ArgumentNullException("schedule") );
       }

       m_schedule =schedule;
      }


      /// <summary>
      /// 启动任务
      /// </summary>
      public void Start()
      {
       //启动定时器
       m_timer = new Timer (m_execTask, m_param,m_schedule.DueTime ,m_schedule.Period);
      }


      /// <summary>
      /// 停止任务
      /// </summary>
      public void Stop()
      {
       //停止定时器
       m_timer.Change(Timeout.Infinite,Timeout.Infinite);
       
      }


      /// <summary>
      /// 任务内容
      /// </summary>
      /// <param name="param">任务函数参数</param>
      public  virtual void Execute(object param)
      {
       //你需要重载该函数,但是需要在你的新函数中调用base.Execute();
       m_lastExecuteTime = DateTime.Now;

       if(m_schedule.Period == Timeout.Infinite)
       {
        m_nextExecuteTime = DateTime.MaxValue; //下次运行的时间不存在
       }
       else
       {
        TimeSpan period = new TimeSpan(m_schedule.Period * 1000);
     
        m_nextExecuteTime = m_lastExecuteTime +period;
       }
        
      }
      

      /// <summary>
      /// 任务下执行时间
      /// </summary>
      public DateTime NextExecuteTime
      {
       get
       {
        return m_nextExecuteTime;
       }
      }

      DateTime m_nextExecuteTime;
      /// <summary>
      /// 执行任务的计划
      /// </summary>
      public ISchedule Shedule
      {
       get
       {
        return m_schedule;
       } 
      }

      private ISchedule m_schedule;

      /// <summary>
      /// 系统定时器
      /// </summary>
      private Timer m_timer;
      
      /// <summary>
      /// 任务内容
      /// </summary>
      public TimerCallback Job
      {
       get
       {
        return m_execTask;
       }
       set
       {
        m_execTask= value;
       }
      }

      private TimerCallback m_execTask;

      /// <summary>
      /// 任务参数
      /// </summary>
      public object JobParam
      {
       set
       {
        m_param = value;
       }
      }
      private object m_param;

      /// <summary>
      /// 任务名称
      /// </summary>
      public string Name
      {
       get
       {
        return m_name;
       }
       set
       {
        m_name = value;
       }
      }
      private string m_name;
      
      
      /// <summary>
      /// 任务描述
      /// </summary>
      public string Description
      {
       get
       {
        return m_description;
       }
       set
       {
        m_description = value;
       }
      }
      private string m_description;

      /// <summary>
      /// 该任务最后一次执行的时间
      /// </summary>
      public DateTime LastExecuteTime
      {
       get
       {
        return m_lastExecuteTime;
       }
      }
      private DateTime m_lastExecuteTime;

      
     }

     #endregion

     #region 启动任务
     
     /// <summary>
     /// 任务管理中心
     /// 使用它可以管理一个或则多个同时运行的任务
     /// </summary>
     public class TaskCenter
     {
      /// <summary>
      /// 构造函数
      /// </summary>
      public TaskCenter()
      {
       m_scheduleTasks = new ArrayList();
      }

      /// <summary>
      /// 添加任务
      /// </summary>
      /// <param name="newTask">新任务</param>
      public void AddTask(Task newTask)
      {
       m_scheduleTasks.Add(newTask);
      }

      /// <summary>
      /// 删除任务
      /// </summary>
      /// <param name="delTask">将要删除的任务,你可能需要停止掉该任务</param>
      public void DelTask(Task delTask)
      {
       m_scheduleTasks.Remove(delTask);
      }

      /// <summary>
      /// 启动所有的任务
      /// </summary>
      public void StartAllTask()
      {
       foreach(Task task in ScheduleTasks)
       {
        StartTask(task);
       }
      }

      /// <summary>
      /// 启动一个任务
      /// </summary>
      /// <param name="task"></param>
      public void StartTask(Task task)
      {
       //标准启动方法
       if(task.Job == null)
       {
        task.Job+= new TimerCallback(task.Execute);
       }

       task.Start();
      }

      /// <summary>
      /// 终止所有的任务
      /// </summary>
      public void TerminateAllTask()
      {
       foreach(Task task in ScheduleTasks)
       {
        TerminateTask(task);
       }
      }

      /// <summary>
      /// 终止一个任务
      /// </summary>
      /// <param name="task"></param>
      public void TerminateTask(Task task)
      {
       task.Stop();
      }
      
      /// <summary>
      /// 获得所有的任务
      /// </summary>
      ArrayList ScheduleTasks
      {
       get
       {
        return m_scheduleTasks;
       }
      }
      private ArrayList m_scheduleTasks;

      /// <summary>
      /// 单元测试代码
      /// </summary>
      public  void TestTaskCenter()
      {
       TaskCenter center = new TaskCenter();

       //Test immedialte task
       Task newTask = new Task( new ImmediateExecution());
       newTask.Job+= new TimerCallback(newTask.Execute);
       newTask.JobParam = "Test immedialte task";

       //Test excute once task
       DateTime sheduleTime = DateTime.Now.AddSeconds(10);
     
       ScheduleExecutionOnce future= new ScheduleExecutionOnce(sheduleTime);

       Task sheduleTask = new Task( future);
       sheduleTask.Job+= new TimerCallback(sheduleTask.Execute);
       sheduleTask.JobParam = "Test excute once task";
       
       //Test cyc task at once

       CycExecution cyc = new CycExecution( new TimeSpan(0,0,2));
       Task cysTask = new Task(cyc);
       
       cysTask.Job+= new TimerCallback(cysTask.Execute);
       cysTask.JobParam = "Test cyc task";

       //Test cys task at schedule

       CycExecution cycShedule = new CycExecution( DateTime.Now.AddSeconds(8),new TimeSpan(0,0,2));

       Task cycSheduleTask = new Task(cycShedule);
       
       cycSheduleTask.Job+= new TimerCallback(cysTask.Execute);
       cycSheduleTask.JobParam = "Test cyc Shedule task";


       center.AddTask(newTask);
       center.AddTask(sheduleTask);
       center.AddTask(cysTask);

       center.AddTask(cycSheduleTask);

       center.StartAllTask();

       Console.ReadLine();

       Console.WriteLine(newTask.LastExecuteTime);
      }
     }

     #endregion
    }


    测试代码:
    using System;
    using System.Threading;


    namespace Ibms.Utility.Task.Test
    {
     /// <summary>
     /// 解释怎么创建自己的任务类,和使用它们
     /// </summary>
     class TestTask:Ibms.Utility.Task.Task
     {
      public TestTask(ISchedule schedule)
       :base(schedule)
      {
       
      }

      public override void Execute(object param)
      {
       //一定要保留
       base.Execute (param);

       Console.WriteLine("Begin to execute a long job...NextExecuteTime:{0}",this.NextExecuteTime);

       Thread.Sleep(5000);
       
       Console.WriteLine("Test Tast execute job.Last ExecuteTime {0}, ",
        this.LastExecuteTime
        );

       

      }

      /// <summary>
      /// 应用程序的主入口点。
      /// </summary>
      [STAThread]
      static void Main(string[] args)
      {
       //
       // TODO: 在此处添加代码以启动应用程序
       //
       
       TaskCenter center = new TaskCenter();

       //Test immedialte task
       Task newTask = new TestTask( new ImmediateExecution());
       newTask.JobParam = "Test immedialte task";

       //Test excute once task
       DateTime sheduleTime = DateTime.Now.AddSeconds(10);
       ScheduleExecutionOnce future= new ScheduleExecutionOnce(sheduleTime);
       Task sheduleTask = new TestTask(future);
       sheduleTask.JobParam = "Test excute once task";
       
       //Test cyc task at once
       CycExecution cyc = new CycExecution( new TimeSpan(0,0,2));
       Task cysTask = new TestTask(cyc);
       cysTask.JobParam = "Test cyc task";

       //Test cys task at schedule
       CycExecution cycShedule = new CycExecution( DateTime.Now.AddSeconds(8),new TimeSpan(0,0,2));
       Task cycSheduleTask = new TestTask(cycShedule);
       cycSheduleTask.JobParam = "Test cyc Shedule task";


       center.AddTask(newTask);
       center.AddTask(sheduleTask);
       center.AddTask(cysTask);
       center.AddTask(cycSheduleTask);

       center.StartAllTask();

       Console.ReadLine();
       
       Console.WriteLine("terminate all task");

       center.TerminateAllTask();
       
       Console.ReadLine();

      }

     }
    }

    展开全文
  • 任务并行编程模型

    千次阅读 2013-07-08 14:26:07
    来自文章《任务并行编程模型研究与进展》---软件学报  并行编程模型是底层体系结构与上层应用程序之间的桥梁, 向上隐藏并行处理器的细节, 提供给程序员并行表达的方法; 向下充分利用硬件资源、高效且正确地完成...

    来自文章《任务并行编程模型研究与进展》---软件学报

           并行编程模型是底层体系结构与上层应用程序之间的桥梁, 向上隐藏并行处理器的细节, 提供给程序员并行表达的方法; 向下充分利用硬件资源、高效且正确地完成应用需求. 任务划分、任务映射、数据分布、通信和同步是设计并行编程模型时需要考虑的 5 个关键要素。任务并行编程模型主要关注共享存储的平台, 数据分为共享和私有两种存储属性, 通过共享数据进行通信. 因此, 该编程模型的研究重点是任务划分、任务映射和同步这个关键要素.

           任务并行编程模型把任务作为并行的基本单位, 提供任务划分和同步的编程接口, 把任务划分和同步工作交给程序员完成, 用户可以把应用程序划分出大量细粒度任务. 然而, 具体到每个任务到底并行执行还是串行执行、在哪个物理核上执行以及如何实现任务之间的同步则由运行时系统完成. 任务并行编程模型提倡嵌套的递归任务, 并引入以任务窃取为核心的用户级线程调度, 实现程序的高性能和动态的负载平衡.

    展开全文
  • Java并行编程–从并行任务集获取反馈

    千次阅读 多人点赞 2012-04-01 12:53:24
    Java并行编程–从并行任务集获取反馈并行任务启动后,强制性地从并行任务得到反馈。假想有一个程序,可以发送批邮件,还使用了多线程机制。你想知道有多少邮件成功发送吗?你想知道实际发送过程期间,这个批处理...
  • 任务的概念人们已经非常熟悉了,它是指用户可以同一时间内运行多个应用程序。Linux就是一种支持多任务的操作系统,它支持多进程、多线程等多任务处理和任务之间的多种通信机制。 Linux下多任务机制的介绍 多...
  • Node.js中使用TCP套编程

    千次阅读 2014-01-26 12:00:05
    Node.js中使用TCP套编程 译自[http://www.hacksparrow.com/tcp-socket-programming-in-node-js.html][1] 想知道如何NodeJS中使用socket编程NodeJS中有三种socket:1. TCP,2. UDP,3. Unix域套...
  • windows任务栏图标编程步骤

    千次阅读 2009-05-12 16:47:00
    windows任务栏图标编程步骤Ligo,2009.5.12windows任务栏中加载图标,其步骤非常简单,关键的就是一个函数:Shell_NotifyIcon()此API函数有三个功能:把图标放入任务栏、更换放入任务栏中的图标、删除任务栏中的...
  • Tcp编程下的多线程任务

    千次阅读 2016-11-08 17:30:54
    Tcp编程下的多线程任务标签(空格分隔): tcp 多线程 TCP通信为毛要引入多线程?基本 TCP 响应服务器一次只能处理一个客户端的请求。当一个客户端向一个已经被其他客户端占用的服务器发送连接请求时,虽然其连接...
  • vxWorks多任务编程初探-下

    千次阅读 多人点赞 2011-07-08 10:39:28
    当一个任务要进入资源,首先要得到一个信号量(take that semaphore),只要有任务在使用这个信号量,其它的要进入资源的任务要停止执行(blocked from execution),当这个任务完成了对资源的使用,它会释放信号量...
  • 编程其实跟进程间通信有一定的相似性,可能也正因为此,stevens这位大神才会将套编程与进程间的通信都归为“网络编程”,并分别写成了两本书《UNP1》《UNP2》。TCP套编程是套编程中非常重要的一种...
  • RTOS环境下多任务编程要点

    千次阅读 2014-04-05 17:39:53
    RTOS环境下多任务编程要点 一. 分析阶段 1. 需求分析,予以文档描述; 2. 一些初始化问题,探究需求分析中的关键点; 3. 解决时序问题,系统中算法的分析; 4. 决定使用RTOS,依赖于时间响应和任务数量;...
  • 今天来讲学习的知识应用于实战编程:利用已搭建好的仿真工作站和机器人系统,建立好例行程序后,编写机器人程序,完成机器人从A0到A1点,经过A2点到达A3点,最后回到A0点这样的运动过程。其中P0点作为机器人运动...
  • MySQL编程接口学习

    千次阅读 2013-10-12 17:04:24
    之前有记下过关于MySQL的一些笔记《MySQL必知必会》摘录 以下是《MySQL技术内幕》的一些笔记 ...为解决这类问题,MySQL服务器特意准备了一个客户端API(Application Programming Interface,应用程序编程接
  • IASyncResult接口实现简单异步编程

    千次阅读 2017-12-22 13:56:47
    我有一个梦想,是改变世界,这是很多技术人员的梦想;从小事做起,踏实做人...1、异步编程是建立委托基础上的编程方法 2、异步调用的每个方法都是独立线程中执行的,因此本质上就是一种多线程程序。 3、比较适
  • 你好呀,我是沉默王二,一个和...本篇文章就打算通过我和三妹对话的形式来聊一聊“Spring 的 Aware、异步编程、计划任务”。 教妹学 Spring,没见过这么放肆的标题吧?“语不惊人死不休”,没错,本篇文章的标题...
  • VB6中的任务栏图标编程

    千次阅读 2004-06-24 10:02:00
    VB6中的任务栏图标编程 杨山河 Windows 9X的桌面任务栏显示了当前正在运行的任务,并且右下角的任务栏图标提供了快速访问对于当前不可见的任务。我们的鼠标单击或双击动作都通过任务栏转发给相应的窗口,哪怕该应用...
  • vxWorks多任务编程初探-上

    千次阅读 多人点赞 2011-07-08 10:35:51
    进程(Process)是具有一定独立功能的程序关于某个数据集合上的一次运行活动,是系统进行资源分配和调度的一个独立单位...而进程则不同,它是程序某个数据集上的执行,是一个动态实体。它因创建而产生,因调度而运行
  • Verilog 语言提供r 一组标准的系统任务和函数, 参见附录 C 设计时,经常会遇到一些特殊的情况,需要通过定义自己的系统任务和函数才能实现设计目标 为了做到这一点,设计者需要与表示设计的内部数据结构以及 ...
  • 并发编程面试题(2020最新版)

    万次阅读 多人点赞 2020-03-14 17:28:01
    文章目录基础知识并发编程的优缺点为什么要使用并发编程(并发编程的优点)并发编程有什么缺点并发编程三要素是什么? Java 程序中怎么保证多线程的运行安全?并行和并发有什么区别?什么是多线程,多线程的优劣?...
  • PHP套编程(socket)

    千次阅读 2004-11-03 17:13:00
    特别的web应用程序开发中,常用perl实现套字。除此以外,用php进行套编程也是一个选择。Php可以胜任吗?当然可以。Php是一门高质量的web应用程序开发语言,他的许多特性可以处理众多的任务,网络编程也不...
  • C#并行编程(4):基于任务的并行

    万次阅读 2019-04-13 08:44:58
    C#编程中,实现并行可以直接使用线程,但使用起来很繁琐;也可以使用线程池,线程池很大程度上简化了线程的使用,但是也有着一些局限,比如我们不知道作业什么时候完成,也取不到作业的返回值;解决线程池局限性的...
  • Linux下多任务介绍  首先,先简单的介绍一下什么叫多任务系统?任务、进程、线程分别是什么?它们之间的区别是什么?,从而可以宏观的了解一下这三者,然后再针对每一个仔细的讲解。  什么叫多任务系统?多任务...
  • 我今天要讲的是如何任务提交到线程池后取消正在运行的任务? 有线程池编程经验的朋友可能第一反应就是利用Future.cancel(boolean)方法。这个方法确实可以取消任务,但这个方法有一个缺陷。当任务队列中没有...
  • unp第三章主要介绍了基本套编程函数。主要有:socket(),bind(),connect(),accept(),listen()等。 本博文也直接进入正题,对这几个函数进行剖析和讲解。 1. 基本套字函数《计算机网络》和《TCP/IP详解》中...
  • 【博文汇总】linux下多任务编程

    千次阅读 2013-11-27 08:52:13
    【博文汇总】linux下多任务编程 [Linux的多任务编程-基本概念]介绍了多任务处理的基本知识,主要讲解了基于进程和线程实现多任务处理的不同特点和区别.基于进程的多任务编程 [Linux的多任务编程-进程]介绍了进程的...
  • 记得之前做过学校的一个实验,是关于多线程套编程地,那次实验中,我们采用了如下的代码: ServerSocket server = new ServerSocket(80); while(true){ //新建线程 new Thread(xxx).start; } 上方...
  • 这个编程作业中,你将用Python语言开发一个简单的Web服务器,它仅能处理一个请求。具体而言,你的Web服务器将: 当一个客户(浏览器)联系时创建一个连接套字; 从这个连接套字接收HTTP请求; 解释该请求以...
  • 本部分就来看一下Spring框架封装下的多线程编程。因为毕竟是被Spring封装过的异步并发编程,所以用起来还是蛮简单的。主要还是ThreadPoolTaskExecutor的使用。下方会给出Spring框架中多线程编程的小示例。   ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 490,720
精华内容 196,288
热门标签
关键字:

在哪里接编程任务