Difference between revisions of "CSC352 Java Threads: Producer-Consumer Lab"
(→Eclipse-Ready version) |
(→Processing GUI version) |
||
Line 88: | Line 88: | ||
size( 600, 400 ); | size( 600, 400 ); | ||
smooth(); | smooth(); | ||
− | frameRate( | + | frameRate( 10 ); // draw() will be called 10 times a second |
} | } | ||
Line 103: | Line 103: | ||
</source> | </source> | ||
+ | |||
+ | * Implement one of the two versions above on your computer | ||
+ | * Observe that it runs and displays translucent rectangles at a rate of 10 rectangles a second (approximately) | ||
+ | <br /> | ||
+ | |||
+ | =Version 2: A Threaded Producer of Rectangles= | ||
<br /> | <br /> | ||
+ | What we have is nice, but the rectangles are produced at a fixed rate of 10 rectangles a second. Assume that we want to generate them faster. We could increase the frame-rate, but this would take us only so far. Maybe 60 times a second at most. | ||
+ | |||
+ | Another option is to have a thread generate random rectangles, and have it pass them to '''draw()''' as it generates them. | ||
+ | |||
+ | This new thread will be a ''producer'' of rectangles, and '''draw()''' will be its ''consumer''. In a first step we will make them exchange 1 rectangle at a time. | ||
+ | |||
+ | The version below is an ill-formed (you'll have to fix it!) first attempt at doing just that: | ||
+ | |||
+ | <br /> | ||
+ | <source lang="java" highlight="11,26-40"> | ||
+ | // MainApplet2.java | ||
+ | // Another badly synchronized program in need of | ||
+ | // some help! | ||
+ | import java.util.ArrayList; | ||
+ | import java.util.Random; | ||
+ | import processing.core.PApplet; | ||
+ | |||
+ | public class MainApplet2 extends PApplet { | ||
+ | ArrayList<Rect> rects = new ArrayList<Rect>(); | ||
+ | Random generator = new Random( System.currentTimeMillis() ); | ||
+ | Rect newRect = null; | ||
+ | RectProducer producer; | ||
+ | |||
+ | class Rect { | ||
+ | int x; int y; int w; int h; | ||
+ | int col; | ||
+ | Rect() { this.x = this.y = 0; this.w = this.h = 10; col= 0xff6699cc; } | ||
+ | Rect( int x, int y, int w, int h, int c ) { this.x = x; this.y = y; this.w = w; this.h = h; col = c; } | ||
+ | public Rect randomRect() { | ||
+ | return new Rect( generator.nextInt( width ), generator.nextInt( height ), | ||
+ | generator.nextInt( width ), generator.nextInt( height ), | ||
+ | generator.nextInt( 0x77ffffff ) ); | ||
+ | } | ||
+ | } | ||
+ | |||
+ | class RectProducer extends Thread { | ||
+ | public void run() { | ||
+ | // forever... (bad infinite loop, but ok for example) | ||
+ | for (;;) { | ||
+ | // wait for newRect to be absorbed by draw() | ||
+ | while ( newRect != null ) | ||
+ | try { | ||
+ | sleep( 1 ); // wait 1 ms | ||
+ | } catch (InterruptedException e) {} | ||
+ | |||
+ | // put new randomly generated rect in newRect | ||
+ | newRect = (new Rect()).randomRect(); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | public void setup() { | ||
+ | size( 600, 400 ); | ||
+ | smooth(); | ||
+ | frameRate( 10 ); | ||
+ | |||
+ | //--- create a producer of rectangles --- | ||
+ | producer = new RectProducer(); | ||
+ | producer.start(); | ||
+ | } | ||
+ | |||
+ | public void draw() { | ||
+ | if ( newRect == null ) | ||
+ | return; | ||
+ | |||
+ | stroke( 0x000000 ); | ||
+ | fill( newRect.col ); | ||
+ | rect( newRect.x, newRect.y, newRect.w, newRect.h ); | ||
+ | newRect = null; | ||
+ | } | ||
+ | |||
+ | private Rect getNewRect() { | ||
+ | return (new Rect()).randomRect(); | ||
+ | } | ||
+ | } | ||
+ | |||
+ | </source> | ||
+ | |||
<br /> | <br /> | ||
<br /> | <br /> |
Revision as of 21:34, 18 September 2013
--D. Thiebaut (talk) 21:10, 18 September 2013 (EDT)
The goal of this lab is to see how threads can be used along size a main application that is already threaded. A perfect example of this is a Processing application where the draw() method is called by a thread that is timed to run approximately 30 times a second (or whatever interval is specified by the frameRate() method).
Contents
Version 1: Displaying 30 random rectangles a second
- The following Java program is a Processing app. taylored for Eclipse. The version that follows is the one for the Processing IDE. They are both similar, but in one case the application is included in a class extending the PApplet class of Processing. In the second case, the Processing GUI hides the PApplet implementation.
- Please refer to the tutorials at http://cs.smith.edu/dftwiki/index.php/Tutorials#Processing_and_Eclipse if you are interested in running Processing applets from Eclipse.
Eclipse-Ready version
// MainApplet.java
// D. Thiebaut
// This application needs the core.jar library of the Processing package to be included in the
// build path of the application. See
import java.util.ArrayList;
import java.util.Random;
import processing.core.PApplet;
public class MainApplet extends PApplet {
ArrayList<Rect> rects = new ArrayList<Rect>();
Random generator = new Random( System.currentTimeMillis() );
class Rect {
int x; int y; int w; int h;
int col;
Rect() { this.x = this.y = 0; this.w = this.h = 10; col= 0xff6699cc; }
Rect( int x, int y, int w, int h, int c ) { this.x = x; this.y = y; this.w = w; this.h = h; col = c; }
public Rect randomRect() {
return new Rect( generator.nextInt( width ), generator.nextInt( height ),
generator.nextInt( width ), generator.nextInt( height ),
generator.nextInt( 0x77ffffff ) );
}
}
public void setup() {
size( 600, 400 );
smooth();
frameRate( 10 ); // draw() will be called 10 times a second
}
public void draw() {
Rect r = getNewRect();
stroke( 0x000000 );
fill( r.col );
rect( r.x, r.y, r.w, r.h );
}
private Rect getNewRect() {
return (new Rect()).randomRect();
}
}
Processing GUI version
// MainApplet.sketch
// D. Thiebaut
import java.util.ArrayList;
import java.util.Random;
ArrayList<Rect> rects = new ArrayList<Rect>();
Random generator = new Random( System.currentTimeMillis() );
class Rect {
int x; int y; int w; int h;
int col;
Rect() { this.x = this.y = 0; this.w = this.h = 10; col= 0xff6699cc; }
Rect( int x, int y, int w, int h, int c ) { this.x = x; this.y = y; this.w = w; this.h = h; col = c; }
public Rect randomRect() {
return new Rect( generator.nextInt( width ), generator.nextInt( height ),
generator.nextInt( width ), generator.nextInt( height ),
generator.nextInt( 0x77ffffff ) );
}
}
void setup() {
size( 600, 400 );
smooth();
frameRate( 10 ); // draw() will be called 10 times a second
}
void draw() {
Rect r = getNewRect();
stroke( 0x000000 );
fill( r.col );
rect( r.x, r.y, r.w, r.h );
}
Rect getNewRect() {
return (new Rect()).randomRect();
}
- Implement one of the two versions above on your computer
- Observe that it runs and displays translucent rectangles at a rate of 10 rectangles a second (approximately)
Version 2: A Threaded Producer of Rectangles
What we have is nice, but the rectangles are produced at a fixed rate of 10 rectangles a second. Assume that we want to generate them faster. We could increase the frame-rate, but this would take us only so far. Maybe 60 times a second at most.
Another option is to have a thread generate random rectangles, and have it pass them to draw() as it generates them.
This new thread will be a producer of rectangles, and draw() will be its consumer. In a first step we will make them exchange 1 rectangle at a time.
The version below is an ill-formed (you'll have to fix it!) first attempt at doing just that:
// MainApplet2.java
// Another badly synchronized program in need of
// some help!
import java.util.ArrayList;
import java.util.Random;
import processing.core.PApplet;
public class MainApplet2 extends PApplet {
ArrayList<Rect> rects = new ArrayList<Rect>();
Random generator = new Random( System.currentTimeMillis() );
Rect newRect = null;
RectProducer producer;
class Rect {
int x; int y; int w; int h;
int col;
Rect() { this.x = this.y = 0; this.w = this.h = 10; col= 0xff6699cc; }
Rect( int x, int y, int w, int h, int c ) { this.x = x; this.y = y; this.w = w; this.h = h; col = c; }
public Rect randomRect() {
return new Rect( generator.nextInt( width ), generator.nextInt( height ),
generator.nextInt( width ), generator.nextInt( height ),
generator.nextInt( 0x77ffffff ) );
}
}
class RectProducer extends Thread {
public void run() {
// forever... (bad infinite loop, but ok for example)
for (;;) {
// wait for newRect to be absorbed by draw()
while ( newRect != null )
try {
sleep( 1 ); // wait 1 ms
} catch (InterruptedException e) {}
// put new randomly generated rect in newRect
newRect = (new Rect()).randomRect();
}
}
}
public void setup() {
size( 600, 400 );
smooth();
frameRate( 10 );
//--- create a producer of rectangles ---
producer = new RectProducer();
producer.start();
}
public void draw() {
if ( newRect == null )
return;
stroke( 0x000000 );
fill( newRect.col );
rect( newRect.x, newRect.y, newRect.w, newRect.h );
newRect = null;
}
private Rect getNewRect() {
return (new Rect()).randomRect();
}
}