Java Threads

Jussi Pohjolainen

TAMK University of Applied Sciences » ICT

What are threads?

• Multithreading: methods that are running at the same time
• In Java: An instance of a class java.lang.Thread
• JVM is responsible scheduling the threads
• Sometimes native OS's thread system is used... and sometimes it is not
• Different JVMs run threads in a different way.

Making a thread

• When making a thread, java.lang.Thread class is always used.
• There are two choices when creating a thread.
  1. Extending the Thread - class
  2. Implementing Runnable - interface
• Implementation of the thread itself is coded always in a method called run()

1. Extending java.lang.Thread

• The simplest way to define code to run in a separate thread is to extend the Thread class and override run() - method

• class MyThread extends Thread {
      public void run() {
          // Implement your thread here
      }
  }
  

• To start the thread, you create instance of the class and call it's start() - method.

• MyThread thread = new MyThread();
  thread.start();
  

1. Example of Extending java.lang.Thread

class MyThread extends Thread {
    int i = 0;
    public void run() {
        while( true ) {
            System.out.println(i++);
        }
    }
    public static void main(String [] args) {
        ( new MyThread() ).start();
    }
}

2. Implementing java.lang.Runnable

• Implement the Runnable-interface

• class MyThread implements Runnable {
      public void run() {
          // Implement your thread here
      }
  }
  

• Every thread of execution begins as an instance of Thread- class
• Thread - class is needed when starting the execution!
• To start the thread:

  MyThread temp = new MyThread();
  Thread thread = new Thread( temp );
  thread.start();
  

2. Example of Implementing java.lang.Runnable

class MyThread implements Runnable {
    int i = 0;
    public void run() {
        while( true ) {
            System.out.println(i++);
        }
    }
    public static void main(String [] args) {
        Thread thread = new Thread( new MyThread() );
        thread.start();
    }
}

Thread states

Starting a thread

• Once the Thread is created, you have to start it.
• Starting the thread is done by using start()-method: t.start();
• What happens after you call start()?
  • A new thread of execution starts
  • The thread moves from new state to runnable state.
  • When the thread gets a chance to execute, its target run() method will run.

Influencing the thread

• The thread scheduler is the part of JVM that decides which thread should run at any given moment
• Any thread in the Runnable state can be chosen by the scheduler
• The order in which runnable threads are chosen to run is not guaranteed
• We can't control scheduler, but we can sometimes influence it..

Thread priorities

• Threads always run with some priority (number from 1-10)
• Higher priority threads are executed more often than the lower priority threads
• Setting the priority:
  • t.setPriority( int priority );
  • Three constants: Thread.MIN_PRIORITY (1), Thread.NORM_PRIORITY (5), Thread.MAX_PRIORITY (10)

class MyThread extends Thread {
    private static Time time;
    
    private int number;
  
    public void run() {
        while( time.getTime() >= 0 ) {
            System.out.println( Thread.currentThread().getName() );
            number++;
        }
        System.out.println(Thread.currentThread().getName() + " Number of execution: " + number);
    }
    
    public static void main(String [] args) {
        MyThread thread1 = new MyThread();
        thread1.setName("Min");
        MyThread thread2 = new MyThread();
        thread2.setName("Max");
        
        time = new Time();
        thread1.setPriority(1);
        thread2.setPriority(10);
        
        time.start();
        thread1.start();
        thread2.start();
    }
}

class Time extends Thread {
    private int time = 10;
    
    public int getTime() {
        return time;
    }
    
    public void run() {
        while(time >= 0) {
            time--;
            try {
                sleep(1000);
            } catch( InterruptedException e ) {
                e.printStackTrace();
            }
        }
    }
}

yield()

• Thread.yield() tries to make the currently running thread head back to runnable to allow other threads of the same priority to get their turn.
• Promote graceful turn-taking among equal priority threads.
• Calling yield doesn't guarantee much..

Synchronizing Code

• There might be a problem, if two threads accesses the same data
• Example
  • Two people each have a ATM cards that are linked to only one account
  • What happens when these two people accesses the account at the same time?
• Withdrawal is two-step process
  1. Check the balance
  2. If there's enough money int the account, make the withdrawal
• What happens if 1 and 2 are separated?

class AccountDanger implements Runnable {
	private Account acct = new Account();
	
	public static void main(String [] args){
		AccountDanger r = new AccountDanger();
		Thread lucy = new Thread(r, "Lucy");
		Thread fred = new Thread(r, "Fred");
		lucy.start();
		fred.start();
	}
	public void run() {
		for(int x = 0; x < 5; x++){
			makeWithdrawal(10);
			if(acct.getBalance() < 0 ){
				System.out.println("account is overdrawn!");
			}
		}
	}
	private void makeWithdrawal(int amt) {
		if(acct.getBalance() >= amt){
			System.out.println(Thread.currentThread().getName() + " is going to withdraw!");
			try{
				Thread.sleep(500);
			}
			catch(InterruptedException ex){}
			acct.withdraw(amt);
			System.out.println(Thread.currentThread().getName() + " completes the withdrawal!");
		}
		else{
			System.out.println("Not enough in account for " + Thread.currentThread().getName() + " to withdraw " + acct.getBalance());
		}
	
	}

}

class Account{
	private int balance = 50;
	public int getBalance() {
		return balance;
	}
	public void withdraw(int amount) {
		balance = balance - amount;
	}
}

Synchronized - keyword

• We must guarantee that the two steps are never split apart. Use synchronized keyword
• Synchronization works with locks. Every object has a lock. If one thread has picked up the lock, no other thread can use the synchronized code.

Synchronized - example 1

• 
  class MyThread implements Runnable {
      public synchronized void run() {
          for(int i=0; i<100; i++) 
              System.out.println(i);
      }
      public static void main(String [] args) {
          MyThread temp = new MyThread();
          Thread thread1 = new Thread(temp);
          Thread thread2 = new Thread(temp);
          thread1.start();
          thread2.start();
      }
  }
  

Synchronized - example 2

• 
  class MyThread implements Runnable {
      public void run() {
          synchronized(this) {
              for(int i=0; i<100; i++) 
                  System.out.println(i);
          }
      }
      public static void main(String [] args) {
          MyThread temp = new MyThread();
          Thread thread1 = new Thread(temp);
          Thread thread2 = new Thread(temp);
          thread1.start();
          thread2.start();
      }
  }
  

Synchronized - example 3

class MyThread implements Runnable {
    private Vector list;
    public MyThread(Vector list) {
        this.list = list;
    }
    public void run() {
        synchronized(list) {
            list.add("a");
            list.add("b");            
            for (String s : list) {
                System.out.println(s);
            }
            System.out.println("* *");
        }
    }
    public static void main(String [] args) {
        Vector list = new Vector();
        MyThread temp = new MyThread(list);      
        Thread thread1 = new Thread(temp);
        Thread thread2 = new Thread(temp);
        thread1.start();
        thread2.start();
    }
}