• Föreläsning 4

Innehåll, föreläsning 5 (Animering, trådar och strömmar)

• Klassen Thread
  • En tråds liv
  • Animering
  • Dubbelbuffring
  • Synkronisering
  • Multithreading
• Strömmar
  • Grundklasserna
  • Skrivning till skärmfönster och läsning från tangentbord
  • Textfiler
  • Binärfiler

Föreläsning 5: Animering, trådar och strömmar

Klassen Thread

En tråds liv

• En tråd skapas med hjälp av en konstruktor
• En tråd startas (eller oftare hamnar i tillståndet "färdig att köras")
• En tråd kan exekveras varefter den hamnar i något av följande tillstånd:
  • färdig att köras (när min tur kommer)
  • sovande
  • suspenderad
  • väntande
  • blockerad (väntande på att en I/O-operation ska bli klar)
• En tråd kan försvinna (eller snarare fås att försvinna)

Klassen Thread implementerar trådar. Dess vanligaste konstruktorer är:

Thread() 
Thread(Runnable)

Viktiga metoder i Thread är

static void sleep(long millis) - söver ner den tråd som exekverar
static void sleep(long millis , int nanos) - söver ner den tråd som exekverar
void start() - startar exekveringen av tråden
void final stop() - stoppar exekveringen av tråden
void final suspend() - stoppar tillfälligt en tråd
void final resume() - startar om en tråd som stoppats med suspend()
static yield() - stoppar tillfälligt den tråd som nu exekverar

Ingen av metoderna ovan ersätts vanligen, man anropar dem vid behov.

Animering

Koden följer här:

import java.applet.*;
import java.awt.*;

public class WelcomeAnimation extends Applet implements Runnable
{
    static final int sleepingTime = 100;
    static final String msg = 
	"Welcome to the World of Internet Programming";
    private Font font;
    private int size = 100;
    private boolean shrinking = true;
    private Thread animator = null;

    public void init() 
    {
	super.init();
	font = new Font("Times", Font.BOLD, 12 );
	setBackground( Color.white );
    }
    
    public void start() // Appletens start(), *ej* trådens
    {
	animator = new Thread( this ); // Skapa en tråd
	animator.start();        
    }

    public void stop() // Appletens stop(), *ej* trådens
    {
	animator.stop();
        animator = null;
    }

    public void paint( Graphics g)
    {
	g.setColor(Color.red);
	g.fillOval(230-size*3/2, 97-size/2, size*3, size);
	if (shrinking)
	    { size -= 2; if (size == 0) shrinking = false;  }
	else
	    { size += 2; if (size == 100) shrinking = true; }
       	g.drawString( msg, 100, 100);		
    }

    
    public void run()
    {
	while (true)
	    {
		repaint();
		try { Thread.sleep(sleepingTime); }
		catch (InterruptedException e) { System.exit(1); }
	    }
    }
    
    public void destroy()
    {
	if ( animator != null ) 
	    {
		animator.stop();
		animator = null; // För att hjälpa skräphanteraren ...
	    }
    }
    
};

Dubbelbuffring

Koden finns här

Ytterligare ett exempel på dubbelbuffring är det tidigare exemplet där koden ser ut så här med dubbelbuffring. I större applikationer kan man uppnå mycket genom att rita om bara den del av appleten som ändrats i stället för att rita om allt som vi gör i dessa exempel.

Synkronisering

Programmet har tre klasser: SynchronizerDemo, Producer och Consumer varav de båda senare exekverar i varsin tråd och alltså asynkront placerar varor i lagret respektive tar bort dem. För att göra det hela litet mer intressant finns en slumpmässig försening i klasserna. Dessutom kan man suspendera och starta om både producent och konsument. När lagret är fullt och producenten vill lägga in en vara (men alltå måste vänta) visas en röd markering på "producentsidan" och om lagret är tomt och konsumenten försöker hämta en vara visas motsvarande markering på "konsumentsidan". Lagret visas som en stapel i mitten.

Vi tittar först på valda delar av klassen SynchronizerDemo (de delar som har med den grafiska presentationen utelämnas):

public class SynchronizerDemo extends Applet
{
    final int bufferSize = 20;
    int inStore = 0;
    private Producer producer =  null;
    private Consumer consumer =  null;

