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();
}
}