PriorityThreadQueue and ListManager

This document includes the implementation of PriorityThreadQueue and ListManager classes in Java. PriorityThreadQueue class demonstrates how to compare and sort threads based on their priority, while ListManager class shows how to shuffle and swap elements in two lists.

1. Questions 1.
import java.util.Comparator;
import java.util.ArrayList;
import java.util.List;
import java.util.Collections;
import java.util.Random;
public class PriorityThreadQueue extends Thread implements Runnable
{
public void run()//implementing the run method for each Thread
{
System.out.println("This is currently the thread with the highest priority "
+ this.getPriority());
}
//To compare the priority of the thread to neccesiate the storage
//of one with the highest priority.
static class ThreadSorting implements Comparator<PriorityThreadQueue>
{
@Override
public int compare(PriorityThreadQueue t1, PriorityThreadQueue t2) {
if(t1.getPriority() > t2.getPriority())
return 1;
else if(t1.getPriority() == t2.getPriority())
return 0;
else
return -1;
}
}
//Driver program to randomly assign priorities to threads
//It tests their priorities.
public static void main(String[] args) {
//Lets create the threads
PriorityThreadQueue t1 = new PriorityThreadQueue();
PriorityThreadQueue t2 = new PriorityThreadQueue();
PriorityThreadQueue t3 = new PriorityThreadQueue();
Random rnd = new Random();
//Lets randomly generate priorities for the threads
//throws IllegalArgument exception otherwise
t1.setPriority(rnd.nextInt(10));
t2.setPriority(rnd.nextInt(10));
t3.setPriority(rnd.nextInt(10));
List<PriorityThreadQueue> list = new ArrayList<>();
list.add(t1);
list.add(t2);
list.add(t3);
Collections.sort(list, new ThreadSorting());//sorting the threads based on our
//ThreadSorting class
//Test the threads stored in the arraylist
for(int i = list.size() -1; i > 0; i--)
{
PriorityThreadQueue curr = list.get(i);
curr.run();
}
}
}

A screenshot illustrating the result of the above class.
2. Question 2.
import java.util.*;
public class ListManager implements Runnable
{
int i;
int k;
private List<Integer> lst1 = new ArrayList<>();
private List<Integer> lst2 = new ArrayList<>();
public ListManager(int n,int i,int k ){
this.i =i;
this.k = k;
for(int j = 0; j < n; j++){
lst1.add((int)(Math.random()*100));
lst2.add((int)(Math.random()*100));
}
}
@Override
public void run() {
//To shuffleBoth
shuffleBoth();
//To atomicSwap the lists
atomicSwap(i, k);
//To check if they are equal

boolean equal = bothEqual();
if(equal)
System.out.println("They are both equal");
}
private void atomicSwap(int i, int j)
{
try {
Collections.swap(this.lst1, 0,i);
Collections.swap(this.lst2, 0, j);
}
catch(Exception e) {
e.printStackTrace();
}
}
private void shuffleBoth() {
Collections.shuffle(lst1);
Collections.shuffle(lst2);
}
private boolean bothEqual()
{
Random rand = new Random();
try {
int i = rand.nextInt(lst1.size());
if (lst1.get(i) == lst2.get(i))
return true;
}catch(Exception e)
{
e.printStackTrace();
}
return false;
}
//Driver program to test the program.
Public static void main (String[] args)
{
int N = 8;
int i = 1;
int j = 2;
ListManager manager = new ListManager(N,i, j);
manager.run();
}
}

A screenshot illustrating the results of the program 2.