 public void init() 
    {
        consumer = new Consumer( this );
        producer = new Producer( this );
    }

    synchronized void get()
    {
        if (inStore == 0)
            {
                setEmpty( true );
                try  { wait(); }
                catch ( InterruptedException e) {}
            }
        if ( (inStore--) == bufferSize )  // Om bufferten var full *innan*
            notify(); // vi tog ett element meddelar vi att nu finns det plats

    }
    
    synchronized void put()
    {
        if (inStore == bufferSize)
            {
                try { wait(); }
                catch ( InterruptedException e) {}
            }
        if ( (inStore++) == 0) // Om bufferten var tom *innan* vi lade dit ett
            notify();     // element meddelar vi att nu finns element att hämta
    }

    public void destroy()
    {
        if ( producer != null ) { producer.stop(); producer = null; }
        if ( consumer != null ) { consumer.stop(); consumer = null; }
    }
}

De andra verktygen för synkronisering är metoderna wait() och notify(). Man anropar wait() i en synkroniserad metod för att låta en annan tråd exekvera så att skälet till att man väntar kan upphävas. notify() är motsatsen till wait(): man väcker upp en väntande tråd efter att något skett med objektet, i vårt fall att lagret inte längre är tomt respektive att det inte längre är fullt. Det objekt som väcks är det som har egenrätt på SynchronizerDemo-instansen just nu, d.v.s. det objekt som startade en synkroniserad metod.

Observera att metoden wait() alltså släpper "låset" på objektet SynchronizerDemo så att producenten eller konsumenten kan uppdatera objektet.

Klasserna Producer och Consumer (även de något förenklade genom att grafiken tagits bort):

class Producer extends Thread
{
    SynchronizerDemo demo;
    long sleepingTime = 500;

    Producer( SynchronizerDemo d ) 
    {
        demo = d;
        start();
    }

    public void run()
    {
        while (true) 
            {
                try { if (Math.random()>0.9) sleep(sleepingTime); }
                catch ( InterruptedException e) {}
                demo.put();
            }
    }
}

class Consumer extends Thread
{
    SynchronizerDemo demo;
    long sleepingTime = 500;

    Consumer( SynchronizerDemo  d)
    {
        demo = d;
        start();
    }

    public void run()
    {
        while (true) 
            {
                try { if (Math.random()>0.9) sleep(sleepingTime); } 
                catch ( InterruptedException e) {}
                demo.get();
            }
    }
}

Konsumenten och producenten är båda arvtagare till Thread och har alltså redan ärvt gränssnittet Runnable genom Thread. Det kanske mest intressanta med klasserna är att ingendera innehåller några konstigheter: all synkronisering sker i klassen SynchronizerDemo. Allt Producer och Consumer gör är att producera och konsumera så fort de kan.

Den fullständiga programkoden visar också hur man kan implementera en ActionListener som ser efter vilken knapp som användaren tryckte på.

Multithreading

Ett roligt (?) exempel (som också visar på skillnaden i effektivitet hos några sorteringsalgoritmer) på multithreading finns här

Strömmar

Javas stream-klasser finns i java.io-paketet. Klasserna kan delas upp litet olika beroende på synsätt: en uppdelning kan vara huruvida man arbetar med tecken eller bytedata (bilder, ljud, etc): i Java är denna uppdelning tydlig:

• klasser vars namn slutar ...Reader läser tecken
• klasser vars namn slutar ...Writer skriver tecken
• klasser vars namn slutar ...InputStream läser bytedata
• klasser vars namn slutar ...OutputStream skriver bytedata

Grundklasserna

Reader: (läser tecken eller arrayer av tecken)
 int read(); // läser ett tecken och returnerar det i en int
 int read( char buf[] ); // läser högst buf.length  tecken, returnerar antalet

InputStream: (läser bytes eller arrayer av bytes)
 int read(); // läser ett tecken och returnerar det i en int
 int read( byte buf[]);// läser högst buf.length bytes, returnerar antalet

Writer: (skriver tecken eller arrayer av tecken)
 int write( int c); // skriver ett tecken (c)
 int write( char buf[] ); // skriver en array (buf.length st.) av tecken

