代码之家  ›  专栏  ›  技术社区  ›  Shushiro

Java:Threadpoolexecutor-使用作业列表提交作业?

  •  1
  • Shushiro  · 技术社区  · 8 年前

    Customer 和 jobManager . 客户有姓名、地址和账户余额。工作是从一个客户到另一个客户的资金转移。这是Threadpoolexecutor培训计划。下面的版本很有效,我一个接一个地提交作业。

    客户.java

    public class customer {
    
        private String name;
        private String adress;
        private Double accountBalance;
    
        public customer(String name, String adress, Double accountBalance)
        {
            this.name = name;
            this.adress = adress;
            this.accountBalance = accountBalance;
        }
    
        public String getName() { return name; }
    
        public String getAdress()
        {
            return adress;
        }
    
        public Double getAccountBalance(){return accountBalance;}
    
        public void setAccountBalance(double accountBalance){this.accountBalance=accountBalance;}
    
        @Override
        public String toString(){
    
            return "[" + name+"; " +adress+"; "+accountBalance+"]";
        }
    }
    

    customerOrganizer.java文件

    import java.util.ArrayList;
    import java.util.List;
    
    public class customerOrganizer {
    
        private static final customerOrganizer myJobOrganizer = new customerOrganizer();
    
        public static customerOrganizer getJobOrganizer(){
            return myJobOrganizer;
        }
    
        private List<customer> customerList = new ArrayList<customer>();
    
        public void add_customer(customer kunde)
        {
            this.customerList.add(kunde);
        }
    
        public Iterable<customer> all_customers()
        {
            return this.customerList;
        }
    
        public static customerOrganizer getInstance()
        {
            return myJobOrganizer;
        }
    
    }
    

    public class job implements Runnable {
        private customer kunde1;
        private customer kunde2;
        private Double transfer;
    
        public job(customer kunde1, customer kunde2, Double transfer) {
            this.kunde1 = kunde1;
            this.kunde2 = kunde2;
            this.transfer = transfer;
        }
    
        @Override
        public String toString(){
    
            return "[" + kunde1+"; " +kunde2+"; "+transfer+"]";
        }
    
        public void run() {
    
            System.out.println("Starting transfer");
    
            Double geber = this.kunde1.getAccountBalance();
            Double nehmer = this.kunde2.getAccountBalance();
    
            Double geberNeu = geber - this.transfer;
            this.kunde1.setAccountBalance(geberNeu);
    
            Double nehmerNeu = nehmer + this.transfer;
            this.kunde2.setAccountBalance(nehmerNeu);
            System.out.println("Transfer done");
        }
    }
    

    public class jobOrganizer {
    
        private static final jobOrganizer myJobOrganizer = new jobOrganizer();
    
        public static jobOrganizer getMyJobOrganizer() {
            return myJobOrganizer;
        }
    
        private List<job> jobList = new ArrayList<job>();
    
        public int getAmount(){ return jobList.size();}
    
        public void add_job(job newJob) {
            this.jobList.add(newJob);
        }
    
        public Iterable<job> all_jobs() {
            return this.jobList;
        }
    
        public static jobOrganizer getInstance() {
            return myJobOrganizer;
        }
    

    }

    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class Main {
    
        public static void main(String[] args) {
            customerOrganizer myCustomerOrganizer = new customerOrganizer();
            jobOrganizer myJobOrganizer= new jobOrganizer();
    
            customer mueller = new customer("Tim Mueller", "Strasse 1", 1077.00);
            customer john = new customer("John Doe", "Strasse 2",503.00);
            customer meier = new customer("John Meier", "Strasse 3", 8500.50);
            customer wurst = new customer("Hans Wurst", "Strasse 4", 1000.00);
    
            myCustomerOrganizer.add_customer(mueller);
            myCustomerOrganizer.add_customer(john);
            myCustomerOrganizer.add_customer(meier);
            myCustomerOrganizer.add_customer(wurst);
    
            job transfer1= new job(meier,wurst,500.50);
            job transfer2= new job(mueller,john,77.00);
    
            myJobOrganizer.add_job(transfer1);
            myJobOrganizer.add_job(transfer2);
    
            // this works:
            ExecutorService executor = Executors.newFixedThreadPool(2);
            executor.submit(transfer1);
            executor.submit(transfer2);
            executor.shutdown();
    
    
        }}
    

    所以,我有一份工作清单,我有一个想法,我应该使用它。我不想一个接一个地提交作业,而是根据作业列表提交作业。我一开始就想到了这样的事情:

     int threads = myJobOrganizer.getAmount();
            ExecutorService executor = Executors.newFixedThreadPool(threads);
            for (int i = 0; i <threads+1; i++){
                //submit jobs? execute?
            }
    

    此外,myJobOrganizer还需要实现Runnable?我还看到解决方案类似于:

    for(condition){
    
            executor.execute(new Runnable() {
    
                @Override
                public void run() {
                  submit the jobs?
                    }
                }}
    

    但我真的不知道怎么做。基本上,我不知道如何以正确的方式从作业列表中提取作业,以便将它们提交给executor服务>&书信电报;

    关于线程安全的更新

    所以,我按照Rab提供的链接,使用了CompletionService。Main.java的最后一部分如下所示:

    int threads = myJobOrganizer.getAmount();
    
    System.out.println(myCustomerOrganizer.all_customers().toString());
    // executor service   
    ExecutorService executor = Executors.newFixedThreadPool(threads);
    // completion service is applied on executor
    CompletionService service = new ExecutorCompletionService(executor);
    
    for(Callable<Job> myJob : myJobOrganizer.all_jobs()){
        service.submit(myJob);
    }
    executor.shutdown();
    // pause the main for control printout -> not nice yet, I am working on 
    // joining threads
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // control print
    System.out.println(myCustomerOrganizer.all_customers().toString());
    

    请注意,这个编辑是为了完成条目,但仍然是错误的(遗憾的)。提供的答案链接到原始问题,与线程安全无关

    2 回复  |  直到 8 年前
        1
  •  3
  •   glee8e    8 年前

    ExecutorService

    for (job jobObj : myJobOrganizer.all_jobs()) 
        executor.submit(jobObj);
    

    注意 sumbit Future<?> ,用于跟踪任务是否已完成或是否出错(以及任务结果,但runnable没有结果)。如果你关心这些东西,你会想把它们收集在某种容器里,比如一个 List


    如果你改变主意 job Callable<Void> Callable 是Runnable的某种扩展,允许任务在完成时生成结果。由于您的传输没有结果,请使用 java.lang.Void

    executor.invokeAll(myJobOrganizer.all_jobs()) 就足够了。这将节省一些上下文切换,加快一些事情(实际上非常重要,因为你的任务都很小)


        2
  •  0
  •   SamHoque    8 年前

    你可以用 Stream 如果你不想使用循环。如果您使用的是大于或等于8的java版本,这里是一个示例

        myJobList
                .stream()
                .forEach(e -> executor.execute(() -> {
            //submit the jobs
        }));
    

    或

        myJobOrganizer.all_jobs()
                .stream()
                .forEach(e -> executor.submit(e));
    

    你可以使用 executor.invokeAll(myJobList) 如果你真的不想循环。

    https://stackoverflow.com/a/34798567/6895166