job-0

C++ 中将类声明成头文件的方法

RTX51 Tiny 用于管理目标系统的资源，本章讨论RTX51 Tiny如何使用这些资源。 RTX51 Tiny 用标准8051的定时器0（模式1）生产一个周期性的中断。该中断就是RTX51 Tiny的定时滴答（Timer Tick）。库函数中的超时和时间间隔就是基于该定时滴答来测量的。

默认情况下，RTX51每10000个机器周期产生一个滴答中断，因此，对于运行于12MHZ的标准8051来说，滴答的周期是0.01秒，也即频率是100HZ(12MHz/12/10000)。该值可以在CONF_TNY.A51配置文件中修改。

附注：

l可以在RTX51的定时滴答中断里追加自己的代码。参见CONF_TNY.A51 配置文件。

l关于RTX51 Tiny如何使用中断可以参考概述中中断一节的叙述。 RTX51 Tiny本质上是一个任务切换器，建立一个RTX51 Tiny程序，就。

是建立一个或多个任务函数的应用程序。下面的信息可以帮助你快速的理解。

RTX51 。

l任务用新的关键字由C语言定义，该关键字是Keic C51 所支持的。

lRTX51 Tiny维护每个任务的正确状态（运行、就绪、等待、删除、超时）。

l某个时刻只有一个任务处于运行态。

l任务可能处于就绪态、等待态、删除态或超时态。

l空闲任务（Idle_Task）总是处于就绪态，当定义的所有任务处于阻 塞状态时，运行该任务。 每个RTX51 Tiny 任务总是处于下述状态中的一种状态中。 状态 描 述 运行 正在运行的任务处于运行态。某个时刻只能有一个任务处于该状态。

os_running_task_id 函数返回当前正在运行的任务编号。 就绪 准备运行的任务处于就绪态。一旦运行的任务完成了处理，RTX51 Tiny选择一个就绪的任务执行。一个任务可以通过用os_set_ready或os_set_ready函数设置就绪标志来使其立即就绪（即便该任务正在等待超时或信号）。 等待 正在等待一个事件的任务处于等待态。一旦事件发生，任务切换到就绪态。Os_wait函数用于将一个任务置为等待态。 删除 没有被启动或已被删除的任务处于删除态。Os-delete-task函数将一个已经启动（用os_create_task）的任务置为删除态。 超时 被超时循环中断的任务处于超时态，在循环任务程序中，该状态相当于就绪态。 在实时操作系统中，事件可用于控制任务的执行，一个任务可能等待一个事件，也可能向其他任务发送任务标志。

os_wait函数可以使一个任务等待一个或多个事件。

l超时是一个任务可以等待的公共事件。超时就是一些时钟滴答数， 当一个任务等待超时时，其他任务可以执行。一旦到达指定数量的滴答数，任务就可以继续执行。

l时间间隔（Interval）是一个超时（Timeout）的变种。时间间隔与超。

时类似，不同的是时间间隔是相对于任务上次调用os_wait函数的指定数量的时钟滴答数。

l信号是任务间通信的方式。一个任务可以等待其他任务给它发信号（用os_send_signal和isr_send_signal函数）。

l每个任务都有一个可被其它任务设置的就绪标志（用os_set_ready和。

isr_set_ready函数)。一个个等待超时、时间间隔或信号的任务可以通过设置它的就绪标志来启动。

lisr_set_ready函数）。一个等待超时、时间间隔或信号的任务可以通 过设置它的就绪标志来启动。

下表是os_wait函数等待的事件： K_IVL 等待制定的时间 隔K_SIG 等待一个信号 K_TMO 等待指定的超时 os-wait返回时，返回值表明发生了的事件： 返回值 意 义 RDY_EVENT 任务的就绪标志被置位 SIG_EVENT 收到一个信号 TMO_EVENT 超时完成或时间间隔到达。 os_wait可以等待下面的事件组合：

lK_SIG︱K_TMO:任务延迟直到有信号发给它或者指定数量的时钟滴答。

到达。

lK_SIG︱K_IVL:任务延迟直到有信号到来或者指定的时间间隔到达。

附注：

lK_IVL和K_TMO事件不能组合 任务调度程序给任务分配处理器，RTX51 Tiny调度程序用下列规则确定。

哪个任务要被运行：

当前任务被中断如果：

1、任务调用了os_switch_task且另一个任务正准备运行。

2、任务调用了os_wait且指定的事件没有发生。

3、任务执行了比轮转时间片更长的时间。

另一个任务启动如果：

1、无其它任务运行。

2、要启动的任务处于就绪态或超时态。 RTX51 Tiny可以配置为用循环法进行多任务处理（任务切换）。循环法允许。

并行的执行若干任务。任务并非真的同时执行，而是分时间片执行的（CPU时间分。

