Outline. Command Pattern. Examples. Goal & Applications Motivation (undo / redo) Structure & participants Sequence diagram

Transcription

1 Outline Command Pattern Goal & Applications Motivation (undo / redo) Structure & participants Sequence diagram Examples javax.swing.action java.util.timer java.util.concurrent.executorservice Callable & Future: asynchronous programming 11 May

2 Command Pattern Goal Turn an action into an object (command), i.e. encapsulate all the information needed to call an action at a later time Client instantiates the command and provides the information needed to call the method at a later time (receiver, method name, parameters) Command may be stored and may be executed at a later time Invoker does not need to know the receiver of the method nor the method parameters (they are stored in the command object) Decouple the class that is invoking the action from the action itself 11 May

3 Command Pattern Applications Transactional behavior Similar to the undo, a database engine keeps a list of operations that have been (or will be) performed. If one of them fails, a rollback is executed Wizards Command object is created when the wizard is first displayed Each wizard page stores its GUI changes in the command object "Finish" executes the command Actions in Swing: an Action is a command object Thread Pool: actions are registered to be executed Macro recording: user interactions can be recorded Multi-level undo User actions are stored in an undo history stack 11 May

4 Undo / Redo Motivation op 1 op 2 op 3 op 4 op 5 current position Remarks: Association of undo/redo list with model or with view? What happens if a new operation is executed at the current position? 11 May

5 Undo / Redo Emacs / vim support undo-trees 11 May

6 Undo / Redo Implementation S 0 S 1 S 2 S 3 Copy and save the states Figure list has to be (deep) cloned upon every operation Copy and save the changes The changes have to be represented as command objects 11 May

7 Undo / Redo DrawCommand redo() undo() AddCommand redo() undo() Model m Figure f m.addfigure(f) m.removefigure(f) MoveCommand redo() undo() Figure f int dx, dy f.move(dx, dy) f.move(-dx, -dy) GroupCommand redo() undo() Figure g Model m for (Figure f:g.figs) m.removefigure(f); m.addfigure(g); 11 May

8 Undo / Redo State diagram for commands From the view of a single command 11 May

