Bully algorithm in Java

The bully algorithm is a type of Election algorithm which is mainly used for choosing a coordinate. In a distributed system, we need some election algorithms such as bully and ring to get a coordinator that performs functions needed by other processes.

Election algorithms select a single process from the processes that act as coordinator. A new process is selected when the selected coordinator process crashes due to some reasons. In order to determine the position where the new copy of coordinator should be restarted, the election algorithms are used.

It assumes that each process has a unique priority number in the system, so the highest priority process will be chosen first as a new coordinator. When the current use coordinator process crashes, it elects a new process having the highest priority number. We note that priority number and pass it to each active process in the distributed system.

The Bully election algorithm is as follows:

Let's assume that P is a process that sends a message to the coordinator.

It will assume that the coordinator process is failed when it doesn't receive any response from the coordinator within the time interval T.
An election message will be sent to all the active processes by process P along with the highest priority number.
If it will not receive any response within the time interval T, the current process P elects itself as a coordinator.
After selecting itself as a coordinator, it again sends a message that process P is elected as their new coordinator to all the processes having lower priority.
If process P will receive any response from another process Q within time T:
1. It again waits for time T to receive another response, i.e., it has been elected as coordinator from process Q.
2. If it doesn't receive any response within time T, it is assumed to have failed, and the algorithm is restarted.

BullyAlgoExample.java

// import required classes and packages
packagejavaTpoint.javacodes;

import java.io.*;
importjava.util.Scanner;

// create class BullyAlgoExample to understand how bully algorithms works
classBullyAlgoExample{
	
	// declare variables and arrays for process and their status
staticintnumberOfProcess;
staticintpriorities[] = newint[100];
staticintstatus[] = newint[100];
staticintcord;

    // main() method start
publicstaticvoid main(String args[])throwsIOException	// handle IOException
    {
	// get input from the user for the number of processes 
System.out.println("Enter total number of processes:");

        // create scanner class object to get input from user
        Scanner sc = newScanner(System.in);
numberOfProcess = sc.nextInt();

inti;

        // use for loop to set priority and status of each process
for(i = 0; i<numberOfProcess; i++)
        {
System.out.println("Status for process "+(i+1)+":");
status[i] = sc.nextInt();
System.out.println("Priority of process "+(i+1)+":");
priorities[i] = sc.nextInt();
        }

System.out.println("Enter proces which will initiate election");
intele = sc.nextInt();

sc.close();

        // call electProcess() method 
electProcess(ele);
System.out.println("After electing process the final coordinator is "+cord);
    }

    // create electProcess() method 
staticvoidelectProcess(intele)
    {
ele = ele - 1;
cord = ele + 1;

for(inti = 0; i<numberOfProcess; i++)
        {
	if(priorities[ele]<priorities[i])
            {
System.out.println("Election message is sent from "+(ele+1)+" to "+(i+1));
if(status[i]==1)
	electProcess(i+1);
            }
        }
    }
}

BullyAlgoExample2.java

// import required classes and packages
packagejavaTpoint.javacodes;

importjava.util.Scanner;

// create process class for creating a process having id and status
class Process{
	// declare variables
	publicint id;
	public String status;
	
	// initialize variables using constructor
	public Process(int id){
		this.id = id;
		this.status = "active";
	}
}
// create class BullyAlgoExample2 for understanding the concept of Bully algorithm
publicclass BullyAlgoExample2 {
	
	// initialize variables and array
	Scanner sc;
	Process[] processes;
	int n;
	
	// initialize Scanner class object in constructor
	public BullyAlgoExample2(){
		sc= new Scanner(System.in);
	}
	
	// create ring() method for initializing the ring
	publicvoid ring(){
		
		// get input from the user for processes
		System.out.println("Enter total number of processes of Processes");
		n = sc.nextInt();
		
		// initialize processes array
		processes = new Process[n];
		for(inti = 0; i< n; i++){
			processes[i]= new Process(i);
		}
	}
	
	// create election() method for electing process
	publicvoidperformElection(){

		// we use the sleep() method to stop the execution of the current thread
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			
			e.printStackTrace();
		}
		
		// show failed process
		System.out.println("Process having id "+processes[getMaxValue()].id+" fails");
		
		// change status to Inactive of the failed process
		processes[getMaxValue()].status = "Inactive";
		
		// declare and initialize variables 
		intidOfInitiator = 0;
		booleanoverStatus = true;
		
		// use while loop to repeat steps 
		while(overStatus){
			
			booleanhigherProcesses = false;
			
			// iterate all the processes
			for(inti = idOfInitiator + 1; i< n; i++){
				if(processes[i].status == "active"){
					System.out.println("Process "+idOfInitiator+" Passes Election("+idOfInitiator+") message to process" +i);
					higherProcesses = true;

				}
			}
			
			// check for higher process
			if(higherProcesses){
				
				// use for loop to again iterate processes
				for(inti = idOfInitiator + 1; i< n; i++){
					if(processes[i].status == "active"){
						System.out.println("Process "+i+"Passes Ok("+i+") message to process" +idOfInitiator);
					}

				}
				// increment initiator id 
				idOfInitiator++;
			}

			else{
				// get the last process from the processes that will become coordinator
				intcoord = processes[getMaxValue()].id;
				
				// show process that becomes the coordinator
				System.out.println("Finally Process "+coord+" Becomes Coordinator");
				
				
				for(inti = coord - 1; i>= 0; i--){
					if(processes[i].status == "active"){
						System.out.println("Process "+coord+"Passes Coordinator("+coord+") message to process " +i);
					}
				}
				
				
				System.out.println("End of Election");
				overStatus = false;
				break;
			}
		}

	}
	
	// create getMaxValue() method that returns index of max process
	publicintgetMaxValue(){
		intmxId = -99;
		intmxIdIndex = 0;
		for(inti = 0; i<processes.length; i++){
			if(processes[i].status == "active" && processes[i].id >mxId){
				mxId = processes[i].id;
				mxIdIndex = i;
			}
		}
		returnmxIdIndex;
	}
	
	// main() method start
	publicstaticvoid main(String[] args) {
		
		// create instance of the BullyAlgoExample2 class
		BullyAlgoExample2 bully = newBullyAlgoExample2();
		
		// call ring() and performElection() method
		bully.ring();
		bully.performElection();

	}

}

Output: