diff --git a/leader-followers/README.md b/leader-followers/README.md new file mode 100644 index 0000000000000000000000000000000000000000..fa355644a55d2019b91153b86d3b519c5d472bbc --- /dev/null +++ b/leader-followers/README.md @@ -0,0 +1,32 @@ +--- +layout: pattern +title: Leader/Followers +folder: leader-followers +permalink: /patterns/leader-followers/ +categories: Concurrency +tags: + - Performance +--- + +## Intent +The Leader/Followers pattern provides a concurrency model where multiple +threads can efficiently de-multiplex events and dispatch event handlers +that process I/O handles shared by the threads. + +## Class diagram +![Leader/Followers class diagram](./etc/leader-followers.png) + +## Applicability +Use Leader-Followers pattern when + +* multiple threads take turns sharing a set of event sources in order to detect, de-multiplex, dispatch and process service requests that occur on the event sources. + +## Real world examples + +* [ACE Thread Pool Reactor framework](https://www.dre.vanderbilt.edu/~schmidt/PDF/HPL.pdf) +* [JAWS](http://www.dre.vanderbilt.edu/~schmidt/PDF/PDCP.pdf) +* [Real-time CORBA](http://www.dre.vanderbilt.edu/~schmidt/PDF/RTS.pdf) + +## Credits + +* [Douglas C. Schmidt and Carlos O’Ryan - Leader/Followers](http://www.kircher-schwanninger.de/michael/publications/lf.pdf) diff --git a/leader-followers/etc/leader-followers.png b/leader-followers/etc/leader-followers.png new file mode 100644 index 0000000000000000000000000000000000000000..de8efd9f0b6bfb6a897bfc70f8be53450dfa428c Binary files /dev/null and b/leader-followers/etc/leader-followers.png differ diff --git a/leader-followers/etc/leader-followers.urm.puml b/leader-followers/etc/leader-followers.urm.puml new file mode 100644 index 0000000000000000000000000000000000000000..fc674a518aa89cba8ceed52af6a3b56dbec04ff7 --- /dev/null +++ b/leader-followers/etc/leader-followers.urm.puml @@ -0,0 +1,54 @@ +@startuml +package com.iluwatar.leaderfollowers { + class App { + + App() + - addTasks(taskSet : TaskSet) {static} + - execute(workCenter : WorkCenter, taskSet : TaskSet) {static} + + main(args : String[]) {static} + } + class Task { + - finished : boolean + - time : int + + Task(time : int) + + getTime() : int + + isFinished() : boolean + + setFinished() + } + class TaskHandler { + + TaskHandler() + + handleTask(task : Task) + } + class TaskSet { + - queue : BlockingQueue + + TaskSet() + + addTask(task : Task) + + getSize() : int + + getTask() : Task + } + class WorkCenter { + - leader : Worker + - workers : List + + WorkCenter() + + addWorker(worker : Worker) + + createWorkers(numberOfWorkers : int, taskSet : TaskSet, taskHandler : TaskHandler) + + getLeader() : Worker + + getWorkers() : List + + promoteLeader() + + removeWorker(worker : Worker) + } + class Worker { + - id : long + - taskHandler : TaskHandler + - taskSet : TaskSet + - workCenter : WorkCenter + + Worker(id : long, workCenter : WorkCenter, taskSet : TaskSet, taskHandler : TaskHandler) + + equals(o : Object) : boolean + + hashCode() : int + + run() + } +} +Worker --> "-taskSet" TaskSet +Worker --> "-taskHandler" TaskHandler +TaskSet --> "-queue" Task +Worker --> "-workCenter" WorkCenter +@enduml \ No newline at end of file diff --git a/leader-followers/pom.xml b/leader-followers/pom.xml new file mode 100644 index 0000000000000000000000000000000000000000..4efdbf3ac61a67a1c09336ffeb53f443cbb0f280 --- /dev/null +++ b/leader-followers/pom.xml @@ -0,0 +1,46 @@ + + + + 4.0.0 + + com.iluwatar + java-design-patterns + 1.23.0-SNAPSHOT + + leader-followers + + + junit + junit + test + + + org.mockito + mockito-core + test + + + \ No newline at end of file diff --git a/leader-followers/src/main/java/com.iluwatar.leaderfollowers/App.java b/leader-followers/src/main/java/com.iluwatar.leaderfollowers/App.java new file mode 100644 index 0000000000000000000000000000000000000000..2a4d716ef9de3151948ed84fd509afb512199d41 --- /dev/null +++ b/leader-followers/src/main/java/com.iluwatar.leaderfollowers/App.java @@ -0,0 +1,93 @@ +/* + * The MIT License + * Copyright © 2014-2019 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +package com.iluwatar.leaderfollowers; + +import java.util.Random; +import java.util.concurrent.Executors; +import java.util.concurrent.TimeUnit; + +/** + * Leader/Followers pattern is a concurrency pattern. This pattern behaves like a taxi stand where + * one of the threads acts as leader thread which listens for event from event sources, + * de-multiplexes, dispatches and handles the event. It promotes the follower to be the new leader. + * When processing completes the thread joins the followers queue, if there are no followers then it + * becomes the leader and cycle repeats again. + * + *