9 Undo / Redo: DrawCommandHandler public interface DrawCommandHandler { void addcommand(drawcommand cmd); void undo(); void redo(); // clears redo list // adds cmd to undo commands boolean undopossible(); boolean redopossible(); void clearhistory(); Implementation: List of commands (ListIterator supports methods next and previous) Two stacks 11 May

10 Command Pattern Definition Encapsulate a request as an object Allows to parameterize clients with different requests Client {creates ConcrCmd and sets receiver Example: ActionListener implementation 11 May

11 Command Pattern Participants Command Declares interface for executing commands Concrete Command Client Implements execute by invoking an operation on the receiver Creates a concrete command and sets the information needed to call the method at a later time (receiver and parameters) Invoker Decides when the method is called, i.e. Asks the command to carry out the request Receiver Knows how to execute the operation, i.e. Receiver executes the actual work to be done 11 May

12 Command Pattern Sequence Diagram 11 May

13 Undo / Redo: DrawCommandHandler Problem: Movement of a figure leads to many operations move(dx, dy) typically moves the figure only about 1-2 pixels Guarantees visual feedback All MoveCommand objects are stored in the undo-list Undo of such a move operation requires many undo invocations Solution: 11 May

14 Command Pattern Forces You have to provide a undo / redo management You have to queue commands Remember Observer Causality Problem You need to maintain a persistent log of commands executed You need to provide transaction support You have to support timed operations 11 May

15 Outline Command Pattern Goal & Applications Motivation (undo / redo) Structure & participants Sequence diagram Examples Functional Interfaces, Lambda Expressions and Method references javax.swing.action java.util.timer java.util.concurrent.executorservice Callable & Future: asynchronous programming 11 May

16 Lambda Expression Argument List A list of parameters enclosed in parentheses Parameter types can be explicitly declared, or they can be inferred from the context. Empty parentheses indicate that there are no parameters. Parentheses can be omitted for a single parameter whose type can be inferred. Arrow Token "->", the lambda operator Body A function body, which can be either of the following: a statement block enclosed in braces a single expression (return type is that of the expression) 11 May

17 Lambda Expression: Examples (int x, int y) -> { return x + y; returns the sum of two integers (x, y) -> x + y Returns the sum of two numbers Types of the parameters and the return type are inferred from the context Body is a single expression; braces omitted n -> n % 2 == 0 Returns true if n is even (type is inferred) () -> 42 constant function, no parameters 11 May

18 Functional Interfaces & Lambda Expressions Functional Interface A functional interface is an interface with a single abstract method Default methods in interfaces are not abstract and do not count a functional interface may have multiple default Functional interfaces are recommended to have this annotation. This allows compilers to generate an error if the annotated interface does not satisfy the conditions. Lambda Expressions Conversion to a functional interface is the only thing you can do with a lambda expression in Java Pass it to a method parameter of a functional interface type Assign it to a variable of a functional interface type 11 May

19 Examples public interface Comparator<T> { int compare(t o1, T o2); java.awt.event.actionlistener public interface ActionListener extends EventListener { public void actionperformed(actionevent e); public interface Runnable { public abstract void run(); 11 May

20 Examples java.util.function.* public interface Function<T, R> { R apply(t t); public interface BiFunction<T, U, R> { R apply(t t, U u); public interface UnaryOperator<T> extends Function<T, T> { public interface BinaryOperator<T> extends BiFunction<T,T,T> { public interface Consumer<T> { void accept(t t); public interface BiConsumer<T, U> { void accept(t t, U u); public interface Supplier<T> { T get(); public interface Predicate<T> { boolean test(t t); public interface BiPredicate<T, U> { boolean test(t t, U u); 11 May

21 Types of Method References Reference to a static method Class::staticMethod (args) -> Class.staticMethod(args) String::valueOf String::format Reference to an instance method of a particular object instance::instancemethod (args) -> obj.instancemethod(args) s::tostring s::contains Reference to an instance method of an obj of a particular type Class:instanceMethod (obj, args) -> obj.instancemethod(args) String::toString String::contains s -> String.valueOf(s) (s,e1, ) -> String.format(s,e1, ) () -> s.tostring() (pat) -> s.contains(pat) s -> s.tostring() (s,pat) -> s.contains(pat) 11 May

22 Command Pattern Example: javax.swing.action Action Interface Useful extension to Action- Listener in cases where the same functionality may be accessed by several controls Supports: Text strings Icons NAME SHORT_DESCRIPTION LONG_DESCRIPTION SMALL_ICON Enabled/disabled state 11 May

23 Command Pattern Example: javax.swing.action public interface Action extends ActionListener { public static final String DEFAULT = "Default"; // not used public static final String NAME = "Name"; // menu or button public static final String SHORT_DESCRIPTION = "ShortDescription"; public static final String LONG_DESCRIPTION = "LongDescription"; public static final String SMALL_ICON = "SmallIcon"; public static final String ACTION_COMMAND_KEY= "ActionCommandKey"; public static final String ACCELERATOR_KEY = "AcceleratorKey"; public static final String MNEMONIC_KEY = "MnemonicKey"; public Object getvalue(string key); public void putvalue(string key, Object value); public void setenabled(boolean b); public boolean isenabled(); public void addpropertychangelistener(propertychangelistener l); public void removepropertychangelistener( PropertyChangeListener l); 11 May

24 Command Pattern Example: javax.swing.action Container Support Certain containers (menus, tool bars) know how to add an Action object => Upon adding an Action object: Container creates an appropriate component Container uses the Action properties to customize the component Renders component in enabled/disabled state Registers a listener on state changes Action may also be used to define (or be set on) a AbstractButton setaction JButton JButton(Action) JMenuItem JMenuItem(Action) JToggleButton JToggleButton(Action) [Radio/CheckBox] JTextField setaction JComboBox setaction 11 May

25 Timer (java.util.timer) Timer Facility to schedule tasks for future execution Tasks may be scheduled for one-time execution for repeated execution at regular intervals Fixed delay Fixed rate Each Timer instance uses a single background thread to execute the tasks Tasks should complete quickly, otherwise they hog the execution thread Timer does not offer real-time guarantees Implemented using a heap Task scheduling: O(log n) 11 May

26 Timer (java.util.timer) public class Timer { void cancel() // terminates this timer int purge() // Removes all cancelled tasks void schedule(timertask task, Date time) void schedule(timertask task, Date time, long period) void schedule(timertask task, long delay) void schedule(timertask task, long delay, long period) void scheduleatfixedrate(timertask t, Date time, long period) void scheduleatfixedrate(timertask t, long delay, long period) public abstract class TimerTask implements Runnable { abstract void run() // Action to be performed by this timer task boolean cancel() // Cancels this timer task long scheduledexecutiontime() // returns next execution time 11 May

27 Executor Framework Participants Worker: One thread is used to execute many unrelated tasks These threads are called worker threads / background threads May be organized in a thread pool (if more than one thread is used) May provide a flexible thread management Channel: A buffer which holds pending requests May be bounded 11 May

28 Executor Framework Executor = Channel + Workers public interface Executor { void execute(runnable command); Decouples task submission from task execution Executes the given command at some time in the future The command may be executed in a new thread / in a pooled thread / in the calling thread Task = Runnable public interface Runnable { void run(); Limitation: Method run cannot return a result (results are placed in shared fields) Method run cannot declare a checked exception 11 May

29 Executor: Simple Implementations DirectExecutor: Synchronous execution (in calling thread) class DirectExecutor implements Executor { public void execute(runnable r) { r.run(); Thread per task executor class ThreadPerTaskExecutor implements Executor { public void execute(runnable r) { new Thread(r).start(); 11 May

30 Executor: Advanced Implementations Execution Policies Execution order of submitted tasks (FIFO, LIFO, Priority Queue) Number of threads which execute concurrently Maximal size of queue with pending tasks Actions taken before / after task execution (startup/cleanup) Factory: java.util.concurrent.executors Provides several implementations for thread pools which implement different policies All factory methods return an executor which implements the ExecutorService interface 11 May

31 Executor: Advanced Implementations Executors.newFixedThreadPool Threads are created up to a fixed number Threads which die due to an unexpected exception are replaced Executors.newCachedThreadPool Creates new threads as needed, reusing previously constructed threads if they are available Executors.newSingleThreadExecutor Uses single worker thread Worker thread is replaced if an unexpected exception occurs Executors.newScheduledThreadPool Creates a ScheduledExecutorService which supports Periodic tasks (scheduleatfixedrate / schedulewithfixeddelay) Delayed tasks (schedule) 11 May

32 Executor Framework Example: Matrix Multiplication: c = a * b private static void computeproductparallel(int nt, final int[][] a, final int[][] b, final int[][] c) throws InterruptedException { ExecutorService ex = Executors.newFixedThreadPool(nt); for (int i = 0; i < N; i++) { ex.execute(new ComputeRow(i, a, b, c)); ex.shutdown(); // Graceful shutdown: // - finish pending tasks // - do not accept new ones ex.awaittermination(1, TimeUnit.HOURS); // awaits until executor is terminated Do not call it with computeproductparallel(n, a, b, a) // A = A*B 11 May

33 Result-bearing tasks: Callable & Future Callable: Task with a result / exception interface Callable<V> { V call() throws Exception; Future: represents lifecycle of a task interface Future<V> { boolean cancel(boolean mayinterruptifrunning); boolean iscancelled(); boolean isdone(); V get() throws InterruptedException, ExecutionException, CancellationException; V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, CancellationException, TimeoutException; 11 May

34 Callable & Future Submitting tasks interface ExecutorService extends Executor { //... Lifecycle methods <T> Future<T> submit(callable<t> task); Future<?> submit(runnable task); <T> Future<T> submit(runnable task, T result); <T> List<Future<T>> invokeall( Collection<? extends Callable<T>> tasks) throws InterruptedException; <T> T invokeany( Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException; 11 May

35 Callable & Future States of a Task created submitted started completed get() If completed: returns immediately (returns result or throws ExecutionException) If not completed: method call blocks If terminates regularly If terminates with an exception If cancelled If thread calling get was interrupted => result => ExecutionException => CancellationException => InterruptedException 11 May

36 Callable & Future Example: Matrix Multiplication (supports A = A*B) private static void computeproductparallel(int nt, final int[][] a, final int[][] b, final int[][] c) throws InterruptedException, ExecutionException { ExecutorService ex = Executors.newFixedThreadPool(nt); List<ComputeRow> tasks = new ArrayList<ComputeRow>(N); for (int i = 0; i < N; i++) { tasks.add(new ComputeRow(i, a, b)); List<Future<int[]>> result = ex.invokeall(tasks); // something else could be done for(int i=0; i<n; i++) { c[i] = result.get(i).get(); 11 May