分布式调度问题

最新推荐文章于 2024-09-15 19:46:31 发布
最新推荐文章于 2024-09-15 19:46:31 发布
阅读量234 收藏
点赞数
分类专栏： Java 分布式集群 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40377973/article/details/125772894
版权

调度—>定时任务，分布式调度—>在分布式集群环境下定时任务

1、定时任务的场景

定时任务形式：每隔⼀定时间/特定某⼀时刻执⾏
例如：

  • 订单审核、出库
  • 订单超时⾃动取消、⽀付退款
  • 礼券同步、⽣成、发放作业
  • 物流信息推送、抓取作业、退换货处理作业
  • 数据积压监控、⽇志监控、服务可⽤性探测作业
  • 定时备份数据
  • ⾦融系统每天的定时结算
  • 数据归档、清理作业
  • 报表、离线数据分析作业

2、什么是分布式调度

1）运⾏在分布式集群环境下的调度任务（同⼀个定时任务程序部署多份，只应该有⼀个定时任务在执⾏）
2）分布式调度—>定时任务的分布式—>定时任务的拆分（即为把⼀个⼤的作业任务拆分为多个⼩的作业任务，同时执⾏）

在这里插入图片描述

3、定时任务与消息队列的区别

  • 共同点
    • 异步处理
      ⽐如注册、下单事件
    • 应⽤解耦
      不管定时任务作业还是MQ都可以作为两个应⽤之间的⻮轮实现应⽤解耦，这个⻮轮可以中转数据，当然单体服务不需要考虑这些，服务拆分的时候往往都会考虑
    • 流量削峰
      双⼗⼀的时候，任务作业和MQ都可以⽤来扛流量，后端系统根据服务能⼒定时处理订单或者从MQ抓取订单抓取到⼀个订单到来事件的话触发处理，对于前端⽤户来说看到的结果是已经下单成功了，下单是不受任何影响的
  • 不同
    • 定时任务作业是时间驱动，⽽MQ是事件驱动；
    • 时间驱动是不可代替的，⽐如⾦融系统每⽇的利息结算，不是说利息来⼀条（利息到来事件）就算⼀下，⽽往往是通过定时任务批量计算；
    • 定时任务作业更倾向于批处理，MQ倾向于逐条处理；

4、定时任务的实现⽅式

定时任务的实现⽅式有多种。早期没有定时任务框架的时候，我们会使⽤JDK中的Timer机制和多线程机制（Runnable+线程休眠）来实现定时或者间隔⼀段时间执⾏某⼀段程序；后来有了定时任务框架，⽐如⼤名鼎鼎的Quartz任务调度框架，使⽤时间表达式（包括：秒、分、时、⽇、周、年）配置某⼀个任务什么时间去执⾏：

Quartz的使用
引⼊jar

<!--任务调度框架quartz-->
<!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz -->
<dependency> 
	<groupId>org.quartz-scheduler</groupId> 
	<artifactId>quartz</artifactId> 
	<version>2.3.2</version>
</dependency>

定时任务作业主调度程序

public class QuartzDemo {

    public static void main(String[] args) throws SchedulerException {
        // 创建⼀个作业任务调度器（类似于公交调度站）
        Scheduler scheduler = QuartzDemo.createScheduler();
        // 创建⼀个作业任务（类似于⼀辆公交⻋）
        JobDetail detail = QuartzDemo.createJobDetail();
        // 创建⼀个作业任务时间触发器（类似于公交⻋出⻋时间表）
        Trigger trigger = QuartzDemo.createTrigger();
        // 使⽤调度器按照时间触发器执⾏这个作业任务
        scheduler.scheduleJob(detail, trigger);
        scheduler.start();
    }

    // 1、创建⼀个作业任务调度器（类似于公交调度站）
    public static Scheduler createScheduler() throws SchedulerException {
        SchedulerFactory factory = new StdSchedulerFactory();
        return factory.getScheduler();
    }

    // 创建⼀个作业任务（类似于⼀辆公交⻋）
    public static JobDetail createJobDetail(){
        JobBuilder job = JobBuilder.newJob(JobTest.class);
        job.withIdentity("job","job");
        JobDetail build = job.build();
        return build;
    }

