From a4e4aff755a3a34f1e3084c0f29f7eb9ccb968d5 Mon Sep 17 00:00:00 2001 From: Sechkin Cholak Date: Tue, 31 Oct 2023 06:34:05 +0200 Subject: [PATCH] #1 Stop counter thread and #2 Two counter threads and refactored #7 Calculator from Design-patterns --- .../designpatterns/calculator/Calculator.java | 73 ++++++++-------- .../calculator/CalculatorApp.java | 52 ++++-------- .../calculator/RPNEvaluator.java | 83 ++++++++++++++++++- .../calculator/commands/AddCommand.java | 15 ++-- .../calculator/commands/Command.java | 2 +- .../calculator/commands/DivisionCommand.java | 18 ++-- .../commands/ExponentiateCommand.java | 17 ++-- .../calculator/commands/MultiplyCommand.java | 15 ++-- .../calculator/commands/SubtractCommand.java | 15 ++-- .../calculator/CalculatorAppTest.java | 33 +++----- .../calculator/CalculatorTest.java | 17 +++- .../calculator/RPNEvaluatorTest.java | 25 +++++- .../designpatterns/singleton/Neo4jTest.java | 34 +++++++- pom.xml | 1 + .../ontotext/javacourse/threads/Runner.java | 12 ++- .../com/ontotext/javacourse/threads/Test.java | 5 +- .../threads/stopcounterthread/Counter.java | 29 ++++++- .../stopcounterthread/CounterRunnable.java | 25 +++++- .../twocounterthreads/InterruptThread.java | 30 ++++++- .../twocounterthreads/TwoCounterThreads.java | 12 ++- 20 files changed, 358 insertions(+), 155 deletions(-) diff --git a/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/Calculator.java b/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/Calculator.java index 01a1563..e5f7552 100644 --- a/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/Calculator.java +++ b/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/Calculator.java @@ -1,46 +1,53 @@ package com.ontotext.javacourse.designpatterns.calculator; -import lombok.NoArgsConstructor; +import com.ontotext.javacourse.designpatterns.calculator.commands.*; +import java.util.ArrayDeque; +import java.util.Deque; +import java.util.List; /** - * Defines a calculator that can perform addition,subtraction,multiplication,division and - * exponentiation and return the result. + * The Calculator class contains a method that takes a given reverse polish notation expression and + * returns its result. */ -@NoArgsConstructor -public class Calculator { - private double result; - private double operand; +public final class Calculator { - public void setOperand(double operand) { - this.operand = operand; + private Calculator() throws IllegalAccessException { + throw new IllegalAccessException("Calculator class is not meant to be instantiated!"); } - public void add() { - result += operand; - } - - public void subtract() { - result -= operand; - } - - public void multiply() { - result *= operand; - } - - /** Divides the result by the given operand if the divisor is not zero. */ - public void divide() { - if (operand == 0) { - System.out.println("Division by zero!"); - } else { - result /= operand; + /** + * Evaluates the given expression. + * + * @param reversePolishNotationExpression the reverse polish notation expression + * @return the result of the expression + */ + public static double evaluateExpression(List reversePolishNotationExpression) { + Deque stack = new ArrayDeque<>(); + double firstOperand; + double secondOperand; + Double result; + for (String item : reversePolishNotationExpression) { + if (RPNEvaluator.isNumeric(item)) { + stack.push(Double.parseDouble(item)); + } else { + secondOperand = stack.pop(); + firstOperand = stack.pop(); + Command command = getCommand(item); + result = command.execute(firstOperand, secondOperand); + stack.push(result); + } } + return stack.pop(); } - public void exponentiate() { - result = Math.pow(result, operand); - } - - public double getResult() { - return this.result; + private static Command getCommand(String action) { + return switch (action) { + case "+" -> new AddCommand(); + case "-" -> new SubtractCommand(); + case "*" -> new MultiplyCommand(); + case "/" -> new DivisionCommand(); + case "^" -> new ExponentiateCommand(); + default -> throw new IllegalArgumentException("Action is invalid!"); + }; } } diff --git a/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/CalculatorApp.java b/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/CalculatorApp.java index 83ad7a8..7b8ebb3 100644 --- a/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/CalculatorApp.java +++ b/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/CalculatorApp.java @@ -1,50 +1,28 @@ package com.ontotext.javacourse.designpatterns.calculator; -import com.ontotext.javacourse.designpatterns.calculator.commands.*; -import java.security.InvalidParameterException; +import java.util.Arrays; +import java.util.List; +import java.util.Scanner; /** - * The CalculatorApp class contains a method that starts the calculator and begins to accept - * operation and executes them. + * The CalculatorApp class contains a method that starts the calculator and accepts an expression as + * input. */ public class CalculatorApp { - private final CalculatorView calculatorView; - private final Calculator calculator; - private final CalculatorInvoker calculatorInvoker; + private final Scanner scanner; - public CalculatorApp(Calculator calculator) { - calculatorView = new CalculatorView(); - this.calculator = calculator; - calculatorInvoker = new CalculatorInvoker(); + public CalculatorApp() { + scanner = new Scanner(System.in); } /** Starts accepting user input from the console. */ public void startCalculator() { - calculatorView.displayAvailableCommands(); - double startingNumber = calculatorView.promptNumberInput(); - calculatorInvoker.setCommand(new AddCommand(this.calculator, startingNumber)); - calculatorInvoker.executeCommand(); - int operationNumber = calculatorView.promptOperationNumber(); - double operand = 0; - while (operationNumber != 6) { - operand = calculatorView.promptNumberInput(); - Command command = getOperationCommand(operationNumber, operand); - calculatorInvoker.setCommand(command); - calculatorInvoker.executeCommand(); - calculatorView.displayCurrentResult(calculator.getResult()); - operationNumber = calculatorView.promptOperationNumber(); - } - calculatorView.displayEndResult(calculator.getResult()); - } - - private Command getOperationCommand(int operationNumber, double operand) { - return switch (operationNumber) { - case 1 -> new AddCommand(this.calculator, operand); - case 2 -> new SubtractCommand(this.calculator, operand); - case 3 -> new MultiplyCommand(this.calculator, operand); - case 4 -> new DivisionCommand(this.calculator, operand); - case 5 -> new ExponentiateCommand(this.calculator, operand); - default -> throw new InvalidParameterException("Invalid operand number!"); - }; + System.out.println("Enter an expression with a space between each number and symbol:"); + String input = scanner.nextLine(); + List expression = Arrays.stream(input.split(" ")).toList(); + List reversePolishNotationExpression = + RPNEvaluator.getReversePolishNotation(expression); + double result = Calculator.evaluateExpression(reversePolishNotationExpression); + System.out.printf("Result: %.2f%n", result); } } diff --git a/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/RPNEvaluator.java b/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/RPNEvaluator.java index 4452d0e..8c6e4d0 100644 --- a/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/RPNEvaluator.java +++ b/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/RPNEvaluator.java @@ -1,2 +1,83 @@ -package com.ontotext.javacourse.designpatterns.calculator;public class RPNEvaluator { +package com.ontotext.javacourse.designpatterns.calculator; + +import java.util.*; + +/** + * The RPNEvaluator class contains methods that return the reverse polish notation of a given + * expression. + */ +public final class RPNEvaluator { + private RPNEvaluator() throws IllegalAccessException { + throw new IllegalAccessException("RPNEvaluator class is not meant to be instantiated!"); + } + + public static List getReversePolishNotation(List expression) { + return transformExpression(expression); + } + + /** + * Determines whether the given item is a valid number. + * + * @param item the item which to check the type of + * @return whether the item is a valid number or not. + */ + public static boolean isNumeric(String item) { + try { + Double.parseDouble(item); + return true; + } catch (NumberFormatException exception) { + return false; + } + } + + private static List transformExpression(List expression) { + if (expression.isEmpty()) { + throw new IllegalArgumentException("Empty input!"); + } + Deque stack = new ArrayDeque<>(); + List output = new ArrayList<>(); + for (String item : expression) { + if (isNumeric(item)) { + output.add(item); + } else if (item.equals("(")) { + stack.push(item); + } else if (item.equals(")")) { + while (!stack.isEmpty() && !stack.peek().equals("(")) { + output.add(stack.pop()); + } + stack.pop(); + } else { + while (!stack.isEmpty() + && getPrecedence(item) <= getPrecedence(stack.peek()) + && hasLeftAssociativity(item)) { + output.add(stack.pop()); + } + stack.push(item); + } + } + emptyStack(stack, output); + return output; + } + + private static int getPrecedence(String item) { + return switch (item) { + case "+", "-" -> 1; + case "*", "/" -> 2; + case "^" -> 3; + default -> -1; + }; + } + + private static boolean hasLeftAssociativity(String item) { + return item.equals("+") || item.equals("-") || item.equals("/") || item.equals("*"); + } + + private static void emptyStack(Deque stack, List output) { + while (!stack.isEmpty()) { + if (stack.peek().equals("(")) { + throw new IllegalArgumentException("This expression is invalid"); + } + output.add(stack.pop()); + } + } } diff --git a/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/AddCommand.java b/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/AddCommand.java index 606eab6..3177708 100644 --- a/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/AddCommand.java +++ b/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/AddCommand.java @@ -1,16 +1,13 @@ package com.ontotext.javacourse.designpatterns.calculator.commands; -import com.ontotext.javacourse.designpatterns.calculator.Calculator; +import lombok.NoArgsConstructor; -/** The AddCommand class is a command that executes the addition operation. */ -public class AddCommand extends BaseOperation { - - public AddCommand(Calculator calculator, double operand) { - super(calculator, operand); - } +/** The AddCommand class is a command that adds two given operands. */ +@NoArgsConstructor +public class AddCommand implements Command { @Override - public void execute() { - super.getCalculator().add(); + public Double execute(Double firstOperand, Double secondOperand) { + return firstOperand + secondOperand; } } diff --git a/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/Command.java b/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/Command.java index 8ec7361..fab6870 100644 --- a/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/Command.java +++ b/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/Command.java @@ -2,5 +2,5 @@ /** Defines a command that can be executed. */ public interface Command { - public void execute(); + Double execute(Double firstOperand, Double secondOperand); } diff --git a/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/DivisionCommand.java b/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/DivisionCommand.java index 7ecdcdc..7be75da 100644 --- a/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/DivisionCommand.java +++ b/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/DivisionCommand.java @@ -1,16 +1,16 @@ package com.ontotext.javacourse.designpatterns.calculator.commands; -import com.ontotext.javacourse.designpatterns.calculator.Calculator; +import lombok.NoArgsConstructor; -/** The DivisionCommand class is a command that executes the division operation. */ -public class DivisionCommand extends BaseOperation { - - public DivisionCommand(Calculator calculator, double operand) { - super(calculator, operand); - } +/** The DivisionCommand class is a command that divides two given operands. */ +@NoArgsConstructor +public class DivisionCommand implements Command { @Override - public void execute() { - super.getCalculator().divide(); + public Double execute(Double firstOperand, Double secondOperand) { + if (secondOperand == 0) { + throw new IllegalArgumentException("Division by zero!"); + } + return firstOperand / secondOperand; } } diff --git a/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/ExponentiateCommand.java b/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/ExponentiateCommand.java index a05ea62..4a77804 100644 --- a/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/ExponentiateCommand.java +++ b/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/ExponentiateCommand.java @@ -1,17 +1,12 @@ package com.ontotext.javacourse.designpatterns.calculator.commands; -import com.ontotext.javacourse.designpatterns.calculator.Calculator; - -/** - * The ExponentiateCommand class is a command that raises the current result to a given exponent. - */ -public class ExponentiateCommand extends BaseOperation { - public ExponentiateCommand(Calculator calculator, double operand) { - super(calculator, operand); - } +import lombok.NoArgsConstructor; +/** The ExponentiateCommand class is a command that exponentiates two given operands. */ +@NoArgsConstructor +public class ExponentiateCommand implements Command { @Override - public void execute() { - super.getCalculator().exponentiate(); + public Double execute(Double firstOperand, Double secondOperand) { + return Math.pow(firstOperand, secondOperand); } } diff --git a/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/MultiplyCommand.java b/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/MultiplyCommand.java index 57aae84..ec5a62f 100644 --- a/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/MultiplyCommand.java +++ b/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/MultiplyCommand.java @@ -1,15 +1,12 @@ package com.ontotext.javacourse.designpatterns.calculator.commands; -import com.ontotext.javacourse.designpatterns.calculator.Calculator; - -/** The MultiplyCommand class is a command that executes the multiplication operation. */ -public class MultiplyCommand extends BaseOperation { - public MultiplyCommand(Calculator calculator, double operand) { - super(calculator, operand); - } +import lombok.NoArgsConstructor; +/** The MultiplyCommand class is a command that multiplies two given operands. */ +@NoArgsConstructor +public class MultiplyCommand implements Command { @Override - public void execute() { - super.getCalculator().multiply(); + public Double execute(Double firstOperand, Double secondOperand) { + return firstOperand * secondOperand; } } diff --git a/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/SubtractCommand.java b/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/SubtractCommand.java index d1774a2..7c92885 100644 --- a/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/SubtractCommand.java +++ b/design-patterns/src/main/java/com/ontotext/javacourse/designpatterns/calculator/commands/SubtractCommand.java @@ -1,15 +1,12 @@ package com.ontotext.javacourse.designpatterns.calculator.commands; -import com.ontotext.javacourse.designpatterns.calculator.Calculator; - -/** The SubtractCommand class is a command that executes the subtraction operation. */ -public class SubtractCommand extends BaseOperation { - public SubtractCommand(Calculator calculator, double operand) { - super(calculator, operand); - } +import lombok.NoArgsConstructor; +/** The SubtractCommand class is a command that subtracts two given operands. */ +@NoArgsConstructor +public class SubtractCommand implements Command { @Override - public void execute() { - super.getCalculator().subtract(); + public Double execute(Double firstOperand, Double secondOperand) { + return firstOperand - secondOperand; } } diff --git a/design-patterns/src/test/java/com/ontotext/javacourse/designpatterns/calculator/CalculatorAppTest.java b/design-patterns/src/test/java/com/ontotext/javacourse/designpatterns/calculator/CalculatorAppTest.java index b5a284a..2f5ffd7 100644 --- a/design-patterns/src/test/java/com/ontotext/javacourse/designpatterns/calculator/CalculatorAppTest.java +++ b/design-patterns/src/test/java/com/ontotext/javacourse/designpatterns/calculator/CalculatorAppTest.java @@ -3,35 +3,28 @@ import static org.junit.jupiter.api.Assertions.*; import java.io.ByteArrayInputStream; -import java.io.InputStream; -import java.security.InvalidParameterException; +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; import org.junit.jupiter.api.Test; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.ValueSource; class CalculatorAppTest { private CalculatorApp calculatorApp; + private ByteArrayInputStream inputStream; + private ByteArrayOutputStream outputStream; @Test - void startCalculatorExecutesUserOperationsCorrectly() { - ByteArrayInputStream input = new ByteArrayInputStream("10\n1\n20\n6".getBytes()); - Calculator calculator = new Calculator(); - setUp(input, calculator); + void startCalculatorTakesInputAndDisplaysExpressionResultCorrectly() { + setUp("( 2 + 10 ) * 3 / 2"); calculatorApp.startCalculator(); - assertEquals(30, calculator.getResult()); + String consoleOutput = outputStream.toString().trim(); + assertTrue(consoleOutput.contains("18.00")); } - @ParameterizedTest - @ValueSource(strings = {"0", "-2", "100"}) - void startCalculatorThrowsExceptionIfInvalidOperationNumberIsGiven(String operationNumber) { - ByteArrayInputStream input = - new ByteArrayInputStream(("10\n" + operationNumber + "\n20\n6").getBytes()); - setUp(input, new Calculator()); - assertThrows(InvalidParameterException.class, () -> calculatorApp.startCalculator()); - } - - private void setUp(InputStream inputStream, Calculator calculator) { + private void setUp(String inputString) { + inputStream = new ByteArrayInputStream(inputString.getBytes()); + outputStream = new ByteArrayOutputStream(); System.setIn(inputStream); - calculatorApp = new CalculatorApp(calculator); + System.setOut(new PrintStream(outputStream)); + calculatorApp = new CalculatorApp(); } } diff --git a/design-patterns/src/test/java/com/ontotext/javacourse/designpatterns/calculator/CalculatorTest.java b/design-patterns/src/test/java/com/ontotext/javacourse/designpatterns/calculator/CalculatorTest.java index 441a82e..5ce7105 100644 --- a/design-patterns/src/test/java/com/ontotext/javacourse/designpatterns/calculator/CalculatorTest.java +++ b/design-patterns/src/test/java/com/ontotext/javacourse/designpatterns/calculator/CalculatorTest.java @@ -1,10 +1,21 @@ package com.ontotext.javacourse.designpatterns.calculator; +import static org.junit.jupiter.api.Assertions.*; + +import java.util.List; import org.junit.jupiter.api.Test; -import static org.junit.jupiter.api.Assertions.*; class CalculatorTest { @Test - void evaluateExpression() {} -} \ No newline at end of file + void evaluateExpressionReturnsCorrectExpressionResult() { + assertEquals(1296, Calculator.evaluateExpression(List.of("10", "2", "+", "3", "*", "2", "^"))); + } + + @Test + void evaluateExpressionThrowsExceptionWhenDivisionByZero() { + assertThrows( + IllegalArgumentException.class, + () -> Calculator.evaluateExpression(List.of("2", "0", "/"))); + } +} diff --git a/design-patterns/src/test/java/com/ontotext/javacourse/designpatterns/calculator/RPNEvaluatorTest.java b/design-patterns/src/test/java/com/ontotext/javacourse/designpatterns/calculator/RPNEvaluatorTest.java index 7c51aaa..de5a4dd 100644 --- a/design-patterns/src/test/java/com/ontotext/javacourse/designpatterns/calculator/RPNEvaluatorTest.java +++ b/design-patterns/src/test/java/com/ontotext/javacourse/designpatterns/calculator/RPNEvaluatorTest.java @@ -1,10 +1,29 @@ package com.ontotext.javacourse.designpatterns.calculator; +import static org.junit.jupiter.api.Assertions.*; + +import java.util.List; import org.junit.jupiter.api.Test; -import static org.junit.jupiter.api.Assertions.*; class RPNEvaluatorTest { @Test - void getReversePolishNotation() {} -} \ No newline at end of file + void getReversePolishNotationReturnsRPNOfExpressionCorrectly() { + assertEquals( + List.of("1", "3", "+", "4", "/"), + RPNEvaluator.getReversePolishNotation(List.of("(", "1", "+", "3", ")", "/", "4"))); + } + + @Test + void getReversePolishNotationThrowsExceptionIfParenthesisIsLeftOpen() { + assertThrows( + IllegalArgumentException.class, + () -> RPNEvaluator.getReversePolishNotation(List.of("(", "1", "+", "3"))); + } + + @Test + void getReversePolishNotationThrowsExceptionIfExpressionIsEmpty() { + assertThrows( + IllegalArgumentException.class, () -> RPNEvaluator.getReversePolishNotation(List.of())); + } +} diff --git a/design-patterns/src/test/java/com/ontotext/javacourse/designpatterns/singleton/Neo4jTest.java b/design-patterns/src/test/java/com/ontotext/javacourse/designpatterns/singleton/Neo4jTest.java index c32f3a9..b86fda3 100644 --- a/design-patterns/src/test/java/com/ontotext/javacourse/designpatterns/singleton/Neo4jTest.java +++ b/design-patterns/src/test/java/com/ontotext/javacourse/designpatterns/singleton/Neo4jTest.java @@ -1,10 +1,16 @@ package com.ontotext.javacourse.designpatterns.singleton; -import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import java.net.URL; +import org.eclipse.rdf4j.query.QueryEvaluationException; +import org.eclipse.rdf4j.query.QueryLanguage; +import org.eclipse.rdf4j.query.TupleQuery; +import org.eclipse.rdf4j.query.TupleQueryResult; +import org.eclipse.rdf4j.repository.Repository; import org.eclipse.rdf4j.repository.RepositoryConnection; +import org.eclipse.rdf4j.repository.http.HTTPRepository; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; import org.testcontainers.containers.Neo4jContainer; @@ -27,11 +33,31 @@ static void setUp() { } @Test - void testNeo4jConnection() throws IOException { - // Fix method + void testNeo4jConnectionFALSE() throws IOException { URL url = new URL(NEO4J_URL + "/browser/"); RepositoryConnection connection = DatabaseConnection.getInstance(url.getPath(), "neo4j-container").getConnection(); - assertEquals(200, 200); +connection.prepareTupleQuery(QueryLanguage.SPARQL,""); + assertTrue(true); + } + + @Test + void testNeo4jConnection() throws IOException { + URL url = new URL(NEO4J_URL); + + // Create an RDF4J repository connection to the Neo4j endpoint + Repository repository = new HTTPRepository(url.toString()); + repository.init(); + + try (RepositoryConnection connection = repository.getConnection()) { + // Perform a SPARQL SELECT query + String query = "SELECT ?s ?p ?o WHERE { ?s ?p ?o } LIMIT 10"; // Example query + TupleQuery tupleQuery = connection.prepareTupleQuery(QueryLanguage.SPARQL, query); + try (TupleQueryResult result = tupleQuery.evaluate()) { + assertTrue(result.hasNext()); // Ensure there are results + } + } catch (QueryEvaluationException e) { + e.printStackTrace(); // Handle query execution errors + } } } diff --git a/pom.xml b/pom.xml index 46c9601..cebe590 100644 --- a/pom.xml +++ b/pom.xml @@ -25,6 +25,7 @@ input-output collections design-patterns + threads diff --git a/threads/src/main/java/com/ontotext/javacourse/threads/Runner.java b/threads/src/main/java/com/ontotext/javacourse/threads/Runner.java index de5efab..1ee00ce 100644 --- a/threads/src/main/java/com/ontotext/javacourse/threads/Runner.java +++ b/threads/src/main/java/com/ontotext/javacourse/threads/Runner.java @@ -1,2 +1,12 @@ -package com.ontotext.javacourse.threads;public class Runner { +package com.ontotext.javacourse.threads; + +import com.ontotext.javacourse.threads.twocounterthreads.TwoCounterThreads; + +public class Runner { + public static void main(String[] args) { + + + TwoCounterThreads threads = new TwoCounterThreads(); + threads.start(); + } } diff --git a/threads/src/main/java/com/ontotext/javacourse/threads/Test.java b/threads/src/main/java/com/ontotext/javacourse/threads/Test.java index 67ca1d8..12e66a4 100644 --- a/threads/src/main/java/com/ontotext/javacourse/threads/Test.java +++ b/threads/src/main/java/com/ontotext/javacourse/threads/Test.java @@ -1,2 +1,5 @@ -package com.ontotext.javacourse.threads;public class Test { +package com.ontotext.javacourse.threads; + +public class Test { + } diff --git a/threads/src/main/java/com/ontotext/javacourse/threads/stopcounterthread/Counter.java b/threads/src/main/java/com/ontotext/javacourse/threads/stopcounterthread/Counter.java index a2191ea..be4345a 100644 --- a/threads/src/main/java/com/ontotext/javacourse/threads/stopcounterthread/Counter.java +++ b/threads/src/main/java/com/ontotext/javacourse/threads/stopcounterthread/Counter.java @@ -1,2 +1,29 @@ -package com.ontotext.javacourse.threads.stopcounterthread;public class Counter { +package com.ontotext.javacourse.threads.stopcounterthread; + +import java.util.Scanner; + +/** + * The Counter class contains a method that starts a thread that counts on every second and + * interrupts it when user input is given. + */ +public final class Counter { + private static final Scanner scanner = new Scanner(System.in); + + private Counter() throws IllegalAccessException { + throw new IllegalAccessException("Counter class is not meant to be instantiated!"); + } + + /** Starts the counter thread. */ + public static void start() { + System.out.println("Enter count:"); + int count = scanner.nextInt(); + scanner.nextLine(); + CounterRunnable runnable = new CounterRunnable(count); + Thread counterThread = new Thread(runnable); + counterThread.start(); + System.out.println("Enter any symbol to stop the counting thread:"); + scanner.nextLine(); + counterThread.interrupt(); + System.out.println("Thread is stopped!"); + } } diff --git a/threads/src/main/java/com/ontotext/javacourse/threads/stopcounterthread/CounterRunnable.java b/threads/src/main/java/com/ontotext/javacourse/threads/stopcounterthread/CounterRunnable.java index 9b7f1c7..875873e 100644 --- a/threads/src/main/java/com/ontotext/javacourse/threads/stopcounterthread/CounterRunnable.java +++ b/threads/src/main/java/com/ontotext/javacourse/threads/stopcounterthread/CounterRunnable.java @@ -1,2 +1,25 @@ -package com.ontotext.javacourse.threads.stopcounterthread;public class CounterRunnable { +package com.ontotext.javacourse.threads.stopcounterthread; + +import lombok.AllArgsConstructor; + +/** + * The CounterRunnable class defines a runnable that counts on every second until a configured + * count is reached. + */ +@AllArgsConstructor +public class CounterRunnable implements Runnable { + private final int count; + + @Override + public void run() { + for (int i = 1; i <= this.count; i++) { + System.out.println("Current count: " + i); + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + System.out.println("Thread has been interrupted!"); + return; + } + } + } } diff --git a/threads/src/main/java/com/ontotext/javacourse/threads/twocounterthreads/InterruptThread.java b/threads/src/main/java/com/ontotext/javacourse/threads/twocounterthreads/InterruptThread.java index 9e68c89..2c8689b 100644 --- a/threads/src/main/java/com/ontotext/javacourse/threads/twocounterthreads/InterruptThread.java +++ b/threads/src/main/java/com/ontotext/javacourse/threads/twocounterthreads/InterruptThread.java @@ -1,2 +1,30 @@ -package com.ontotext.javacourse.threads.twocounterthreads;public class InterruptThread { +package com.ontotext.javacourse.threads.twocounterthreads; + +public class InterruptThread extends Thread { + private final int count; + private Thread otherThread; + + public InterruptThread(int count) { + this.count = count; + } + + public void setOtherThread(Thread thread) { + this.otherThread = thread; + } + + @Override + public void run() { + int startCount = 0; + while (startCount <= count) { + System.out.printf("%s count is: %d%n", Thread.currentThread().getName(), startCount); + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + System.out.printf("%s has been interrupted!%n", Thread.currentThread().getName()); + return; + } + startCount++; + } + otherThread.interrupt(); + } } diff --git a/threads/src/main/java/com/ontotext/javacourse/threads/twocounterthreads/TwoCounterThreads.java b/threads/src/main/java/com/ontotext/javacourse/threads/twocounterthreads/TwoCounterThreads.java index 99a65b1..f1f5923 100644 --- a/threads/src/main/java/com/ontotext/javacourse/threads/twocounterthreads/TwoCounterThreads.java +++ b/threads/src/main/java/com/ontotext/javacourse/threads/twocounterthreads/TwoCounterThreads.java @@ -1,2 +1,12 @@ -package com.ontotext.javacourse.threads.twocounterthreads;public class TwoCounterThreads { +package com.ontotext.javacourse.threads.twocounterthreads; + +public class TwoCounterThreads { + public void start() { + InterruptThread firstThread = new InterruptThread(10); + InterruptThread secondThread = new InterruptThread(5); + firstThread.setOtherThread(secondThread); + secondThread.setOtherThread(firstThread); + firstThread.start(); + secondThread.start(); + } }