Home > Articles > Programming > Java

  • Print
  • + Share This
This chapter is from the book

Selfish Threads

Our ball threads were well-behaved and gave each other a chance to run. They did this by calling the sleep method to wait their turns. The sleep method blocks the thread and gives the other threads an opportunity to be scheduled. Even if a thread does not want to put itself to sleep for any amount of time, it can call yield() whenever it does not mind being interrupted. A thread should always call sleep or yield when it is executing a long loop, to ensure that it is not monopolizing the system. A thread that does not follow this rule is called selfish.

The following program shows what happens when a thread contains a tight loop, a loop in which it carries out a lot of work without giving other threads a chance. When you click on the "Selfish" button, a blue ball is launched whose run method contains a tight loop.

class BallThread extends Thread
{
  . . .
  public void run()
  {
   try
   {
     for (int i = 1; i <= 1000; i++)
     {
      b.move();
      if (selfish)
      {
        // busy wait for 5 milliseconds
        long t = System.currentTimeMillis();
        while (System.currentTimeMillis() < t + 5)
         ;
      }
      else
        sleep(5);
     }
   }
   catch (InterruptedException exception)
   {          
   }
  }
  . . .
  private boolean selfish;
}

When the selfish flag is set, the run method will last about five seconds before it returns, ending the thread. In the meantime, it never calls sleep or yield.

What actually happens when you run this program depends on your operating system and choice of thread implementation. For example, when you run this program under Solaris or Linux with the "green threads" implementation as opposed to the "native threads" implementation, you will find that the selfish ball indeed hogs the whole application. Try closing the program or launching another ball; you will have a hard time getting even a mouse-click into the application. However, when you run the same program under Windows or the native threads implementation, nothing untoward happens. The blue balls can run in parallel with other balls.