In this example, one of the workers becomes Leader and listens on the {@link TaskSet} for + * work. {@link TaskSet} basically acts as the source of input events for the {@link Worker}, who + * are spawned and controlled by the {@link WorkCenter} . When {@link Task} arrives then the leader + * takes the work and calls the {@link TaskHandler}. It also calls the {@link WorkCenter} to + * promotes one of the followers to be the new leader, who can then process the next work and so + * on. + * + *

The pros for this pattern are: + * It enhances CPU cache affinity and eliminates unbound allocation and data buffer sharing between + * threads by reading the request into buffer space allocated on the stack of the leader or by using + * the Thread-Specific Storage pattern [22] to allocate memory. It minimizes locking overhead by not + * exchanging data between threads, thereby reducing thread synchronization. In bound handle/thread + * associations, the leader thread dispatches the event based on the I/O handle. It can minimize + * priority inversion because no extra queuing is introduced in the server. It does not require a + * context switch to handle each event, reducing the event dispatching latency. Note that promoting + * a follower thread to fulfill the leader role requires a context switch. Programming simplicity: + * The Leader/Followers pattern simplifies the programming of concurrency models where multiple + * threads can receive requests, process responses, and de-multiplex connections using a shared + * handle set. + */ +public class App { + + /** + * The main method for the leader followers pattern. + */ + public static void main(String[] args) throws InterruptedException { + var taskSet = new TaskSet(); + var taskHandler = new TaskHandler(); + var workCenter = new WorkCenter(); + workCenter.createWorkers(4, taskSet, taskHandler); + execute(workCenter, taskSet); + } + + /** + * Start the work, dispatch tasks and stop the thread pool at last. + */ + private static void execute(WorkCenter workCenter, TaskSet taskSet) throws InterruptedException { + var workers = workCenter.getWorkers(); + var exec = Executors.newFixedThreadPool(workers.size()); + workers.forEach(exec::submit); + Thread.sleep(1000); + addTasks(taskSet); + exec.awaitTermination(2, TimeUnit.SECONDS); + exec.shutdownNow(); + } + + /** + * Add tasks. + */ + private static void addTasks(TaskSet taskSet) throws InterruptedException { + var rand = new Random(); + for (var i = 0; i < 5; i++) { + var time = Math.abs(rand.nextInt(1000)); + taskSet.addTask(new Task(time)); + } + } +} diff --git a/leader-followers/src/main/java/com.iluwatar.leaderfollowers/Task.java b/leader-followers/src/main/java/com.iluwatar.leaderfollowers/Task.java new file mode 100644 index 0000000000000000000000000000000000000000..7d91e40ccf520e1023e2c21dbe83e773959de9c1 --- /dev/null +++ b/leader-followers/src/main/java/com.iluwatar.leaderfollowers/Task.java @@ -0,0 +1,51 @@ +/* + * The MIT License + * Copyright © 2014-2019 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +package com.iluwatar.leaderfollowers; + +/** + * A unit of work to be processed by the Workers. + */ +public class Task { + + private final int time; + + private boolean finished; + + public Task(int time) { + this.time = time; + } + + public int getTime() { + return time; + } + + public void setFinished() { + this.finished = true; + } + + public boolean isFinished() { + return this.finished; + } + +} diff --git a/leader-followers/src/main/java/com.iluwatar.leaderfollowers/TaskHandler.java b/leader-followers/src/main/java/com.iluwatar.leaderfollowers/TaskHandler.java new file mode 100644 index 0000000000000000000000000000000000000000..5dfd67d69c9692603babdcc29a643ae0f310e73b --- /dev/null +++ b/leader-followers/src/main/java/com.iluwatar.leaderfollowers/TaskHandler.java @@ -0,0 +1,46 @@ +/* + * The MIT License + * Copyright © 2014-2019 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +package com.iluwatar.leaderfollowers; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * The TaskHandler is used by the {@link Worker} to process the newly arrived task. + */ +public class TaskHandler { + + private static final Logger LOGGER = LoggerFactory.getLogger(TaskHandler.class); + + /** + * This interface handles one task at a time. + */ + public void handleTask(Task task) throws InterruptedException { + var time = task.getTime(); + Thread.sleep(time); + LOGGER.info("It takes " + time + " milliseconds to finish the task"); + task.setFinished(); + } + +} diff --git a/leader-followers/src/main/java/com.iluwatar.leaderfollowers/TaskSet.java b/leader-followers/src/main/java/com.iluwatar.leaderfollowers/TaskSet.java new file mode 100644 index 0000000000000000000000000000000000000000..3138427a3280ab9b0c54d7fdff7b1dde289a1374 --- /dev/null +++ b/leader-followers/src/main/java/com.iluwatar.leaderfollowers/TaskSet.java @@ -0,0 +1,47 @@ +/* + * The MIT License + * Copyright © 2014-2019 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +package com.iluwatar.leaderfollowers; + +import java.util.concurrent.ArrayBlockingQueue; +import java.util.concurrent.BlockingQueue; + +/** + * A TaskSet is a collection of the tasks, the leader receives task from here. + */ +public class TaskSet { + + private BlockingQueue queue = new ArrayBlockingQueue<>(100); + + public void addTask(Task task) throws InterruptedException { + queue.put(task); + } + + public Task getTask() throws InterruptedException { + return queue.take(); + } + + public int getSize() { + return queue.size(); + } +} diff --git a/leader-followers/src/main/java/com.iluwatar.leaderfollowers/WorkCenter.java b/leader-followers/src/main/java/com.iluwatar.leaderfollowers/WorkCenter.java new file mode 100644 index 0000000000000000000000000000000000000000..7c63d95d244208656c11f37ef67625b5d6ba64ec --- /dev/null +++ b/leader-followers/src/main/java/com.iluwatar.leaderfollowers/WorkCenter.java @@ -0,0 +1,76 @@ +/* + * The MIT License + * Copyright © 2014-2019 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +package com.iluwatar.leaderfollowers; + +import java.util.List; +import java.util.concurrent.CopyOnWriteArrayList; + +/** + * A WorkCenter contains a leader and a list of idle workers. The leader is responsible for + * receiving work when it arrives. This class also provides a mechanism to promote a new leader. A + * worker once he completes his task will add himself back to the center. + */ +public class WorkCenter { + + private Worker leader; + private List workers = new CopyOnWriteArrayList<>(); + + /** + * Create workers and set leader. + */ + public void createWorkers(int numberOfWorkers, TaskSet taskSet, TaskHandler taskHandler) { + for (var id = 1; id <= numberOfWorkers; id++) { + var worker = new Worker(id, this, taskSet, taskHandler); + workers.add(worker); + } + promoteLeader(); + } + + public void addWorker(Worker worker) { + workers.add(worker); + } + + public void removeWorker(Worker worker) { + workers.remove(worker); + } + + public Worker getLeader() { + return leader; + } + + /** + * Promote a leader. + */ + public void promoteLeader() { + Worker leader = null; + if (workers.size() > 0) { + leader = workers.get(0); + } + this.leader = leader; + } + + public List getWorkers() { + return workers; + } +} diff --git a/leader-followers/src/main/java/com.iluwatar.leaderfollowers/Worker.java b/leader-followers/src/main/java/com.iluwatar.leaderfollowers/Worker.java new file mode 100644 index 0000000000000000000000000000000000000000..6912af89b6f5323524f7b3e369e5f37475a2ee4a --- /dev/null +++ b/leader-followers/src/main/java/com.iluwatar.leaderfollowers/Worker.java @@ -0,0 +1,96 @@ +/* + * The MIT License + * Copyright © 2014-2019 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +package com.iluwatar.leaderfollowers; + +import java.util.Objects; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class Worker implements Runnable { + + private static final Logger LOGGER = LoggerFactory.getLogger(Worker.class); + + private final long id; + private final WorkCenter workCenter; + private final TaskSet taskSet; + private final TaskHandler taskHandler; + + /** + * Constructor to create a worker which will take work from the work center. + */ + public Worker(long id, WorkCenter workCenter, TaskSet taskSet, TaskHandler taskHandler) { + super(); + this.id = id; + this.workCenter = workCenter; + this.taskSet = taskSet; + this.taskHandler = taskHandler; + } + + /** + * The leader thread listens for task. When task arrives, it promotes one of the followers to be + * the new leader. Then it handles the task and add himself back to work center. + */ + @Override + public void run() { + while (!Thread.interrupted()) { + try { + if (workCenter.getLeader() != null && !workCenter.getLeader().equals(this)) { + synchronized (workCenter) { + workCenter.wait(); + } + continue; + } + final Task task = taskSet.getTask(); + synchronized (workCenter) { + workCenter.removeWorker(this); + workCenter.promoteLeader(); + workCenter.notifyAll(); + } + taskHandler.handleTask(task); + LOGGER.info("The Worker with the ID " + id + " completed the task"); + workCenter.addWorker(this); + } catch (InterruptedException e) { + LOGGER.warn("Worker interrupted"); + return; + } + } + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof Worker)) { + return false; + } + var worker = (Worker) o; + return id == worker.id; + } + + @Override + public int hashCode() { + return Objects.hash(id); + } +} diff --git a/leader-followers/src/test/java/com.iluwatar.leaderfollowers/AppTest.java b/leader-followers/src/test/java/com.iluwatar.leaderfollowers/AppTest.java new file mode 100644 index 0000000000000000000000000000000000000000..00fbfe4d22fcfeb68f30291ab18fa09226bd56fc --- /dev/null +++ b/leader-followers/src/test/java/com.iluwatar.leaderfollowers/AppTest.java @@ -0,0 +1,41 @@ +/* + * The MIT License + * Copyright © 2014-2019 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +package com.iluwatar.leaderfollowers; + +import org.junit.Test; + +/** + * + * Application test + * + */ +public class AppTest { + + @Test + public void test() throws InterruptedException { + String[] args = {}; + App.main(args); + } + +} diff --git a/leader-followers/src/test/java/com.iluwatar.leaderfollowers/TaskHandlerTest.java b/leader-followers/src/test/java/com.iluwatar.leaderfollowers/TaskHandlerTest.java new file mode 100644 index 0000000000000000000000000000000000000000..9fb39c922b07583560ae4d68a6341ca94d448444 --- /dev/null +++ b/leader-followers/src/test/java/com.iluwatar.leaderfollowers/TaskHandlerTest.java @@ -0,0 +1,42 @@ +/* + * The MIT License + * Copyright © 2014-2019 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +package com.iluwatar.leaderfollowers; + +import org.junit.Assert; +import org.junit.Test; + +/** + * Tests for TaskHandler + */ +public class TaskHandlerTest { + + @Test + public void testHandleTask() throws InterruptedException { + var taskHandler = new TaskHandler(); + var handle = new Task(100); + taskHandler.handleTask(handle); + Assert.assertTrue(handle.isFinished()); + } + +} diff --git a/leader-followers/src/test/java/com.iluwatar.leaderfollowers/TaskSetTest.java b/leader-followers/src/test/java/com.iluwatar.leaderfollowers/TaskSetTest.java new file mode 100644 index 0000000000000000000000000000000000000000..53cb31deb43a45ece8015db1d410e3967a4f9e2e --- /dev/null +++ b/leader-followers/src/test/java/com.iluwatar.leaderfollowers/TaskSetTest.java @@ -0,0 +1,50 @@ +/* + * The MIT License + * Copyright © 2014-2019 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +package com.iluwatar.leaderfollowers; + +import org.junit.Assert; +import org.junit.Test; + +/** + * Tests for TaskSet + */ +public class TaskSetTest { + + @Test + public void testAddTask() throws InterruptedException { + var taskSet = new TaskSet(); + taskSet.addTask(new Task(10)); + Assert.assertTrue(taskSet.getSize() == 1); + } + + @Test + public void testGetTask() throws InterruptedException { + var taskSet = new TaskSet(); + taskSet.addTask(new Task(100)); + Task task = taskSet.getTask(); + Assert.assertTrue(task.getTime() == 100); + Assert.assertTrue(taskSet.getSize() == 0); + } + +} diff --git a/leader-followers/src/test/java/com.iluwatar.leaderfollowers/WorkCenterTest.java b/leader-followers/src/test/java/com.iluwatar.leaderfollowers/WorkCenterTest.java new file mode 100644 index 0000000000000000000000000000000000000000..045d8c3dc84f3cecc71d25accae106c820ae51a2 --- /dev/null +++ b/leader-followers/src/test/java/com.iluwatar.leaderfollowers/WorkCenterTest.java @@ -0,0 +1,62 @@ +/* + * The MIT License + * Copyright © 2014-2019 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +package com.iluwatar.leaderfollowers; + +import org.junit.Assert; +import org.junit.Test; + +/** + * Tests for WorkCenter + */ +public class WorkCenterTest { + + @Test + public void testCreateWorkers() { + var taskSet = new TaskSet(); + var taskHandler = new TaskHandler(); + var workCenter = new WorkCenter(); + workCenter.createWorkers(5, taskSet, taskHandler); + Assert.assertEquals(workCenter.getWorkers().size(), 5); + Assert.assertEquals(workCenter.getWorkers().get(0), workCenter.getLeader()); + } + + @Test + public void testNullLeader() { + var workCenter = new WorkCenter(); + workCenter.promoteLeader(); + Assert.assertNull(workCenter.getLeader()); + } + + @Test + public void testPromoteLeader() { + var taskSet = new TaskSet(); + var taskHandler = new TaskHandler(); + var workCenter = new WorkCenter(); + workCenter.createWorkers(5, taskSet, taskHandler); + workCenter.removeWorker(workCenter.getLeader()); + workCenter.promoteLeader(); + Assert.assertEquals(workCenter.getWorkers().size(), 4); + Assert.assertEquals(workCenter.getWorkers().get(0), workCenter.getLeader()); + } +} diff --git a/pom.xml b/pom.xml index d035cfe405b19b2e477d84a17a2abd459d47cee2..b81cfe8d483efdc95084c0ca1e8b56854d35959d 100644 --- a/pom.xml +++ b/pom.xml @@ -183,6 +183,7 @@ game-loop combinator update-method + leader-followers