    // 创建⼀个作业任务时间触发器（类似于公交⻋出⻋时间表）
    /**
     * 创建作业任务时间触发器（类似于公交⻋出⻋时间表）
     * cron表达式由七个位置组成，空格分隔
     * 1、Seconds（秒） 0~59
     * 2、Minutes（分） 0~59
     * 3、Hours（⼩时） 0~23
     * 4、Day of Month（天）1~31,注意有的⽉份不⾜31天
     * 5、Month（⽉） 0~11,或者
     JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC
     * 6、Day of Week(周) 1~7,1=SUN或者 SUN,MON,TUE,WEB,THU,FRI,SAT
     定义⼀个job，需实现Job接⼝
     * 7、Year（年）1970~2099 可选项
     *示例：
     * 0 0 11 * * ? 每天的11点触发执⾏⼀次
     * 0 30 10 1 * ? 每⽉1号上午10点半触发执⾏⼀次
     */
    public static Trigger createTrigger(){
        CronTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("triggerName", "myTrigger")
                .startNow()
                .withSchedule(CronScheduleBuilder.cronSchedule("0/2 * * * * ?"))
                .build();
        return trigger;
    }

}

执行类:

public class JobTest implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("定时任务。。。。");
    }
}

5、分布式调度框架Elastic-Job

5.1 Elastic-Job介绍

Elastic-Job是当当⽹开源的⼀个分布式调度解决⽅案，基于Quartz⼆次开发的，由两个相互独⽴的⼦项⽬Elastic-Job-Lite和Elastic-Job-Cloud组成。我们要学习的是 Elastic-Job-Lite，它定位为轻量级⽆中⼼化解决⽅案，使⽤Jar包的形式提供分布式任务的协调服务，⽽Elastic-Job-Cloud⼦项⽬需要结合Mesos以及Docker在云环境下使⽤。
Elastic-Job的github地址：https://github.com/elasticjob

主要功能

  • 分布式调度协调
    在分布式环境中，任务能够按指定的调度策略执⾏，并且能够避免同⼀任务多实例重复执⾏
  • 丰富的调度策略
    基于成熟的定时任务作业框架Quartz cron表达式执⾏定时任务
  • 弹性扩容缩容
    当集群中增加某⼀个实例，它应当也能够被选举并执⾏任务；当集群减少⼀个实例时，它所执⾏的任务能被转移到别的实例来执⾏。
  • 失效转移
    某实例在任务执⾏失败后，会被转移到其他实例执⾏
  • 错过执⾏作业重触发
    若因某种原因导致作业错过执⾏，⾃动记录错过执⾏的作业，并在上次作业完成后⾃动触发。
  • ⽀持并⾏调度
    ⽀持任务分⽚，任务分⽚是指将⼀个任务分为多个⼩任务项在多个实例同时执⾏。
  • 作业分⽚⼀致性
    当任务被分⽚后，保证同⼀分⽚在分布式环境中仅⼀个执⾏实例。
5.2 Elastic-Job-Lite应⽤

Elastic-Job依赖于Zookeeper进⾏分布式协调，所以需要安装Zookeeper软件（3.4.6版本以上）

  • 安装Zookeeper
  • 这里使⽤3.6.0版本，在linux平台解压下载的zookeeper-3.6.0.tar.gz
    tar -zxvf zookeeper-3.6.0.tar.gz
  • 进⼊conf⽬录，cp zoo_sample.cfg zoo.cfg
  • 进⼊bin⽬录，启动zk服务
    启动 ./zkServer.sh start
    停⽌ ./zkServer.sh stop
    查看状态 ./zkServer.sh status
[root@lotus bin]# ./zkServer.sh start
ZooKeeper JMX enabled by default
Using config: /home/myself/apache-zookeeper-3.6.0-bin/bin/../conf/zoo.cfg
Starting zookeeper ... STARTED
[root@lotus bin]# ./zkServer.sh status
ZooKeeper JMX enabled by default
Using config: /home/myself/apache-zookeeper-3.6.0-bin/bin/../conf/zoo.cfg
Client port found: 2181. Client address: localhost.
Error contacting service. It is probably not running.

引入依赖：

<dependency>
            <groupId>com.dangdang</groupId>
            <artifactId>elastic-job-lite-core</artifactId>
            <version>2.1.5</version>
</dependency>

定时任务实例
需求：每隔两秒钟执⾏⼀次定时任务（test表中未归档的数据归档到rtest_bak表中，每次归档1条记录）
1）rtest_bak和test表结构完全⼀样
2）test表中数据归档之后不删除，只将state置为"已归档"
数据表结构

