A. 一開機就出現這個
scheler - scheler.exe - 進程信息
進程文件： scheler 或者 scheler.exe
進程名稱： Leader PowerReg Scheler
描述：
scheler.exe是Leader技術公司相關產品，例如MicroProse、Iomega、PowerQuest等產品都會包括該進程。
出品者： Leader Technologies
屬於：Leader PowerReg Scheler
刪除軟體再重新安裝 就可以了
B. spring boot 集成quartz-job如何自動注入spring容器託管之後怎麼動態開啟定時器停
我們通過實現JobFactory 介面，在實例化Job以後，在通過ApplicationContext 將Job所需要的屬性注入即可
在Spring與Quartz集成時 用到的是org.springframework.scheling.quartz.SchelerFactoryBean這個類。源碼如下，我們只看最關鍵的地方。
// Get Scheler instance from SchelerFactory. try {
this.scheler = createScheler(schelerFactory, this.schelerName);
populateSchelerContext();
if (!this.jobFactorySet && !(this.scheler instanceof RemoteScheler)) {
// Use AdaptableJobFactory as default for a local Scheler, unless when // explicitly given a null value through the "jobFactory" bean property. this.jobFactory = new AdaptableJobFactory(); }
if (this.jobFactory != null) {
if (this.jobFactory instanceof SchelerContextAware) {
((SchelerContextAware) this.jobFactory).setSchelerContext(this.scheler.getContext());
}
this.scheler.setJobFactory(this.jobFactory);
}
}
C. golang底層用什麼語言實現的
Go runtime的調度器：
在了解Go的運行時的scheler之前，需要先了解為什麼需要它，因為我們可能會想，OS內核不是已經有一個線程scheler了嘛？
熟悉POSIX API的人都知道，POSIX的方案在很大程度上是對Unix process進場模型的一個邏輯描述和擴展，兩者有很多相似的地方。 Thread有自己的信號掩碼，CPU affinity等。但是很多特徵對於Go程序來說都是累贅。 尤其是context上下文切換的耗時。另一個原因是Go的垃圾回
D. uncode schele怎麼啟動
曾經和Uncode-Schele原作者冶衛軍有過交流，啟動方式可以拉最新版的代碼，址接以spring-boot方式啟動。具體路徑為：cn.uncode.schele.UncodeScheleApplication，運行起來後可以訪問：/unocde/schele後台頁面進行動態任務管理。以上供參考。
E. scheler start後能再調用schelejob嗎
第一步：引包
要使用Quartz，必須要引入以下這幾個包：
1、log4j-1.2.16
2、quartz-2.1.7
3、slf4j-api-1.6.1.jar
4、slf4j-log4j12-1.6.1.jar
這些包都在下載的Quartz包裡麵包含著，因此沒有必要為尋找這幾個包而頭疼。
第二步：創建要被定執行的任務類
這一步也很簡單，只需要創建一個實現了org.quartz.Job介面的類，並實現這個介面的唯一一個方法execute(JobExecutionContext arg0) throws JobExecutionException即可。如：
import java.text.SimpleDateFormat;
import java.util.Date;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
public class myJob implements Job {
@Override
public void execute(JobExecutionContext arg0) throws JobExecutionException {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
System.out.println(sdf.format(new Date()));
}
}
import java.text.SimpleDateFormat;
import java.util.Date;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
public class myJob implements Job {
@Override
public void execute(JobExecutionContext arg0) throws JobExecutionException {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
System.out.println(sdf.format(new Date()));
}
}
這個例子很簡單，就不用解說了。
第三步：創建任務調度，並執行
這一步應該算是最難的一步的，但其實是非常簡單的，直接上代碼
import static org.quartz.CronScheleBuilder.cronSchele;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.TriggerBuilder.newTrigger;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheler;
import org.quartz.SchelerFactory;
import org.quartz.impl.StdSchelerFactory;
public class Test {
public void go() throws Exception {
// 首先，必需要取得一個Scheler的引用
SchelerFactory sf = new StdSchelerFactory();
Scheler sched = sf.getScheler();
//jobs可以在scheled的sched.start()方法前被調用
//job 1將每隔20秒執行一次
JobDetail job = newJob(myJob.class).withIdentity("job1", "group1").build();
CronTrigger trigger = newTrigger().withIdentity("trigger1", "group1").withSchele(cronSchele("0/20 * * * * ?")).build();
Date ft = sched.scheleJob(job, trigger);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
System.out.println(job.getKey() + " 已被安排執行於: " + sdf.format(ft) + "，並且以如下重復規則重復執行: " + trigger.getCronExpression());
// job 2將每2分鍾執行一次（在該分鍾的第15秒)
job = newJob(myJob.class).withIdentity("job2", "group1").build();
trigger = newTrigger().withIdentity("trigger2", "group1").withSchele(cronSchele("15 0/2 * * * ?")).build();
ft = sched.scheleJob(job, trigger);
System.out.println(job.getKey() + " 已被安排執行於: " + sdf.format(ft) + "，並且以如下重復規則重復執行: "+ trigger.getCronExpression());
// 開始執行，start()方法被調用後，計時器就開始工作，計時調度中允許放入N個Job
sched.start();
try {
//主線程等待一分鍾
Thread.sleep(60L * 1000L);
} catch (Exception e) {}
//關閉定時調度，定時器不再工作
sched.shutdown(true);
}
public static void main(String[] args) throws Exception {
Test test = new Test();
test.go();
}
}
F. java quartz job 執行時間配置
第一步：引包
要使用Quartz，必須要引入以下這幾個包：
1、log4j-1.2.16
2、quartz-2.1.7
3、slf4j-api-1.6.1.jar
4、slf4j-log4j12-1.6.1.jar
這些包都在下載的Quartz包裡麵包含著，因此沒有必要為尋找這幾個包而頭疼。
第二步：創建要被定執行的任務類
這一步也很簡單，只需要創建一個實現了org.quartz.Job介面的類，並實現這個介面的唯一一個方法execute(JobExecutionContext arg0) throws JobExecutionException即可。如：
import java.text.SimpleDateFormat;
import java.util.Date;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
public class myJob implements Job {
@Override
public void execute(JobExecutionContext arg0) throws JobExecutionException {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
System.out.println(sdf.format(new Date()));
}
}
import java.text.SimpleDateFormat;
import java.util.Date;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
public class myJob implements Job {
@Override
public void execute(JobExecutionContext arg0) throws JobExecutionException {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
System.out.println(sdf.format(new Date()));
}
}
這個例子很簡單，就不用解說了。
第三步：創建任務調度，並執行
這一步應該算是最難的一步的，但其實是非常簡單的，直接上代碼
import static org.quartz.CronScheleBuilder.cronSchele;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.TriggerBuilder.newTrigger;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheler;
import org.quartz.SchelerFactory;
import org.quartz.impl.StdSchelerFactory;
public class Test {
public void go() throws Exception {
// 首先，必需要取得一個Scheler的引用
SchelerFactory sf = new StdSchelerFactory();
Scheler sched = sf.getScheler();
//jobs可以在scheled的sched.start()方法前被調用
//job 1將每隔20秒執行一次
JobDetail job = newJob(myJob.class).withIdentity("job1", "group1").build();
CronTrigger trigger = newTrigger().withIdentity("trigger1", "group1").withSchele(cronSchele("0/20 * * * * ?")).build();
Date ft = sched.scheleJob(job, trigger);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
System.out.println(job.getKey() + " 已被安排執行於: " + sdf.format(ft) + "，並且以如下重復規則重復執行: " + trigger.getCronExpression());
// job 2將每2分鍾執行一次（在該分鍾的第15秒)
job = newJob(myJob.class).withIdentity("job2", "group1").build();
trigger = newTrigger().withIdentity("trigger2", "group1").withSchele(cronSchele("15 0/2 * * * ?")).build();
ft = sched.scheleJob(job, trigger);
System.out.println(job.getKey() + " 已被安排執行於: " + sdf.format(ft) + "，並且以如下重復規則重復執行: "+ trigger.getCronExpression());
// 開始執行，start()方法被調用後，計時器就開始工作，計時調度中允許放入N個Job
sched.start();
try {
//主線程等待一分鍾
Thread.sleep(60L * 1000L);
} catch (Exception e) {}
//關閉定時調度，定時器不再工作
sched.shutdown(true);
}
public static void main(String[] args) throws Exception {
Test test = new Test();
test.go();
}
}
import static org.quartz.CronScheleBuilder.cronSchele;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.TriggerBuilder.newTrigger;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheler;
import org.quartz.SchelerFactory;
import org.quartz.impl.StdSchelerFactory;
public class Test {
public void go() throws Exception {
// 首先，必需要取得一個Scheler的引用
SchelerFactory sf = new StdSchelerFactory();
Scheler sched = sf.getScheler();
//jobs可以在scheled的sched.start()方法前被調用
//job 1將每隔20秒執行一次
JobDetail job = newJob(myJob.class).withIdentity("job1", "group1").build();
CronTrigger trigger = newTrigger().withIdentity("trigger1", "group1").withSchele(cronSchele("0/20 * * * * ?")).build();
Date ft = sched.scheleJob(job, trigger);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
System.out.println(job.getKey() + " 已被安排執行於: " + sdf.format(ft) + "，並且以如下重復規則重復執行: " + trigger.getCronExpression());
// job 2將每2分鍾執行一次（在該分鍾的第15秒)
job = newJob(myJob.class).withIdentity("job2", "group1").build();
trigger = newTrigger().withIdentity("trigger2", "group1").withSchele(cronSchele("15 0/2 * * * ?")).build();
ft = sched.scheleJob(job, trigger);
System.out.println(job.getKey() + " 已被安排執行於: " + sdf.format(ft) + "，並且以如下重復規則重復執行: "+ trigger.getCronExpression());
// 開始執行，start()方法被調用後，計時器就開始工作，計時調度中允許放入N個Job
sched.start();
try {
//主線程等待一分鍾
Thread.sleep(60L * 1000L);
} catch (Exception e) {}
//關閉定時調度，定時器不再工作
sched.shutdown(true);
}
public static void main(String[] args) throws Exception {
Test test = new Test();
test.go();
}
}
OK了，Job1和Job2就會被安排為定時執行了。此時程序是可以執行的了，但是可能會輸出WARN級別日誌，這是因為沒有加log4j的配置文件，加上配置文件，就OK了。這里需要說明的地方只有一個，其它的可以直接Copy到您的項目裡面。看代碼：
CronTrigger trigger = newTrigger().withIdentity("trigger1", "group1").withSchele(cronSchele("0/20 * * * * ?")).build();
CronTrigger trigger = newTrigger().withIdentity("trigger1", "group1").withSchele(cronSchele("0/20 * * * * ?")).build();
G. python自學，需要學習那些內容有沒有課程大綱推薦
以下是老男孩教育Python全棧課程內容：階段一：Python開發基礎
Python開發基礎課程內容包括：計算機硬體、操作系統原理、安裝linux操作系統、linux操作系統維護常用命令、Python語言介紹、環境安裝、基本語法、基本數據類型、二進制運算、流程式控制制、字元編碼、文件處理、數據類型、用戶認證、三級菜單程序、購物車程序開發、函數、內置方法、遞歸、迭代器、裝飾器、內置方法、員工信息表開發、模塊的跨目錄導入、常用標准庫學習，b加密\re正則\logging日誌模塊等，軟體開發規范學習，計算器程序、ATM程序開發等。
階段二：Python高級級編編程&資料庫開發
Python高級級編編程&資料庫開發課程內容包括：面向對象介紹、特性、成員變數、方法、封裝、繼承、多態、類的生成原理、MetaClass、__new__的作用、抽象類、靜態方法、類方法、屬性方法、如何在程序中使用面向對象思想寫程序、選課程序開發、TCP/IP協議介紹、Socket網路套接字模塊學習、簡單遠程命令執行客戶端開發、C\S架構FTP伺服器開發、線程、進程、隊列、IO多路模型、資料庫類型、特性介紹，表欄位類型、表結構構建語句、常用增刪改查語句、索引、存儲過程、視圖、觸發器、事務、分組、聚合、分頁、連接池、基於資料庫的學員管理系統開發等。
階段三：前端開發
前端開發課程內容包括：HTML\CSS\JS學習、DOM操作、JSONP、原生Ajax非同步載入、購物商城開發、Jquery、動畫效果、事件、定時期、輪播圖、跑馬燈、HTML5\CSS3語法學習、bootstrap、抽屜新熱榜開發、流行前端框架介紹、Vue架構剖析、mvvm開發思想、Vue數據綁定與計算屬性、條件渲染類與樣式綁定、表單控制項綁定、事件綁定webpack使用、vue-router使用、vuex單向數據流與應用結構、vuex actions與mutations熱重載、vue單頁面項目實戰開發等。
階段四：WEB框架開發
WEB框架開發課程內容包括：Web框架原理剖析、Web請求生命周期、自行開發簡單的Web框架、MTV\MVC框架介紹、Django框架使用、路由系統、模板引擎、FBV\CBV視圖、Models ORM、FORM、表單驗證、Django session & cookie、CSRF驗證、XSS、中間件、分頁、自定義tags、Django Admin、cache系統、信號、message、自定義用戶認證、Memcached、redis緩存學習、RabbitMQ隊列學習、Celery分布式任務隊列學習、Flask框架、Tornado框架、Restful API、BBS+Blog實戰項目開發等。
階段五：爬蟲開發
爬蟲開發課程內容包括：Requests模塊、BeautifulSoup，Selenium模塊、PhantomJS模塊學習、基於requests實現登陸：抽屜、github、知乎、博客園、爬取拉鉤職位信息、開發Web版微信、高性能IO性能相關模塊：asyncio、aiohttp、grequests、Twisted、自定義開發一個非同步非阻塞模塊、驗證碼圖像識別、Scrapy框架以及源碼剖析、框架組件介紹（engine、spider、downloader、scheler、pipeline）、分布式爬蟲實戰等。
階段六：全棧項目實戰
全棧項目實戰課程內容包括：互聯網企業專業開發流程講解、git、github協作開發工具講解、任務管理系統講解、介面單元測試、敏捷開發與持續集成介紹、django + uwsgi + nginx生產環境部署學習、介面文檔編寫示例、互聯網企業大型項目架構圖深度講解、CRM客戶關系管理系統開發、路飛學城在線教育平台開發等。
階段七：數據分析
數據分析課程內容包括：金融、股票知識入門股票基本概念、常見投資工具介紹、市基本交易規則、A股構成等，K線、平均線、KDJ、MACD等各項技術指標分析，股市操作模擬盤演示量化策略的開發流程，金融量化與Python，numpy、pandas、matplotlib模塊常用功能學習在線量化投資平台：優礦、聚寬、米筐等介紹和使用、常見量化策略學習，如雙均線策略、因子選股策略、因子選股策略、小市值策略、海龜交易法則、均值回歸、策略、動量策略、反轉策略、羊駝交易法則、PEG策略等、開發一個簡單的量化策略平台，實現選股、擇時、倉位管理、止盈止損、回測結果展示等功能。
階段八：人工智慧
人工智慧課程內容包括：機器學習要素、常見流派、自然語言識別、分析原理詞向量模型word2vec、剖析分類、聚類、決策樹、隨機森林、回歸以及神經網路、測試集以及評價標准Python機器學習常用庫scikit-learn、數據預處理、Tensorflow學習、基於Tensorflow的CNN與RNN模型、Caffe兩種常用數據源製作、OpenCV庫詳解、人臉識別技術、車牌自動提取和遮蔽、無人機開發、Keras深度學習、貝葉斯模型、無人駕駛模擬器使用和開發、特斯拉遠程式控制制API和自動化駕駛開發等。
階段九：自動化運維&開發
自動化運維&開發課程內容包括：設計符合企業實際需求的CMDB資產管理系統，如安全API介面開發與使用，開發支持windows和linux平台的客戶端，對其它系統開放靈活的api設計與開發IT資產的上線、下線、變更流程等業務流程。IT審計+主機管理系統開發，真實企業系統的用戶行為、管理許可權、批量文件操作、用戶登錄報表等。分布式主機監控系統開發，監控多個服務，多種設備，報警機制，基於http+restful架構開發，實現水平擴展，可輕松實現分布式監控等功能。
階段十：高並發語言GO開發高並發語言GO開發課程內容包括：Golang的發展介紹、開發環境搭建、golang和其他語言對比、字元串詳解、條件判斷、循環、使用數組和map數據類型、go程序編譯和Makefile、gofmt工具、godoc文檔生成工具詳解、斐波那契數列、數據和切片、make&new、字元串、go程序調試、slice&map、map排序、常用標准庫使用、文件增刪改查操作、函數和面向對象詳解、並發、並行與goroute、channel詳解goroute同步、channel、超時與定時器reover捕獲異常、Go高並發模型、Lazy生成器、並發數控制、高並發web伺服器的開發等。
H. (知乎) golang的goroutine是如何實現的
Go runtime的調度器：
在了解Go的運行時的scheler之前，需要先了解為什麼需要它，因為我們可能會想，OS內核不是已經有一個線程scheler了嘛？
熟悉POSIX API的人都知道，POSIX的方案在很大程度上是對Unix process進場模型的一個邏輯描述和擴展，兩者有很多相似的地方。 Thread有自己的信號掩碼，CPU affinity等。但是很多特徵對於Go程序來說都是累贅。 尤其是context上下文切換的耗時。另一個原因是Go的垃圾回收需要所有的goroutine停止，使得內存在一個一致的狀態。垃圾回收的時間點是不確定的，如果依靠OS自身的scheler來調度，那麼會有大量的線程需要停止工作。
單獨的開發一個GO得調度器，可以是其知道在什麼時候內存狀態是一致的，也就是說，當開始垃圾回收時，運行時只需要為當時正在CPU核上運行的那個線程等待即可，而不是等待所有的線程。
用戶空間線程和內核空間線程之間的映射關系有：N:1,1:1和M:N
N:1是說，多個（N）用戶線程始終在一個內核線程上跑，context上下文切換確實很快，但是無法真正的利用多核。
1：1是說，一個用戶線程就只在一個內核線程上跑，這時可以利用多核，但是上下文switch很慢。
M:N是說， 多個goroutine在多個內核線程上跑，這個看似可以集齊上面兩者的優勢，但是無疑增加了調度的難度。
I. c++ 代碼實現一下。。。
#include<iostream>
#include<cstring>
#include<ctime>
using namespace std;
//司機：啟動車輛，正常行車，到站停車；
//售票員：上乘客，關車門，售票，開車門，下乘客。
//汽車:不斷地到站，停車。
enum WorkSuit{work,stop};
class Saler;
class Bus;
class Driver{
private:
char name[20];
int suit;
public:
Driver(char *N=NULL,int S=stop);
void Start();
void Stop();
void SuitPrint();
};
Driver::Driver(char *N,int S):suit(S){strcpy(name,N);}
void Driver::Start(){
suit=work;
cout<<name<<":Driver Start!"<<endl;
}
void Driver::Stop(){
cout<<name<<":Driver Stop!"<<endl;
suit=stop;
}
void Driver::SuitPrint(){cout<<name<<(suit==work? "is woking!":"is free!")<<endl;}
class Saler{
private:
char name[20];
int suit;
void LoadP();
void UnloadP();
public:
Saler(char *N=NULL,int S=stop);
Saler(Saler &);
void DoorOpen();
void DoorClose();
void SuitPrint();
};
Saler::Saler(char *N,int S):suit(S){strcpy(name,N);}
Saler::Saler(Saler &S):suit(S.suit){strcpy(name,S.name);}
void Saler::LoadP(){cout<<name<<":Load Passangers!"<<endl;}
void Saler::UnloadP(){cout<<name<<":Unload Passangers!"<<endl;}
void Saler::DoorOpen(){cout<<name<<":Open Door!"<<endl;UnloadP();suit=work;}
void Saler::DoorClose(){cout<<name<<":Close Door!"<<endl;suit=stop;}
void Saler::SuitPrint(){cout<<name<<(suit==work? "is woking!":"is free!")<<endl;}
class Bus{
private:
char name[20];
int suit;
Saler &s;
Driver &d;
public:
Bus(char *N,Driver &D,Saler &S,int Su=stop);
Bus(Bus &B);
void Go();
void Arrive();
void SuitPrint();
};
Bus::Bus(char *N,Driver &D,Saler &S,int Su):suit(Su),s(S),d(D){strcpy(name,N);}
Bus::Bus(Bus &B):suit(B.suit),s(B.s),d(B.d){strcpy(name,B.name);}
void Bus::Go(){suit=work;d.Start();s.DoorClose();cout<<name<<"Go!"<<endl;}
void Bus::Arrive(){suit=stop;d.Stop();cout<<name<<"Stop!"<<endl;}
void Bus::SuitPrint(){
cout<<name<<(suit==work? "is woking!":"stoped!")<<endl;
}
class Scheler{
private:
Bus b;
Driver d;
Saler s;
int f;
int min;
int max;
int nstation;
public:
Scheler(char *dn,char *bn,char *sn,int A=2);
void Go();
void Set(int ,int ,int);
};
Scheler::Scheler(char *dn,char *bn,char *sn,int A):s(sn),d(dn),b(bn,d,s),f(A){min=0;max=20;cout<<"Scheler Go!!"<<endl;}
void Scheler::Go(){
srand(time(0));
nstation=1+rand()%5;
int c=0;
b.Go();
for(int i=0;i!=f;i=min+rand()%max,c++){
if(c==nstation)b.Arrive();
else {
b.SuitPrint();
s.SuitPrint();
d.SuitPrint();
}
cin.get();
if(c==nstation){c=0;nstation=1+rand()%10;b.Go();}
}
cout<<"Scheler ending!!!"<<endl;
}
void main(){
Scheler t("Driver_N0.1\0","Bus_N0.1\0","Saler_NO.1\0");
t.Go();
system("pause");
}
J. java：如何使用 quartz定時執行任務，例如定時執行System.out.pintln("aa")；看清楚用quartz
}
importstaticorg.quartz.CronScheleBuilder.cronSchele;
importstaticorg.quartz.JobBuilder.newJob;
importstaticorg.quartz.TriggerBuilder.newTrigger;
importjava.text.SimpleDateFormat;
importjava.util.Date;
importorg.quartz.CronTrigger;
importorg.quartz.JobDetail;
importorg.quartz.Scheler;
importorg.quartz.SchelerFactory;
importorg.quartz.impl.StdSchelerFactory;
publicclassTest{
publicvoidgo()throwsException{
//首先，必需要取得一個Scheler的引用
SchelerFactorysf=newStdSchelerFactory();
Schelersched=sf.getScheler();
//jobs可以在scheled的sched.start()方法前被調用
//job1將每隔30分鍾執行一次
JobDetailjob=newJob(myJob.class).withIdentity("job1","group1").build();
CronTriggertrigger=newTrigger().withIdentity("trigger1","group1").withSchele(cronSchele("00/30***?")).build();
Dateft=sched.scheleJob(job,trigger);
SimpleDateFormatsdf=newSimpleDateFormat("yyyy-MM-ddHH:mm:ssSSS");
System.out.pintln("aa")；
//開始執行，start()方法被調用後，計時器就開始工作，計時調度中允許放入N個Job
sched.start();
try{
//主線程等待一分鍾
Thread.sleep(60L*1000L);
}catch(Exceptione){}
//關閉定時調度，定時器不再工作
sched.shutdown(true);
}
publicstaticvoidmain(String[]args)throwsException{
Testtest=newTest();
test.go();
}
}