The reason for this behavioral difference is that the underlying thread package of the operating system performs time-slicing. It periodically interrupts threads in midstream, even if they are not cooperating. When a thread (even a selfish thread) is interrupted, the scheduler activates another thread—picked among the top-priority-level runnable threads. The green threads implementation on Solaris and Linux does not perform time-slicing, but the native thread package does. (Why doesn't everyone simply use the native threads? Until recently, X11 and Motif were not thread safe, and using native threads could lock up the window manager.) Also, as Java gets ported to new platforms, the green threads implementation tends to get implemented first because it is easier to port.

If you know that your program will execute on a machine whose thread system performs time-slicing, then you do not need to worry about making your threads polite. But the point of Internet computing is that you generally do not know the environments of the people who will use your program. You should, therefore, plan for the worst and put calls to sleep or yield in every loop.

When programming with threads, expect platform-dependent behavior variations. You can't assume that your threads will get pre-empted by other threads, so you must plan for the case that they run forever unless you yield control. But you can't rely on your threads running without interruption—on most platforms, they won't. You must be prepared that they can lose control at any time.

See Example 1–4 for the complete source code of the "selfish ball" program.

Example 1–4: BounceSelfish.java

	1.	import java.awt.*;
	2.	import java.awt.event.*;
	3.	import java.awt.geom.*;
	4.	import java.util.*;
	5.	import javax.swing.*;
	6.	
	7.	/**
	8.	  Shows animated bouncing balls, some running in selfish
	9.	  threads
	10.	*/
	11.	public class BounceSelfish
	12.	{
	13.	  public static void main(String[] args)
	14.	  {
	15.	   JFrame frame = new BounceFrame();
	16.	   frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	17.	   frame.show();
	18.	  }
	19.	}
	20.	
	21.	/**
	22.	  The frame with canvas and buttons.
	23.	*/
	24.	class BounceFrame extends JFrame
	25.	{
	26.	  /**
	27.	   Constructs the frame with the canvas for showing the
	28.	   bouncing ball and Start and Close buttons
	29.	  */
	30.	  public BounceFrame()
	31.	  {
	32.	   setSize(WIDTH, HEIGHT);
	33.	   setTitle("BounceSelfish");
	34.	
	35.	   Container contentPane = getContentPane();
	36.	   canvas = new BallCanvas();
	37.	   contentPane.add(canvas, BorderLayout.CENTER);
	38.	   JPanel buttonPanel = new JPanel();
	39.	   addButton(buttonPanel, "Start",
	40.	     new ActionListener()
	41.	      { 
	42.	        public void actionPerformed(ActionEvent evt)
	43.	        {
	44.	         addBall(false, Color.black);
	45.	        }
	46.	      });
	47.	
	48.	   addButton(buttonPanel, "Selfish",
	49.	     new ActionListener()
	50.	      { 
	51.	        public void actionPerformed(ActionEvent evt)
	52.	        {
	53.	         addBall(true, Color.blue);
	54.	        }
	55.	      });
	56.	
	57.	   addButton(buttonPanel, "Close",
	58.	     new ActionListener()
	59.	      {
	60.	        public void actionPerformed(ActionEvent evt)
	61.	        {
	62.	         System.exit(0);
	63.	        }
	64.	      });
	65.	   contentPane.add(buttonPanel, BorderLayout.SOUTH);
	66.	  }
	67.	
	68.	  /**
	69.	   Adds a button to a container.
	70.	   @param c the container
	71.	   @param title the button title
	72.	   @param listener the action listener for the button
	73.	  */
	74.	  public void addButton(Container c, String title,
	75.	   ActionListener listener)
	76.	  {
	77.	   JButton button = new JButton(title);
	78.	   c.add(button);
	79.	   button.addActionListener(listener);
	80.	  }
	81.	
	82.	  /**
	83.	   Adds a bouncing ball to the canvas and starts a thread
	84.	   to make it bounce
	85.	   @param priority the priority for the threads
	86.	   @color the color for the balls
	87.	  */
	88.	  public void addBall(boolean selfish, Color color)
	89.	  {
	90.	   Ball b = new Ball(canvas, color);
	91.	   canvas.add(b);
	92.	   BallThread thread = new BallThread(b, selfish);
	93.	   thread.start();
	94.	  }
	95.	
	96.	  private BallCanvas canvas;
	97.	  public static final int WIDTH = 450;
	98.	  public static final int HEIGHT = 350; 
	99.	}
	100.	
	101.	/**
	102.	  A thread that animates a bouncing ball.
	103.	*/
	104.	class BallThread extends Thread
	105.	{
	106.	  /**
	107.	   Constructs the thread.
	108.	   @aBall the ball to bounce
	109.	   @boolean selfishFlag true if the thread is selfish, using
	110.	   a busy wait instead of calling sleep
	111.	  */
	112.	  public BallThread(Ball aBall, boolean selfishFlag) 
	113.	  { 
	114.	   b = aBall; 
	115.	   selfish = selfishFlag;
	116.	  }
	117.	
	118.	  public void run()
	119.	  {
	120.	   try
	121.	   {
	122.	     for (int i = 1; i <= 1000; i++)
	123.	     {
	124.	      b.move();
	125.	      if (selfish)
	126.	      {
	127.	        // busy wait for 5 milliseconds
	128.	        long t = System.currentTimeMillis();
	129.	        while (System.currentTimeMillis() < t + 5)
	130.	         ;
	131.	      }
	132.	      else
	133.	        sleep(5);
	134.	     }
	135.	   }
	136.	   catch (InterruptedException exception)
	137.	   {          
	138.	   }
	139.	  }
	140.	
	141.	  private Ball b;
	142.	  boolean selfish;
	143.	}
	144.	
	145.	/**
	146.	  The canvas that draws the balls.
	147.	*/
	148.	class BallCanvas extends JPanel
	149.	{
	150.	  /**
	151.	   Add a ball to the canvas.
	152.	   @param b the ball to add
	153.	  */
	154.	  public void add(Ball b)
	155.	  {
	156.	   balls.add(b);
	157.	  }
	158.	
	159.	  public void paintComponent(Graphics g)
	160.	  {
	161.	   super.paintComponent(g);
	162.	   Graphics2D g2 = (Graphics2D)g;
	163.	   for (int i = 0; i < balls.size(); i++)
	164.	   {
	165.	     Ball b = (Ball)balls.get(i);
	166.	     b.draw(g2);
	167.	   }   
	168.	  }
	169.	
	170.	  private ArrayList balls = new ArrayList();
	171.	}
	172.	
	173.	/**
	174.	  A ball that moves and bounces off the edges of a 
	175.	  component
	176.	*/
	177.	class Ball
	178.	{
	179.	  /**
	180.	   Constructs a ball in the upper left corner
	181.	   @c the component in which the ball bounces
	182.	   @aColor the color of the ball
	183.	  */
	184.	  public Ball(Component c, Color aColor) 
	185.	  { 
	186.	   canvas = c; 
	187.	   color = aColor;
	188.	  }
	189.	
	190.	  /**
	191.	   Draws the ball at its current position
	192.	   @param g2 the graphics context
	193.	  */
	194.	  public void draw(Graphics2D g2)
	195.	  {
	196.	   g2.setColor(color);
	197.	   g2.fill(new Ellipse2D.Double(x, y, XSIZE, YSIZE));
	198.	  }
	199.	
	200.	  /**
	201.	   Moves the ball to the next position, reversing direction
	202.	   if it hits one of the edges
	203.	  */
	204.	  public void move()
	205.	  {
	206.	   x += dx;
	207.	   y += dy;
	208.	   if (x < 0)
	209.	   { 
	210.	     x = 0;
	211.	     dx = -dx;
	212.	   }
	213.	   if (x + XSIZE >= canvas.getWidth())
	214.	   {
	215.	     x = canvas.getWidth() - XSIZE; 
	216.	     dx = -dx; 
	217.	   }
	218.	   if (y < 0)
	219.	   {
	220.	     y = 0; 
	221.	     dy = -dy;
	222.	   }
	223.	   if (y + YSIZE >= canvas.getHeight())
	224.	   {
	225.	     y = canvas.getHeight() - YSIZE;
	226.	     dy = -dy; 
	227.	   }
	228.	
	229.	   canvas.repaint();
	230.	  }
	231.	
	232.	  private Component canvas;
	233.	  private Color color;
	234.	  private static final int XSIZE = 15;
	235.	  private static final int YSIZE = 15;
	236.	  private int x = 0;
	237.	  private int y = 0;
	238.	  private int dx = 2;
	239.	  private int dy = 2;
	240.	}
  • + Share This
  • 🔖 Save To Your Account