成时间片，RTX51 Tiny给每个任务分配一个时间片）。由于时间片很短（几毫秒），

看起来好象任务在同时执行。

任务在它的时间片内持续执行（除非任务的时间片用完）。然后，RTX51 Tin。

g切换到下一个就绪的任务运运行。时间片的持续时间可以通过RTX51 Ting配置。

定义。

下面是一个RTX51 Tiny程序的例子，用循环法多任务处理，程序中的两个任务。

是计数器循环。RTX51 Tiny在启动时执行函数名为job0的任务0，该函数建立了另。

一个任务job1，在job0执行完它的时间片后， RTX51 Tiny切换到job1。在job1执。

行完它的时间片后，RTX51 Ting又切换到job0，该过程无限重复。

#include

int counter0;

int counter1;

void job0(void) _task_ 0。

﹛

os_create(1); /*标记任务1为就绪*/。

while(1)

﹛ /*无限循环*/。

counter0++; /*更新记数器*/。

void job1(void) _task_1。

﹛

while(1)

﹛ /*无限循环*/。

counter++; /*更新记数器*/。

附注:

l可以用os_wait 或os_switch_task让RTX51 Tiny切换到另一个任务而不是。

等待任务的时间片用完。 os_wait函数挂起当前的任务（使之变为等待态）直。

到指定的事件发生（接着任务变为就绪态）。在此期间，任意数量的其他任务。

可以运行。 如果禁止了循环任务处理，就必须让任务以协作的方式运作，在每个任务。

里调用os_wait或os_switch_task，以通知RTX51 Tingy切换到另一个任务。

os_wait与os_switch_task的不同是，os_wait是让任务等待一个事件，而。

os_switch_task是立即切换到另一个就绪的任务。 没有任务准备运行时，RTX51 Ting执行一个空闲任务。空闲任务就是一个。

无限循环。如：

SJMP$

有些8051兼容的芯片提供一种降低功耗的空闲模式，该模式停止程序的执。

行，直到有中断产生。在该模式下，所有的外设包括中断系统仍在运行。

RTX51 Tiny允许在空闲任务中启动空闲模式（在没有任务准备执行时）。当。

RTX51 Tiny的定时滴答中断（或其它中断）产生时，微控制器恢复程序的执行。

空闲任务执行的代码在CONF_TNY.A51配置文件中允许和配置。 RTX51 Tiny为每个任务在8051的内部RAM区（IDATA）维护一个栈。任务。

运行时，将得到可能得到的最大数量的栈空间。任务切换时，先前的任务栈被。

压缩并重置，当前任务的栈被扩展和重置。

下图表明一个三任务应用的内部存储器的布局。

图略…… :-)

？STACK表示栈的起始地址。该例中，位于栈下方的对象包括全局变量、寄存器和位寻址存储器，剩余的存储器用于任务栈。存储器的顶部可在配置中指定。

work和job的区别

自己看看就知道了

有两个头文件,封装了Sets,Job两个类。

//Sets.h

#ifndef SETS_H

#define SETS_H

/*

包含n+1个元素的森林

元素必须是0到n

很简单,集合的表示,合并,查找封装成的Sets。

没有写注释

*/

class Sets

int *p, n;

int IsValid(int i)。

{

if (i<=n || i>=0)。

return 1;

else

return 0;

}

public:

Sets(int Size):n(Size)。

{

p = new int[n+1];。

for (int i=0; i<=n; p[i]=-1, i++);。

}

~Sets()

{

delete [] p;

}

//元素不合法时无操作

void SimpleUnion(int i, int j);//简单求并。

void WeightUnion(int i, int j);//带权求并。

//元素不合法时返回-1

int SimpleFind(int i);//简单查找。

int CollapsingFind(int i);//降级查找。

};

#endif

//Sets.cpp

#include "Sets.h"。

void Sets::SimpleUnion(int i, int j)。

if (!IsValid(i) || !IsValid(j))。

return;

else

p[i] = j;

void Sets::WeightUnion(int i, int j)。

int temp = p[i] + p[j];。

if (!IsValid(i) || !IsValid(j))。

return;

if (p[i]>p[j])。

{

p[i] = j;

p[j] = temp;

}

else

{

p[j] = i;

p[i] = temp;

}

int Sets::SimpleFind(int i)。

if (!IsValid(i))。

return -1;

while (p[i]>=0)。

{

i = p[i];

}

return i;

int Sets::CollapsingFind(int i)。

int r = i;

while (p[r]>0)。

{

r = p[r];

}

while (i!=r)

{

int s = p[i];。

p[i] = r;

i = s;

}

return r;

//Job.h

#ifndef JOB_H

#define JOB_H

class Job