OutputStream: (skriver bytes eller arrayer av bytes)
 int write( int c); // skriver en byte
 int write( byte buf[] ); // skriver en array (buf.length) av bytes

Skrivning till skärmfönster och läsning från tangentbord

Metoder för skrivning:

print( argument ); // skriv argumentet
println( argument ); // skriv argumentet, följt av en newline

Eftersom operatorn + fungerar för strängar kan man skriva ut flera saker i samma print under förutsättning att de objekt man skriver är instanser av klasser med en toString()-metod. I Java har man ingen kontroll över hur många siffror som skrivs ut vid utmatning av flyttal t.ex.

Vid läsning måste litet mer jobb till (InputStream innehåller endast de byte-baserade inläsningsmetoderna). Man gör då så att man skapar en InputStreamReader t.ex:

InputStreamReader = new InputStreamReader( System.in );

BufferedReader = new BufferedReader( new InputStreamReader( System.in ));

String readLine()  - läs en rad

Java är inte speciellt bra på denna typ av I/O; förklaringen ligger i att moderna program använder grafiska användargränssnitt och därför inte behöver ha tillgång till ett fullständigt utbyggt bibliotek för textmässig läsning och skrivning. Det är ju faktiskt också så att program som inte har råd att krascha inte kan läsa in tal på annat sätt än genom egen parsning och för detta finns stöd i Java.

Textfiler

BufferedReader infile = new BufferedReader( new FileReader("filnamn.ny") );
PrintWriter outfile = new PrintWriter( new FileWriter("filnamn.old") );

De båda instanserna infile och outfile kan nu användas exakt som klasserna i föregående avsnitt.

Ett exempel får avsluta detta avsnitt. Programmet nedan läser en textfil och räknar, dels totala antalet ord, dels också hur många gånger ett antal ord förekommer. Resultatet skrivs till skärmfönstret. Programmer använder en StreamTokenizer för att dela upp text i ord:

import java.io.*;

class Grep
{
    public static void main( String[] args ) throws IOException
    {
	StreamTokenizer infile = 
	    new StreamTokenizer( new FileReader( args[0] ) );
	int numWordsToLookFor = args.length;
	int[] numWords  = new int [ numWordsToLookFor ];
	for (int i=0; i < numWordsToLookFor; i++)
	    numWords[i] =  0;
	while ( infile.nextToken() != StreamTokenizer.TT_EOF )
	    if (infile.ttype == infile.TT_WORD )
		{
		    numWords[0]++; // räknar totala antalet ord
		    for (int i=1; i < numWordsToLookFor; i++)
			if ( infile.sval.equals( args[i] ))
			    numWords[i]++;
		}
	System.out.println( "Totala antalet ord: " + numWords[0] );
	for (int i=1; i<numWordsToLookFor; i++)
	    System.out.println( args[i] + ": " + numWords[i] );
    }
}

java Grep Grep.java infile numWords

Totala antalet ord: 69
infile: 1
numWords: 6

Binärfiler

import java.io.*;

public class FileCopy
{
    public static final int BUFSIZE = 4096;

    public static void copy( String sourceName, String destinationName )
	throws IOException
    {
	FileInputStream source = null;
	FileOutputStream destination = null;
	try
	    {
		source =  new FileInputStream( sourceName );
		destination = new FileOutputStream( destinationName );
		byte[] buffer = new byte[BUFSIZE];
		int numBytesRead;
		while ( ( numBytesRead = source.read(buffer)) != -1)
		    destination.write( buffer, 0, numBytesRead);
	    }
	finally  // vi stänger alltid filerna
	    {
		if (source != null) 
		    { try { source.close(); } catch (IOException e) {} }
		if (destination != null)
		    { try { destination.close(); } catch (IOException e) {} }
		    
	    }
    }

    public static void main( String[] args ) throws IOException
    {
	copy ( args[0], args[1] );
    }
	
}

Mer om hur man använder strömmar, och koordination mellan asynkron input och output, kommer i avsnittet om nätverksprogrammering. I filkopieringsprogrammet ovan läses troligen 4096 bytes varje gång (utom den sista) men om filen ligger på en annan dator någonstans i världen kan man inte vara säker på att så är fallet.