CREATE TABLE `test` (
 `id` bigint(20) NOT NULL AUTO_INCREMENT,
 `name` varchar(255) DEFAULT NULL,
 `sex` varchar(255) DEFAULT NULL,
 `phone` varchar(255) DEFAULT NULL,
 `address` varchar(255) DEFAULT NULL,
 `education` varchar(255) DEFAULT NULL,
 `state` varchar(255) DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1001 DEFAULT CHARSET=utf8;
SET FOREIGN_KEY_CHECKS = 1;

定时任务类:

public class LotusJob implements SimpleJob {
    @Override
    public void execute(ShardingContext shardingContext) {
        String selectSql = "select * from test where state= '0' limit 1";
        List<Map<String, Object>> list = JdbcUtil.executeQuery(selectSql);
        if(list == null || list.size() ==0 ) {
            System.out.println("数据已经处理完毕！！！！！！");
            return;
        }
        // 2 "未归档"更改为"已归档"
        Map<String, Object> stringObjectMap = list.get(0);
        long id = (long) stringObjectMap.get("id");
        String name = (String) stringObjectMap.get("name");
        String education = (String) stringObjectMap.get("education");

        System.out.println("=======>>>>id：" + id + "  name：" + name + " education：" + education);

        String updateSql = "update test set state='已归档' where id=?";
        JdbcUtil.executeUpdate(updateSql,id);

        // 3 归档这条记录，把这条记录插入到resume_bak表
        String insertSql = "insert into test_bak select * from test where id=?";
        JdbcUtil.executeUpdate(insertSql,id);
    }
}

主类：

public class ElasticJob {
    public static void main(String[] args) {
        // 配置分布式协调服务（注册中心）Zookeeper
        ZookeeperConfiguration zookeeperConfiguration = new ZookeeperConfiguration("localhost:2181","data-archive-job");
        System.out.println(zookeeperConfiguration);
        CoordinatorRegistryCenter coordinatorRegistryCenter = new ZookeeperRegistryCenter(zookeeperConfiguration);
        System.out.println(coordinatorRegistryCenter);
        coordinatorRegistryCenter.init();
        JobCoreConfiguration configuration = JobCoreConfiguration.newBuilder("lotus-job", "*/2 * * * * ?", 1).build();
        SimpleJobConfiguration jobConfiguration = new SimpleJobConfiguration(configuration, LotusJob.class.getName());
        // 启动任务
        new JobScheduler(coordinatorRegistryCenter,
                LiteJobConfiguration.newBuilder(jobConfiguration).build()).init();
    }
}

数据库工具类：

public class JdbcUtil {
    //url
    private static String url = "jdbc:mysql://localhost:3306/test?characterEncoding=utf8&useSSL=false";
    //user
    private static String user = "root";
    //password
    private static String password = "password";
    //驱动程序类
    private static String driver = "com.mysql.cj.jdbc.Driver";

    static {
        try {
            Class.forName(driver);
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static Connection getConnection() {

        try {
            return DriverManager.getConnection(url, user, password);
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;

    }

    public static void close(ResultSet rs, PreparedStatement ps, Connection con) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } finally {
                if (ps != null) {
                    try {
                        ps.close();
                    } catch (SQLException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } finally {
                        if (con != null) {
                            try {
                                con.close();
                            } catch (SQLException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }
    }


    /***
     * DML操作（增删改）
     * 1.获取连接数据库对象
     * 2.预处理
     * 3.执行更新操作
     * @param sql
     * @param obj
     */
    //调用者只需传入一个sql语句，和一个Object数组。该数组存储的是SQL语句中的占位符
    public static void executeUpdate(String sql,Object...obj) {
        Connection con = getConnection();//调用getConnection()方法连接数据库
        PreparedStatement ps = null;
        try {
            ps = con.prepareStatement(sql);//预处理
            for (int i = 0; i < obj.length; i++) {//预处理声明占位符
                ps.setObject(i + 1, obj[i]);
            }
            ps.executeUpdate();//执行更新操作
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            close(null, ps, con);//调用close()方法关闭资源
        }
    }



    /***
     * DQL查询
     * Result获取数据集
     *
     * @param sql
     * @param obj
     * @return
     */
    public static List<Map<String,Object>> executeQuery(String sql, Object...obj) {
        Connection con = getConnection();
        ResultSet rs = null;
        PreparedStatement ps = null;
        try {
            ps = con.prepareStatement(sql);
            for (int i = 0; i < obj.length; i++) {
                ps.setObject(i + 1, obj[i]);
            }
            rs = ps.executeQuery();
            //new 一个空的list集合用来存放查询结果
            List<Map<String, Object>> list = new ArrayList<>();
            //获取结果集的列数
            int count = rs.getMetaData().getColumnCount();
            //对结果集遍历每一条数据是一个Map集合，列是k,值是v
            while (rs.next()) {
                //一个空的map集合，用来存放每一行数据
                Map<String, Object> map = new HashMap<String, Object>();
                for (int i = 0; i < count; i++) {
                    Object ob = rs.getObject(i + 1);//获取值
                    String key = rs.getMetaData().getColumnName(i + 1);//获取k即列名
                    map.put(key, ob);
                }
                list.add(map);
            }
            return list;
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {

            close(rs, ps, con);
        }

        return null;
    }
}

测试
1）可先启动⼀个进程，然后再启动⼀个进程（两个进程模拟分布式环境下，通⼀个定时任务部署了两份在⼯作）
2）两个进程逐个启动，观察现象
3）关闭其中执⾏的进程，观察现象
Leader节点选举机制
每个Elastic-Job的任务执⾏实例App作为Zookeeper的客户端来操作ZooKeeper的znode
（1）多个实例同时创建/leader节点
（2）/leader节点只能创建⼀个，后创建的会失败，创建成功的实例会被选为leader节点，执⾏任务

5.4 Elastic-Job-Lite轻量级去中⼼化的特点

在这里插入图片描述

5.5 任务分⽚

⼀个⼤的⾮常耗时的作业Job，⽐如：⼀次要处理⼀亿的数据，那这⼀亿的数据存储在数据库中，如果⽤⼀个作业节点处理⼀亿数据要很久，在互联⽹领域是不太能接受的，互联⽹领域更希望机器的增加去横向扩展处理能⼒。所以，ElasticJob可以把作业分为多个的task（每⼀个task就是⼀个任务分⽚），每⼀个task交给具体的⼀个机器实例去处理（⼀个机器实例是可以处理多个task的），但是具体每个task执⾏什么逻辑由我们⾃⼰来指定。

Strategy策略定义这些分⽚项怎么去分配到各个机器上去，默认是平均去分，可以定制，⽐如某⼀个机
器负载 ⽐较⾼或者预配置⽐较⾼，那么就可以写策略。分⽚和作业本身是通过⼀个注册中⼼协调的，因
为在分布式环境下，状态数据肯定集中到⼀点，才可以在分布式中沟通。
分片代码：

public class LotusJob implements SimpleJob {
    @Override
    public void execute(ShardingContext shardingContext) {

        int shardingItem = shardingContext.getShardingItem();
        System.out.println("=====>>>>当前分片：" + shardingItem);

        // 获取分片参数
        String shardingParameter = shardingContext.getShardingParameter(); // 0=bachelor,1=master,2=doctor
        System.out.println(shardingParameter);
        String selectSql = "select * from test where state='0' and education='"+ shardingParameter +"' limit 1";
        List<Map<String, Object>> list = JdbcUtil.executeQuery(selectSql);
        if(list == null || list.size() ==0 ) {
            System.out.println("数据已经处理完毕！！！！！！");
            return;
        }
        // 2 "未归档"更改为"已归档"
        Map<String, Object> stringObjectMap = list.get(0);
        long id = (long) stringObjectMap.get("id");
        String name = (String) stringObjectMap.get("name");
        String education = (String) stringObjectMap.get("education");

        System.out.println("=======>>>>id：" + id + "  name：" + name + " education：" + education);

        String updateSql = "update test set state='已归档' where id=?";
        JdbcUtil.executeUpdate(updateSql,id);

        // 3 归档这条记录，把这条记录插入到resume_bak表
        String insertSql = "insert into test_bak select * from test where id=?";
        JdbcUtil.executeUpdate(insertSql,id);
    }


}

主类：

public class ElasticJob {
    public static void main(String[] args) {
        // 配置分布式协调服务（注册中心）Zookeeper
        ZookeeperConfiguration zookeeperConfiguration = new ZookeeperConfiguration("localhost:2181","data-archive-job");
        System.out.println(zookeeperConfiguration);
        CoordinatorRegistryCenter coordinatorRegistryCenter = new ZookeeperRegistryCenter(zookeeperConfiguration);
        System.out.println(coordinatorRegistryCenter);
        coordinatorRegistryCenter.init();
        JobCoreConfiguration configuration =
                JobCoreConfiguration.newBuilder("lotus-job", "*/2 * * * * ?", 3)
                        .shardingItemParameters("0=1,1=2,2=3")
                        .build();
        SimpleJobConfiguration jobConfiguration = new SimpleJobConfiguration(configuration, LotusJob.class.getName());
        // 启动任务
        new JobScheduler(coordinatorRegistryCenter,
                LiteJobConfiguration.newBuilder(jobConfiguration).overwrite(true).build()).init();
    }
}
小默有礼
关注
专栏目录
thain:Thain是一个分布式流量调度平台
04-16
塞恩 其他语言版本 介绍 Thain是一个分布式流量调度平台，它是由XiaoMi Technology发明的，并且该项目已被证明易于学习，快速开发且在XiaoMi内部部门中稳定。 塞恩（Sean）已完成了后端管理系统，该系统支持对流进行依赖，重新运行，回滚和监视，并包含漂亮且易于操作的Web UI，供用户维护您的工作。 快速开始 环境要求 jdk> = 8 nodejs> = 8 克隆码 git clone https://github.com/XiaoMi/thain.git 在项目根目录下按顺序执行 cd thain-fe npm install npm run build cd .. ./gradlew clean build 跑步 java -jar thain-server/build/libs/thain-server-1.3.0-beta.0.jar 打开以查看效果
分布式任务调度学习及工作问题总结
weixin_45981924的博客
07-21 572
Vue的子父组件通信
【分布式系统】聊聊流量和数据调度
日拱一卒，不期速成！
08-09 486
聊聊流量和数据调度
12.21 Day 6 - 分布式系统关键技术：流量与数据调度
纽雪澳诺加海美德的博客
12-31 378
大家好，我是 Snow Hide，作为《左耳听风》这个专栏的学员之一，这是我打卡的第 6 天，也是我第 6 次进行打卡这种操作。 今天我温习了该专栏里一篇叫《分布式系统关键技术：流量与数据调度》的文章。 关键词总结：分布式流量调度功能（服务流控、流量控制、流量管理）、分布式流量调度技术（高性能、高并发、基本业务能力、服务化）、分布式服务状态数据调度、分布式事务一致性问题（主-从、主-主、2PC/3...
分布式系统学习：06 分布式系统关键技术：流量与数据调度
墨1024
02-03 811
流量调度与服务治理： 一方面，服务治理是内部系统的事，而流量调度可以是内部的，更是外部接入层的事。 另一方面，服务治理是数据中心的事，而流量调度要做得好，应该是数据中心之外的事，也就是我们常说的边缘计算，是应该在类似于 CDN 上完成的事。 流量调度和服务治理是在不同层面上的，不应该混在一起，所以在系统架构上应该把它们分开。 流量调度 流量调度的主要功能 主要功能是：(提高系统架构的稳定性和高可用...
分布式-调度
厚积薄发
03-20 483
分布式调度
浅谈分布式调度
快乐小码农的博客
10-07 6857
浅谈分布式调度 什么是分布式调度？ 要说分布式调度，那么先来谈下什么是分布式。 分布式：百度百科上是这么说的，当计算机的程序和数据通过网络分布在多于一个的计算机上时，计算就成为“分布式的”。通俗的说，平台是分布式部署的，各个节点之间可以无状态和无限的水平扩展。 那么什么是分布式调度？分布式调度就是运⾏在分布式集群环境下的调度任务。它有两层含义： 同⼀个定时任务程序部署多份，只应该有⼀个定时任务在执⾏ 定时任务的拆分，即为把⼀个⼤的作业任务拆分为多个⼩的作业任务，同时执⾏ 下面我们通过一个图来简单了解下分
分布式经济调度,分布式调度系统,matlab
09-10
分布式经济调度是现代电力系统中一...通过这些文件，我们可以深入理解分布式调度系统的工作原理，学习如何应用一致性算法来解决实际的电力系统调度问题。同时，这样的实践案例对于学术研究和工程应用都具有很高的价值。
基于zookeeper临时顺序节点实现分布式调度
04-11
在本场景中，我们利用Zookeeper的临时顺序节点来实现一个分布式调度解决方案，并结合Quartz进行作业调度。Zookeeper是一个分布式协调服务，而Quartz则是一个强大的、开源的作业调度框架，两者结合能构建出高可用、可...
区块链背景下虚拟电厂分布式调度策略研究.pdf
08-08
在信息技术和能源行业的快速发展中，虚拟电厂（Virtual Power Plant, VPP）作为一种新型的能源管理概念，其分布式调度策略在能源互联网中占据重要地位。本文探讨了在区块链技术背景下，如何实现虚拟电厂的分布式调度...
最佳调度问题
12-21
假设有n个任务由k个可并行工作的机器完成。完成任务i需要的时间为ti。试设计一个算法找出完成这n个任务的最佳调度，使得完成全部任务的时间最早。
后端开发-基于Java的分布式调度后端实现.zip
04-02
本资源“后端开发-基于Java的分布式调度后端实现.zip”着重讲解了如何利用Java技术栈来设计和实现一个分布式调度系统。下面我们将深入探讨相关知识点。 一、Java后端开发基础 Java作为一款广泛使用的编程语言，因其...
分布式调度任务XXL-JOB架构图
02-11
分布式调度任务XXL-JOB架构图是一种基于quartz调度器的分布式任务调度框架，旨在解决大规模任务的调度和执行问题。下面是该架构图中的关键知识点： 1. 分布式调度中心：XXL-JOB架构图的核心组件是分布式调度中心，...
分布式服务框架中的负载均衡与流量调度
程序员光剑
01-25 63
1.背景介绍 在分布式服务框架中，负载均衡和流量调度是非常重要的部分。这篇文章将深入探讨这两个概念的核心算法原理、最佳实践、实际应用场景和工具推荐。 1. 背景介绍 分布式服务框架中的负载均衡和流量调度是为了解决服务器资源分配和性能优化的问题。在分布式系统中，服务器资源是有限的，而用户请求则是无限
分布式调度杂谈
南柯
05-12 389
对于规模以上的应用来说，调度系统已经是必不可少的组成部分，尤其是在基于数据分析的后台应用大量增长的今天，健壮的调度任务管理已经是非常重要的一环，因此多花时间来分析研究调度系统的设计对于日常开发与运维具有比较重要的意义。 调度问题从何而来？ 当你的网站是一个简单的blog，并且不需要跟外部交互的时候，你大概不需要调度任务，因为此时网站需要处理的任务仅限于即时交互，即用户想要使用一个功能，你立即给他就是了，如同你在网络上编辑一篇文章，点击保存，这篇文章就保存到网站的后台服务器中去了，这也是互联网刚出...
几种作业调度问题总结
sqjddb的博客
11-22 3196
★流水作业调度（动态规划） ★多机调度问题 （贪心算法） ★批处理作业调度 (回溯法)
调度问题的实例和表示
m0_65532100的博客
02-01 868
在飞机占据登机口的时间里,到达的乘客必须下飞机，飞机需要维修和保养,而出发的乘客必须上飞机。同一阶段里的机器可能在运行的速度、印刷颜色的数量、可处理纸袋的大小等方面略有不同。这台机器准备时间的长度取决于连续订单之间的相似度(相同颜色的数量、纸袋大小的差别等)。为了避免下面的情况,即时间相对短的任务为了等候更高优先级的时间长的任务而在系统中停留很长一段时间,操作系统将任务划分为小碎片。从技术和应用的角度来看,调度可能是很困难的。调度者必须把飞机分配给合适的登机口,使得在它们各自的到达时间，登机口是可用的。
系统调度问题
weixin_30650039的博客
01-23 218
一、什么是调度 　　当有多个线程在操作时，如果系统只有一个CPU，则它根本不可能真正同时进行一个以上的线程，它只能把CPU运行时间划分成若干个时间段，再将时间段分配给各个线程执行，在一个时间段的线程代码运行时，其它线程处于挂起状，这个分配CPU时间的过程就是调度 二、调度的方式 　　2.1非剥夺方式：分派程序一旦把CPU分配给某进程后便让它一直运行下去，直到进程完成或发生某...
Java企业面试题3
最新发布
m0_74972727的博客
09-15 556
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
构建高可用大数据分布式调度平台：策略与实践
调度问题自上世纪50年代起就被广泛研究，最初主要从数学和工程学角度出发，目标是优化资源分配以执行任务，确保时间和成本效益。传统的调度往往依赖于操作系统定时任务，如Linux的Crontab，强调至少执行一次的任务...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值