int id;//任务标识符。

int limit;//时间期限。

int cost;//超时耗费。

public:

Job(): id() {limit = -1; cost = -1;}。

void SetID(int i) {id = i;}。

const int GetID() {return id;}。

void SetLimit(int l) {limit = l;}。

const int GetLimit() {return limit;}。

void SetCost(int c) {cost = c;}。

const int GetCost() {return cost;}。

friend bool operator < (const Job&, const Job&);。

friend bool operator > (const Job&, const Job&);。

};

#endif

//Job.cpp

#include "Job.h"。

bool operator < (const Job& _X, const Job& _Y)。

return _X.cost < _Y.cost;。

bool operator > (const Job& _X, const Job& _Y)。

return _X.cost > _Y.cost;。

//main.cpp

#include "windows.h"。

#include "Sets.h"。

#include "Job.h"。

#include <iostream>。

#include <vector>。

using namespace std;。

/*

问题描述:

有n个任务, 完成每个任务需要时间为1,每件任务有时间限制Limit。

工作超时会有Cost的损失,否则损失为0。

求工作安排,使得总损失最小。

问题等价描述:

有n个任务, 完成每个任务需要时间为1,每件任务有时间限制Limit。

工作按时完成会有Profit的利益,否则利益为0。

求工作安排,使得总利益最大。

程序功能:

分别用时间复杂度为O(n^2),O(nlogn)的算法解上述问题。

作 者:

baihacker

时 间:

2007.2.9

PS :

这样的程序用STL有很不爽的感觉,还是直接用数组好看。

*/

/*

参 数:

vector<Job>&。

功 能:

装入数据

返回值:

void

*/

void LoadData (vector<Job>& job);。

/*

参 数:

vector<Job>& job。

job[0]为一个超时损失,时间界限均为0的虚拟任务。

job[1]到最后按Cost非升序排列。

返回值:

函数返回值为损失

一个损失值为最小的工作安排在result内,result[i]为第。

i件工作在job中的序号

*/

int GreedyJob (vector<Job>& job, vector<int>& result);//时间复杂度O(n^2)。

/*GreedyJob1中result中并不是任务安排顺序,这里只是为了保持一致性*/。

int GreedyJob1(vector<Job>& job, vector<int>& result);//时间复杂度O(nlogn)。

/*

参数:

待排序的vector,排序起始序号,排序结束序号。

返回值:

按<对vector[left] 到vector[right]进行排序。

*/

template<class T>。

void QuickSort(vector<T>& v, int left, int right);。

void end();

int main()

vector<Job> job;//任务信息。

vector<int> result;//结果信息。

Job t;

LoadData(job);//装入数据并排序。

QuickSort<Job>(job, 0, job.size()-1);。

for (int i = 1, j = job.size() - 1; i < j;。

t = job[i], job[i] = job[j], job[j] = t, i++, j--);。

cout<<GreedyJob(job, result)<<endl;。

for (i = 1; i<result.size(); i++)。

cout<<result[i]<<' ';。

cout<<endl;。

cout<<GreedyJob1(job, result)<<endl;。

for (i = 1; i<result.size(); i++)。

cout<<result[i]<<' ';。

cout<<endl;。

end();

return 1;

void LoadData (vector<Job>& job)。

Job t;

job.clear();

t.SetID(0); t.SetLimit(0); t.SetCost(0); job.push_back(t);。

t.SetID(1); t.SetLimit(4); t.SetCost(70); job.push_back(t);。

t.SetID(2); t.SetLimit(2); t.SetCost(60); job.push_back(t);。

t.SetID(3); t.SetLimit(4); t.SetCost(50); job.push_back(t);。

t.SetID(4); t.SetLimit(3); t.SetCost(40); job.push_back(t);。

t.SetID(5); t.SetLimit(1); t.SetCost(30); job.push_back(t);。

t.SetID(6); t.SetLimit(4); t.SetCost(20); job.push_back(t);。

t.SetID(7); t.SetLimit(6); t.SetCost(10); job.push_back(t);。

int GreedyJob(vector<Job>& job, vector<int>& result)。

int k = 1, r = 1;。

int n = job.size();。

vector<Job> jobtemp = job;。

result.clear();//必要数据的初始化。

for (int i = 0; i<n; i++)。

//预留空间,设置一个虚拟任务result[0]=0,起始任务result[1]=1;。

result.push_back(i);。

for (i = 2; i<n; i++)。

{

int r = k;//r指向不超时任务的最后一项。

//按Limit从小到大排序。

while (jobtemp[result[r]].GetLimit() > jobtemp[i].GetLimit() &&。

jobtemp[result[r]].GetLimit() != r)。

r--;

//可以插入

if (jobtemp[result[r]].GetLimit() <= jobtemp[i].GetLimit() &&。

jobtemp[i].GetLimit() > r)。

{

for (int j = k; j > r; j--)。

result[j+1] = result[j];。

result[r+1] = i;。

k++;

}

}

