correct thread

Author: luccaroder

src/main/java/br/com/db1/controller/ApplicationController.java

@@ -1,7 +1,6 @@
 package br.com.db1.controller;
 
 import br.com.db1.model.Money;
-import br.com.db1.model.Rate;
 import br.com.db1.service.MoneyService;
 import br.com.db1.service.RateService;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -26,8 +25,18 @@ public class ApplicationController {
     @RequestMapping(method = RequestMethod.GET)
     public ResponseEntity<?> classifier() {
         try {
-            List<Rate> rates = rateService.getRates();
-            List<Money> listOfMoney = moneyService.getListOfMoney(rates, rates);
+            List<Money> listOfMoney = moneyService.getListOfMoney();
+            return new ResponseEntity<>(listOfMoney, HttpStatus.OK);
+        } catch (IllegalArgumentException e) {
+            return new ResponseEntity<>(e.getMessage(), HttpStatus.BAD_REQUEST);
+        }
+
+    }
+
+    @RequestMapping(value = "/atomic", method = RequestMethod.GET)
+    public ResponseEntity<?> atomic() {
+        try {
+            List<Money> listOfMoney = moneyService.useAtomicReference();
             return new ResponseEntity<>(listOfMoney, HttpStatus.OK);
         } catch (IllegalArgumentException e) {
             return new ResponseEntity<>(e.getMessage(), HttpStatus.BAD_REQUEST);

src/main/java/br/com/db1/service/MoneyService.java

@@ -6,36 +6,70 @@
 import br.com.db1.task.TaskMoneyCallable;
 import com.google.common.collect.Lists;
 import org.apache.log4j.Logger;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
+import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.CompletionService;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
+import java.util.concurrent.atomic.AtomicReference;
 
 @Service
 public class MoneyService {
 
+    @Autowired
+    private RateService rateService;
+
     private static Logger LOGGER = Logger.getLogger(MoneyService.class);
 
-    public List<Money> getListOfMoney(List<Rate> rateListOne, List<Rate> rateListTwo) {
+    private AtomicReference<Money> moneyAtomic = new AtomicReference<>();
+
+    private List<Future<Money>> moeyList = Collections.synchronizedList(Lists.newLinkedList());
+
+    /**
+     * obtem uma lista de dinheiro com valores aleatórios e vai somando os valores entre eles sincronizados
+     * endpoint que cria uma lista de dinheiro com moedas próprias
+     * o valor do dinheiro
+     * @return
+     */
+    public List<Money> useAtomicReference() {
         CompletionService executor = TaskExecutorPool.createCompletionService();
-        List<Future<Money>> moeyListOne = Collections.synchronizedList(Lists.newLinkedList());
 
-        rateListOne.forEach(rate -> executeFuture(executor, moeyListOne, rate));
-        rateListTwo.forEach(rate -> executeFuture(executor, moeyListOne, rate));
+        Rate rate = new Rate("AtomicTest", "AT", 0.0);
+        List<Money> listOfMoney = getListOfMoney();
+
+
+        moneyAtomic.set(new Money(new BigDecimal(0.0), rate));
+        listOfMoney.forEach(money -> executeFuture(executor, money, rate, moneyAtomic));
 
         List<Money> moneyList = new ArrayList<>();
-        moeyListOne.forEach(r -> mountListOfMoney(r, moneyList));
+        moeyList.forEach(r -> mountListOfMoney(r, moneyList));
         return moneyList;
 
     }
 
-    private void executeFuture(CompletionService executor, List<Future<Money>> result, Rate rate) {
-        Future thread = executor.submit(new TaskMoneyCallable(rate));
-        result.add(thread);
+    /**
+     * endpoint para ser usado no exercício de map reduce
+     * @return
+     */
+    public List<Money> getListOfMoney() {
+        List<Money> moneyList = Lists.newLinkedList();
+        rateService.getRates().forEach(rate -> {
+            BigDecimal min = new BigDecimal(100.0);
+            BigDecimal max = new BigDecimal(2000.0);
+            BigDecimal randomBigDecimal = min.add(new BigDecimal(Math.random()).multiply(max.subtract(min)));
+            moneyList.add(new Money(randomBigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP), rate));
+        });
+        return moneyList;
+    }
+
+    private void executeFuture(CompletionService executor, Money money, Rate rate, AtomicReference<Money> moneyAtomic) {
+        Future thread = executor.submit(new TaskMoneyCallable(money, rate, moneyAtomic));
+        moeyList.add(thread);
     }
 
     private synchronized void mountListOfMoney(Future<Money> r, List<Money> moneyList) {

src/main/java/br/com/db1/task/TaskMoneyCallable.java

@@ -3,30 +3,29 @@
 import br.com.db1.model.Money;
 import br.com.db1.model.Rate;
 
-import java.math.BigDecimal;
 import java.util.concurrent.Callable;
 import java.util.concurrent.atomic.AtomicReference;
 
-public class TaskMoneyCallable implements Callable<AtomicReference<Money>> {
+/**
+ * Classe para o controle da concorrência
+ */
+public class TaskMoneyCallable implements Callable<Money> {
 
-    private Rate rate;
+    private Money money;
+
+    private AtomicReference<Money> moneyAtomic;
 
-    private AtomicReference<Money> money = new AtomicReference<>();
+    private Rate rate;
 
-    public TaskMoneyCallable(Rate rate) {
+    public TaskMoneyCallable(Money money, Rate rate, AtomicReference<Money> moneyAtomic) {
+        this.money = money;
         this.rate = rate;
+        this.moneyAtomic = moneyAtomic;
     }
 
     @Override
-    public AtomicReference<Money> call() throws Exception {
-        money.set(new Money(generateRandomBigDecimalFromRange(), rate));
-        return money;
-    }
-
-    public static BigDecimal generateRandomBigDecimalFromRange() {
-        BigDecimal min = new BigDecimal(100.0);
-        BigDecimal max = new BigDecimal(2000.0);
-        BigDecimal randomBigDecimal = min.add(new BigDecimal(Math.random()).multiply(max.subtract(min)));
-        return randomBigDecimal.setScale(2,BigDecimal.ROUND_HALF_UP);
+    public Money call() throws Exception {
+        return this.moneyAtomic.accumulateAndGet(new Money(money.getValue(), rate), (money1, money2) ->
+                new Money(money1.getValue().add(money2.getValue()), rate));
     }
 }