Java Eclipse RCP IJob：限制并发执行作业的数量

如何让EclipseRCP作业管理同时运行最多x个作业

编辑：

它通过使用答案中描述的自定义调度规则来工作

不要将同一规则引用传递给多个作业，这一点很重要

以下是我使用的类：

公营就业主任{

private class Listener implements IJobChangeListener {

    @Override
    public void aboutToRun(final IJobChangeEvent event) {
    }

    @Override
    public void awake(final IJobChangeEvent event) {
    }

    @Override
    public void done(final IJobChangeEvent event) {
        synchronized (JobMaster.this) {
            running--;
            System.err.println("now running " + running);
        }
    }

    @Override
    public void running(final IJobChangeEvent event) {
        synchronized (JobMaster.this) {
            running++;
            System.err.println("now running " + running);
        }
    }

    @Override
    public void scheduled(final IJobChangeEvent event) {

    }

    @Override
    public void sleeping(final IJobChangeEvent event) {
    }

}

private class MyRule implements ISchedulingRule {

    public MyRule() {

    }

    @Override
    public boolean contains(final ISchedulingRule rule) {
        if (rule == this) {
            return true;
        }
        return false;

    }

    @Override
    public boolean isConflicting(final ISchedulingRule rule) {
        synchronized (JobMaster.this) {
            if (rule == this) {
                return true;
            }
            if (rule instanceof MyRule) {
                return running >= maxRun;
            }
            return false;
        }
    }
}

private final Listener l = new Listener();

private final int maxRun;

private volatile int running = 0;

public JobMaster(final int maxRun) {
    this.maxRun = maxRun;

}

public synchronized void add(final Job j) {
    j.setRule(new MyRule());
    j.addJobChangeListener(l);
    j.schedule();
}

---

}

作业管理器无法限制作业总数

对于正在创建的作业，可以创建一个

isSchedulingRule

规则，该规则限制同时运行的作业数量。调用

Job.setRule（rule）

设置作业的规则（在安排作业之前执行此操作）

调度规则示例（来自Java调试）：

这将停止一次运行多个使用特定对象的作业

更新：

作业管理器检查调度规则的以下条件：

// contains method must be reflexive
Assert.isLegal(rule.contains(rule));

// contains method must return false when given an unknown rule
Assert.isLegal(!rule.contains(nullRule));

// isConflicting method must be reflexive
Assert.isLegal(rule.isConflicting(rule));

// isConflicting method must return false when given an unknown rule
Assert.isLegal(!rule.isConflicting(nullRule));

---

从Eclipse Mars（4.5）开始，可以使用作业组来限制并发线程的数量：

JobGroup jobGroup = new JobGroup("Job...", /* maxThreads*/ 10, /* seedJobsCount */ 100);

for (int ii = 0; ii < 100; ii++)
{            
    Job job = new Job("job name")
    {
        @Override
        protected IStatus run(IProgressMonitor monitor)
        {
            // do something
            return Status.OK_STATUS;
        }
    };
    job.setJobGroup(jobGroup);
    job.schedule();
}

jobGroup.join(10000, monitor);

JobGroup JobGroup=new JobGroup（“作业…”，/*maxThreads*/10，/*seedjobsunt*/100）；
对于（int ii=0；ii<100；ii++）
{            
作业=新作业（“作业名称”）
{
@凌驾
受保护的IStatus运行（IProgressMonitor监视器）
{
//做点什么
返回状态。OK_状态；
}
};
job.setJobGroup（作业组）；
job.schedule（）；
}
jobGroup.join（10000，监视器）；

我已经尝试使用调度规则。不幸的是，这不起作用：java.lang.IllegalArgumentException:at org.eclipse.core.runtime.Assert.isLegal（Assert.java:63）at org.eclipse.core.runtime.Assert.isLegal（Assert.java:47）at org.eclipse.core.internal.jobs.JobManager.validateRule（JobManager.java:1573）Assert.isLegal（rule.isConflicting（rule））；这说明你的规则的逻辑是错误的。规则必须是“自反的”-

isConflicting

，传递的规则与参数必须返回true的规则相同。在回答中添加了要求参见关于JobGroup的回答，作为支持的实现节流/限制的方式。

JobGroup jobGroup = new JobGroup("Job...", /* maxThreads*/ 10, /* seedJobsCount */ 100);

for (int ii = 0; ii < 100; ii++)
{            
    Job job = new Job("job name")
    {
        @Override
        protected IStatus run(IProgressMonitor monitor)
        {
            // do something
            return Status.OK_STATUS;
        }
    };
    job.setJobGroup(jobGroup);
    job.schedule();
}

jobGroup.join(10000, monitor);