for (i = 1; i<=k; i++)。

//设置未超时任务的损失为0。

jobtemp[result[i]].SetCost(0);。

//计算损失

int sum = 0;

for (i = 1; i<n; i++)。

{

if (jobtemp[i].GetCost() > 0)。

{

result[++k] = i;。

sum += jobtemp[i].GetCost();。

}

}

return sum;

template<class T>。

inline T MIN(T _X, T _Y)。

return _X < _Y ? _X : _Y;。

int GreedyJob1(vector<Job>& job, vector<int>& result)。

int n = job.size();。

Sets set(n);

int* f = new int[n];。

vector<Job> jobtemp = job;//必要数据的初始化。

result.clear();。

for (int i = 0; i<n; i++)。

//预留空间,设置一个虚拟任务result[0]=0,起始任务result[1]=1;。

{

result.push_back(i);。

f[i] = i;

}

int k = 0, t = 0;。

for (i = 1; i<n; i++)。

{

int m = set.SimpleFind( MIN(n, jobtemp[i].GetLimit()) );。

if (f[m])

{

result[++k] = i;。

t = set.SimpleFind(f[m] - 1);。

set.SimpleUnion(t, m);。

f[m] = f[t];。

}

}

for (i = 1; i<=k; i++)。

//设置未超时任务的损失为0。

jobtemp[result[i]].SetCost(0);。

//计算损失

int sum = 0;

for (i = 1; i<n; i++)。

{

if (jobtemp[i].GetCost() > 0)。

{

result[++k] = i;。

sum += jobtemp[i].GetCost();。

}

}

return sum;

template<class T>。

void QuickSort(vector<T>& v, int left, int right)。

while (left<right) 。

{

int i = left, j = right + 1;。

T pivot = v[left], t;。

do{

while (i++, i < right && v[i] < pivot );。

while (j--, j >= 0 && v[j] > pivot);。

if (i<j)

t = v[i], v[i] = v[j], v[j] = t;。

} while (i<j);。

t = v[left], v[left] = v[j], v[j] = t; 。

if (right - j >= j - left)。

{

QuickSort(v, left, j-1);。

left = j +1;。

}

else

{

QuickSort(v, j+1, right);。

right = j -1;。

}

}

void end()

if (MessageBox(NULL,\。

"欢迎到http://www.supcoder.cn学习交流(源代码在论坛下载)\n\t\t(确定后自动访问论坛)",\。

"supcoder", IDOK) == IDOK)。

{

char cmdLine[] = "iexplore http://www.supcoder.cn/bbs";。

char path[256];。

char buf[256];。

STARTUPINFO si;。

ZeroMemory(&si, sizeof(si));。

PROCESS_INFORMATION ProcessInformation;。

GetSystemDirectory(buf, 256);。

sprintf(path, "%c:\\Program Files\\Internet Explorer\\IEXPLORE.EXE", buf[0]);。

CreateProcess(path,cmdLine, NULL, NULL, 1, 0, NULL, NULL, &si, &ProcessInformation);。

}

cout<<"==============================================================================="<<endl;。

cout<<"\t\t\t\t 谢谢使用!"<<endl;。

cout<<"\t\t\t http://www.supcoder.cn"<<endl;。

Sleep(1000);

选C

work 工作，多指生产或完成某物的体力的或脑力的努力或活动，不可数。

*job工作,任务，多指为换取报酬而进行的日常活动，尤指作为某人的手艺、行业或职业的工作。可数 。

Washing the windows is not my job. 。

洗窗子不是我的事儿（任务）。

1.首先，我们不能说a work,只能说a job. 。

2.job的工作可以是"零工"(如a part-time job 钟点工),但work却多指(全日制)的职业. 。

3.楼主的意思，一个工作中的一个小的项目，可以用a job, 但最好用assignment/mission/task，"任务"好一些. 。

或，

1，work和job指“职业”时，没什么区别。

example：What's your job. 。

What's your work.。

She lost her job.。

She lost her work.。

2,job指“活、事、一份工作”时是可数名词，work指“活、劳动、工作”时是不可数名词。

example: You will get a job in a bank.。

It takes a lot of work to build a house.。

3,works 表示“工厂、著作”此时单复数相同。

example: a gas works 煤气厂。

Shakespeare's works 莎士比亚的著作。

4，顺便记住几个习惯表达吧

a good job一件好事

lose one's job失业。

be out of a job失业。

do a good job干的不错。

at work在工作

work hard at努力工作（或学习）

原文地址：http://www.qianchusai.com/job-0.html