1 / 72

Applets Event Handling Threads and more in Java

Applets Event Handling Threads and more in Java . Sami Khuri Mathematics & Computer Science Department. Creating the “First” Applet. Create a Java source file: First.java

stormy
Télécharger la présentation

Applets Event Handling Threads and more in Java

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. AppletsEvent HandlingThreads and more in Java Sami Khuri Mathematics & Computer Science Department

  2. Creating the “First” Applet • Create a Java source file: First.java • Compile First.java. The Java compiler creates the Java bytecode file First.class in the same directory. • Create an HTML file First.html, for example, that includes First.class. • Run the applet in a Java-enabled browser or a Java applet viewing program.

  3. java.lang.Object | +----java.awt.Component | +----java.awt.Container | +----java.awt.Panel | +----java.applet.Applet • AWT: Abstract Windowing Toolkit

  4. Applets • Methods defined in the class Applet: • init(): Applet is being loaded by browser. Used for one-time initialization. • start(): Browser entered page containing applet • stop(): Browser leaves page containing applet • destroy(): Applet is discarded by browser. • paint() is used for drawing on applets. It is a method in the class Component.

  5. Java-enabled Browser When a Java-enabled browser encounters an <APPLET> tag, it: • reserves a display area of the specified width and height for the applet • loads the bytecodes for the specified Applet subclass • creates an instance of the subclass • calls the instance's init() and start() methods.

  6. HyperText Markup Language • An HTML documents contains tags that specify formatting instructions. • An HTML tag is enclosed in angle brackets: example <BODY> and </BODY> • The width and height (in pixels) of the area in which the applet is displayed is included in the html file.

  7. Inheriting from above classes • Some methods in Component: add(), remove() and setLayout(): controls the positions & sizes of components. • Applets inherit the drawing and event handling methods from AWT Component class to produce user interfaces. • Drawing: images, control of color and font. UI components: buttons, etc.. • Event handling: detecting & responding to mouse dragging, button pushing, key pressing,..

  8. Component, Container, and Panel • From AWT Container, applets get methods to hold components & use layout managers. • Panels and applets can only be displayed on other graphical surfaces. • A panel must be added to another container in order to be displayed. • A component is added to a container by using add() from the Container class.

  9. Security Restrictions Restrictions imposed on applets loaded over the network. The applet cannot: • Dynamically load native code libraries. • Read from or write to the local file system. • Make network connections to any computer except to the one from which it obtained the code. • Read certain system properties. • Start a printing job.

  10. More Applet Capabilities • Applets can make network connections to the host from which they came. • Applets that are loaded from the local file system (from a directory in the user's CLASSPATH) have none of the restrictions that applets loaded over the network do. • Applets can load data files (show images) and play sounds.

  11. Displaying Images • The code base, returned by the Applet getCodeBase() method, is a URL that specifies the directory from which the applet's classes were loaded. • The document base, returned by the Applet getDocumentBase() method, specifies the directory of the HTML page that contains the applet.

  12. Example on Displaying Images • Images must be in GIF or JPEG format. • Example: Image file yawn.gif is in directory “images”. To create an image object “nekopicture” that contains “yawn.gif”: Image nekopicture = new Image nekopicture = getImage(getCodeBase(), "images/yawn.gif");

  13. Playing Sounds • The AudioClip interface in the Applet class provides basic support for playing sounds. • Sound format: 8 bit, 8000 Hz, one-channel, Sun ".au" files. • Methods in AudioClip that need to be implemented in the applet: loop(): starts playing the clip repeatedly play() & stop() to play & stop the clip.

  14. Inheritance tree of applets & frames Object Component Canvas Label Container List Button Scrollbar Panel Window TextComponent Applet Frame Checkbox Choice

  15. Event Handling • With event-driven programming, events are detected by a program and handled appropriately • Events: moving the mouse clicking the button pressing a key sliding the scrollbar thumb choosing an item from a menu

  16. Three Steps of Event Handling • Prepare to accept events import package java.awt.event • Start listening for events include appropriate methods • Respond to events implement appropriate abstract method

  17. 1. Prepare to accept events • Import package java.awt.event • Applet manifests its desire to accept events by promising to “implement” certain methods • Example: “ActionListener” for Button events “AdjustmentListener” for Scrollbar events

  18. 2. Start listening for events • To make the applet “listen” to a particular event, include the appropriate “addxxxListener”. • Examples: addActionListener(this) shows that the applet is interested in listening to events generated by the pushing of a certain button.

  19. 2. Start listening for events (cont) • Example addAdjustmentListener(this) shows that the applet is interested in listening to events generated by the sliding of a certain scroll bar thumb. • “this” refers to the applet itself - “me” in English

  20. 3. Respond to events • The appropriate abstract methods are implemented. • Example: actionPerformed() is automatically called whenever the user clicks the button. Thus, implement actionPerformed() to respond to the button event.

  21. 3. Respond to events (cont) • Example: adjustmentValueChanged() is automatically invoked whenever the user slides the scroll bar thumb. So adjustmentValueChanged() needs to be implemented. • In actionPerformed(ActionEvent evt), ActionEvent is a class in java.awt.event.

  22. StatBar pan2 statement north ranger center south centerValue leftMsg rightMsg pan3 pan1

  23. Threads • A lightweight sequential flow of control that shares an address space and resources with other threads. • A thread, unlike processes (heavyweight), has a low context switching time. • Threads are indispensable for sockets, image holding, and animation.

  24. Threads in Java • Traditionally, threads are implemented at the system level, separate from the programming language. • Java is a language and a runtime system and threads are integrated in both. • The keyword synchronize is used to make a block of code accessible to at most one thread at a time.

  25. Purpose of Threads • Making a User Interface more responsive. • When one method can use the partial output of another without waiting for the first one to finish. Example: image-loading and image-displaying methods. • Any type of application that lends itself to concurrency.

  26. How to create threads • There are two ways of creating threads in Java: 1) Extend the “Thread” class We can instantiate the class Thread as many times as desired to achieve multi-threading. 2) Implement the “Runnable” interface Since multiple inheritance is not allowed in Java, this method is used when the program already extends another class (Ex. Applets)

  27. 1) Extend the Thread class • Create a subclass of java.lang.Thread: public class MyThread extends Thread { public void run() { \\put code here } } • Instantiate MyThread: MyThread myTrd; myTrd.start(); // calls run() in MyThread

  28. Methods in Class Thread • Three primary methods to control a thread: • public native synchronized void start() prepares a thread to run • public void run() actually performs the work of the thread • public final void stop() to terminate the thread. The thread also dies when run() terminates.

  29. start() & run() in Thread • start() causes the thread to begin execution and the Java Virtual Machine calls run(). Thus, we never have to call run() explicitly. • The result is that two threads are running concurrently: the current thread which returns from the call to start() and the thread that executes run().

  30. Other Methods in Thread • Other important methods in Thread include: • suspend() and resume() • sleep(mls) which causes the thread to temporarily stop execution for mls milliseconds • yield() which causes the executing thread object to temporarily pause and allow other threads to execute • getName() and getPriority()

  31. Class Thread Priorities • The class Thread has three fields: • MAX_PRIORITY • MIN_PRIORITY • NORM_PRIORITY: the default priority assigned to a thread • A new created thread has its priority initially set equal to the priority of the creating thread.

  32. 2) Creating a thread by using Runnable Interface • Instantiate Thread and pass it “this” (the applet) as a parameter. • Use the method start() to start running the instantiated thread. • Place all the important code for the instantiated thread in the run() method. • Set the instantiated thread to “null” in the stop() method.

  33. Implement Runnable interface • Create a class that implements Runnable: public class MyFoo extends Applet implements Runnable; • Runnable is an interface in java.lang that contains only one method: run(). • Multiple inheritance is not allowed in Java, thus this method of creating threads is used when MyFoo already extends another class.

  34. The Life Cycle of a Thread running start() New Thread Runnable Not Runnable run() terminates Dead

  35. Out of Runnable sleep() is invoked. wait() is invoked (for a specified condition to be satisfied). Thread is blocked on I/O. Back to Runnable Specified number of milliseconds elapsed. An object notifies the waiting thread that the condition is satisfied. I/O event the thread is blocked on, is completed. In and Out of Runnable

  36. sleep new Done sleeping blocked start suspend resume runnable wait notify Block on I/O I/O complete stop dead Thread States from Core Java. Drawn by Ping Wu

  37. Managing Threads • Launching threads and letting them compete for computer resources, in an uncontrolled fashion, may lead to very unpleasant results. • A typical application involves two or more threads that share a common resource: file or block of memory, where one thread tries to modify the resource while that resource is still being used by another thread.

  38. Simple Model of a Bank [Horton97] • A very small bank consists of: • a bank: a computer that performs operations on accounts • clerk1: processes credits (deposits) • clerk2: processes debits (withdrawals) • Each clerk can communicate directly with the bank • Initially, the bank has only one customer

  39. Credits clerk1 theAccount theBank Credit operations Debit operations Computer operations are overlapped Debits clerk2

  40. Four Classes of the Bank Model • public class Account field: balance getBalance() and setBalance(balance) • class Bank where credit & debit operations are performed and balance is updated. public void credit(Account theAcc, int amt) public void debit(Account theAcc, int amt)

  41. Clerk Class • public class Clerk implements Runnable Bank theBank // The employer // Types of transactions // Details of the current transaction public void doCredit(Account theAcc, int amt) public void doDebit(Account theAcc, int amt) public void run() public boolean isBusy() //done with transactions?

  42. Driver Class • public class BankOperation public static void main(String[] args) // initialization (balance, transactionCount) // create account, bank and clerks // create clerk1Thread and clerk2Thread and start them off // generate transactions of each type and pass them to the appropriate clerk // wait until clerks are done & output results

  43. Running the Example • Original balance : $ 500 Total credits : $1252 Total debits : $ 852 Final balance : $ 100 Should be : $ 900 • The problem: One operation is retrieving the account balance while another operation is still in the process of amending it.

  44. Synchronization The objective of synchronization is to make sure that when several threads need access to a shared resource, only one thread can access it at any given time. Use synchronized at the • method level: declare methods to be synchronized • block of code level: declare some code to be synchronized

  45. Synchronizing Methods [Bank_SyncM] • One solution: declare the operations in class Bank as being synchronized [see Bank_SyncM] synchronized public void credit(Account theAcc, int amt) { int balance = theAcc.getBalance(); … balance = balance + amt; // update balance theAcc.setBalance(balance); // put it back in the bank } synchronized public void debit(Account theAcc, int amt) // same as above except for: balance = balance - amt

  46. Synchronizing Methods • Only one of the synchronized methods in a class object can be executing at any time. synchronized public void method1() { // code for the method } synchronized public void method2() { // code for the method } …… // can also have none synchronized methods which will operate the usual way (not “protected”) synchronized public void method3() { // code for the method } …..

  47. Synchronizing Blocks of Code • Specify a block of statements in the program as synchronized: synchronized(myObject) { statement; statement; ... } // synchronized with respect to myObject • Any other statements in the program that are synchronized with myObject cannot execute while the above statements are executing.

  48. Synchronizing Code [Bank_SyncB] • Other solution: declare the code in the methods to be synchronized [see Bank_SyncB] public void credit(Account theAcc, int amt) { synchronized(the Acc) { int balance = theAcc.getBalance(); … } } public void debit(Account theAcc, int amt) { synchronized(the Acc) { int balance = theAcc.getBalance(); … } }

  49. Handling Multiple Accounts [Bank_SyncB] • Bank_SyncB handles multiple accounts • Had we left the synchronization of the methods (rather than the block of code), no debit operation of any kind would have been able to be carried out while a credit operation is in progress, and vice versa. • Synchronization of a block of code prevents overlapping of operations on the same account, and that is what we want.

  50. Thread Organization [Tan95] • The possible organization of threads: • dispatcher/worker model: an idle worker thread is chosen by the dispatcher thread for the incoming job • team model: each thread works on its own request • pipeline model: threads cooperate with each other in a sequential fashion. [see Figure]

More Related