More Threads algorithm efficiency analysis, Big-Oh Work on Minesweeper
See the nine announcements in the email message that I sent you yesterday afternoon. By now, everyone should know how to submit files in AFS and to SVN repositories.
I have been rather lenient in the past if you didn't get it submitted correctly. By now you should be able to submit it to the right place on time.
It is important that we not only be able to write object-oriented programs, but that we build a vocabulary that enables us to communicate with each other about them. That is why I asked you to spend four weeks learning the "lingo" of OOP in Java. Tomorrow is the check-up on that. This ANGEL-based quiz is closed book and notes. It consists of matching questions, and you will only have about 30 seconds per term to complete it. So know your terms well!
Each class day this week.
A progress report is due at the end of each class.
Discuss a Java feature (threads, function objects) A little bit on algorithm analysis Some time to work on Minesweeper (typically 30+ minutes).
It is basically an updated version of your IEP, showing your progress on the phases that you outlined. Name today's report Day 13 progress Report.xlsx (You should be able to use "Save as" in Excel to do this.) Commit it to your Minesweeper repository.
Additional requirement for your project: You should add a "cheat" feature Details are on the Assignments discussion forum
to help you debug your code to help me test your code more easily
Multithreaded Programs More on Algorithm analysis Big Oh Work on Minesweeper
Often we want our program to do multiple (semi) independent tasks at the same time Each thread of execution can be assigned to a different processor, or one processor can simulate simultaneous execution through "time slices" (each probably a large fraction of a millisecond)
Time Slices running thread 1 running thread 2
1
2
3
4
5
6
7
8
9
1 0
1 1
1 2
1 3
1 4
There is always one default thread; you can create others. Uses for additional threads
A thread may sleep for a specified amount of time by calling Thread.sleep(numberOfMilliseconds);
Animation that runs while still allowing user interaction. A server (such as a web server) communicates with multiple clients. Animate multiple objects (such as the timers in the CounterThreads example in a few minutes).
How to create and run a new thread
Define a new class that implements the Runnable interface. (it has one method: public void run(); ) Place the code for the threaded task in the run() method:
class MyRunnable implements Runnable { public void run () { // task statements go here } } Runnable r = new MyRunnable(); Thread t = new Thread(r); t.start();
Create an object of this class:
Construct a Thread object from this Runnable object Call the start method to start the thread
Greetings simple threads, different wait times AnimatedBall move balls, stop with click CounterThreads multiple independent counters CounterThreadsRadioButtons same as above, but with radio buttons. The remaining two are more advanced than we will use in this course, dealing with race conditions and synchronization. Detailed descriptions are in Big Java.
BankAccount SelectionSorter
One thread prints the Hello messages; the other Thread prints the Goodbye messages. Each thread sleeps for a random amount of time after printing each line.
Thu Thu Thu Thu Thu Thu Thu Thu Thu Thu Thu Thu Thu Thu Thu Thu Thu Thu Thu Thu . .
Jan Jan Jan Jan Jan Jan Jan Jan Jan Jan Jan Jan Jan Jan Jan Jan Jan Jan Jan Jan .
03 03 03 03 03 03 03 03 03 03 03 03 03 03 03 03 03 03 03 03
16:09:36 16:09:36 16:09:36 16:09:36 16:09:36 16:09:36 16:09:37 16:09:37 16:09:38 16:09:38 16:09:38 16:09:38 16:09:39 16:09:39 16:09:39 16:09:39 16:09:39 16:09:39 16:09:40 16:09:40
EST EST EST EST EST EST EST EST EST EST EST EST EST EST EST EST EST EST EST EST
2008 2008 2008 2008 2008 2008 2008 2008 2008 2008 2008 2008 2008 2008 2008 2008 2008 2008 2008 2008
Hello, World! Goodbye, World! Hello, World! Goodbye, World! Goodbye, World! Hello, World! Goodbye, World! Hello, World! Hello, World! Goodbye, World! Goodbye, World! Hello, World! Goodbye, World! Goodbye, World! Goodbye, World! Hello, World! Hello, World! Goodbye, World! Hello, World! Goodbye, World!
This example was adapted from Cay Horstmann's Big Java, Chapter 23
public class GreetingThreadTester{ public static void main(String[] args){ // Create the two Runnable objects GreetingRunnable r1 = new GreetingRunnable("Hello, World!"); GreetingRunnable r2 = new GreetingRunnable("Goodbye, World!"); // Create the threads from the Runnable objects Thread t1 = new Thread(r1); Thread t2 = new Thread(r2); We do not // Start the threads running. t1.start(); t2.start(); } }
directly. Instead we call start(), which sets up the thread environment, and calls run() for us.
call run()
import java.util.Date; public class GreetingRunnable implements Runnable { private String greeting; private static final int REPETITIONS = 15; private static final int DELAY = 1000; public GreetingRunnable(String aGreeting) { greeting = aGreeting; } public void run() { try { for (int i = 1; i <= REPETITIONS; i++){ Date now = new Date(); System.out.println(now + " " + greeting); Thread.sleep((int)(DELAY*Math.random())); } } catch (InterruptedException exception){ } If a thread is interrupted while it is sleeping, } }
an InterruptedException is thrown.
A simplified version of the way BallWorlds does animation When balls are created, they are given position, velocity, and color Our run() method tells each of the balls to move, then redraws them Clicking the mouse turns movement off/on. Think about: could this application be written without creating the new thread? Demonstrate the program!
public class AnimatedBallViewer { static final int FRAME_WIDTH = 600; static final int FRAME_HEIGHT = 500; public static void main(String[] args){ JFrame frame = new JFrame(); frame.setSize(FRAME_WIDTH, FRAME_HEIGHT); frame.setTitle("BallAnimation"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); AnimatedBallComponent component = new AnimatedBallComponent(); frame.add(component); frame.setVisible(true); new Thread(component).start(); } }
This class has all of the usual stuff, plus this last line of code that starts the animation.
class Ball private private private private
{ double centerX, centerY, velX, velY; Ellipse2D.Double ellipse; Color color; static final double radius = 15;
public Ball(double cx, double cy, double vx, double vy, Color c){ this.centerX = cx; this.centerY = cy; this.velX = vx; this.velY = vy; this.color = c; this.ellipse = new Ellipse2D.Double ( this.centerX-radius, this.centerY-radius, 2*radius, 2*radius); } public void fill (Graphics2D g2) g2.setColor(this.color); { g2.fill(ellipse); } public void move (){ this.ellipse.x += this.velX; this.ellipse.y += this.velY; } }
Everything here should look familiar, similar to code that you wrote for BallWorlds.
public class AnimatedBallComponent extends JComponent implements Runnable, MouseListener { private ArrayList<Ball> balls = new ArrayList<Ball>(); private boolean moving = true; public static final long DELAY = 30; Again, public static final int ITERATIONS = 300; public AnimatedBallComponent() { super(); balls.add(new Ball(40, 50, 8, 5, Color.BLUE)); balls.add(new Ball(500, 400, -3, -6, Color.RED)); balls.add(new Ball(30, 300, 4, -3, Color.GREEN)); this.addMouseListener(this); }
there should be no surprises here!
public void run() { Each time through for (int i=0; i<ITERATIONS; i++) { if (moving){ the loop (if moving), for (Ball b:balls) tell each ball to b.move(); this.repaint(); move, then repaint } try { Thread.sleep(DELAY); Sleep for a while } catch (InterruptedException e) {} } } public void paintComponent(Graphics g){ Graphics2D g2 = (Graphics2D)g; for (Ball b:balls) b.fill(g2); }
Draw each ball Toggle "moving" when the mouse is pressed
public void mousePressed (MouseEvent arg0) { moving = !moving; }
Could this program have been written without creating the new thread?
With regular buttons
With radio buttons
How many threads does this application appear to have?
public class CounterThreads { public static void main (String []args) { JFrame win = new JFrame(); Same old stuff! Container c = win.getContentPane(); win.setSize(600, 250); c.setLayout(new GridLayout(2, 2, 10, 0)); c.add(new CounterPane(200)); c.add(new CounterPane(500)); c.add(new CounterPane(50)); // this one will count fast! c.add(new CounterPane(1000)); win.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); win.setVisible(true); } }
class CounterPane extends JComponent implements Runnable { private int delay; // sleep time before changing counter private int direction = 0; // current increment of counter private JLabel display = new JLabel("0"); // Constants to define counting directions: private static final int COUNT_UP = 1; // Declaring these private static final int COUNT_DOWN = -1; // constants avoids private static final int COUNT_STILL = 0; // "magic numbers" private static final int BORDER_WIDTH = 3; private static final int FONT_SIZE = 60;
public CounterPane(int delay) { JButton upButton = new JButton("Up"); JButton downButton = new JButton("Down"); JButton stopButton = new JButton("Stop"); // Note that these do // NOT have to be fields // of this class.
this.delay = delay; // milliseconds to sleep this.setLayout(new GridLayout(2, 1, 5, 5)); // top row for display, bottom for buttons. JPanel buttonPanel = new JPanel(); buttonPanel.setLayout(new GridLayout(1, 3, 8, 1)); display.setHorizontalAlignment(SwingConstants.CENTER); display.setFont(new Font(null, Font.BOLD, FONT_SIZE)); // make the number display big! Put a simple border
this.add(display); this.add(buttonPanel); this.setBorder(BorderFactory.createLineBorder(Color.blue, BORDER_WIDTH)); // Any Swing component can have a border. this.addButton(buttonPanel, upButton, Color.orange, COUNT_UP); this.addButton(buttonPanel, downButton, Color.cyan, COUNT_DOWN); this.addButton(buttonPanel, stopButton, Color.pink, COUNT_STILL); Thread t = new Thread(this); t.start();
around the panel. There are also more complex border styles that you can use.
A lot of the repetitive work is done by the calls to addButton().
// Adds a control button to the panel, and creates an // ActionListener that sets the count direction. private void addButton(Container container, JPanel is a subclass JButton button, of Container Color color, final int dir) { The value of dir will be 1, 1, or 0, to indicate counting container.add(button); up, down, or neither. button.setBackground(color); button.addActionListener(new ActionListener () { public void actionPerformed(ActionEvent e) { direction = dir; } }); } The action listener added here is an anonymous
in...