Question

Create a simple Java application that will exhibit concurrency concepts. Your application should create two threads that will act as counters. One thread should count up to 20. Once thread one reaches 20, then a second thread should be used to count down to 0. For your created code, please be provide a detailed analysis of appropriate concepts that could impact your application. Specifically, please address:

• Performance issues with concurrency
• Vulnerabilities exhibited with use of strings
• Security of the data types exhibited.

Answer 1

In case of any queries, please revert back.

public class Main extends Thread
{
public static void main(String[] args)
{
//We have referenced thread1 as the Main thread of the program.
Thread thread1=Thread.currentThread();
  
//Fort this thread to work first, we set its priority as max.
thread1.setPriority(MAX_PRIORITY);
  
//Countdown Begins
for(int k=1;k<=20;k++){
System.out.println("Count 1 : "+ k);
}
  
//Now, we declare thread2 as Child process.
NextThread thread2=new NextThread();
  
//start the second concurrent thread
thread2.start();
  
}
}

/*This class is extended as Class acts as thread. When start() is encountered, run() is executed.*/
class NextThread extends Thread
{
@Override
public void run()
{
for (int i = 20; i >= 1; i--)
{
System.out.println("Countdown 2 : "+i);
}
}   
}

}

Some Vulnerabilities are :-

Performance issues with concurrency :-

Some Threads may block the working of other threads. They may clog the CPU which may lead to starvation. Useless excessive Threading is Harmful and may lead to some unexpected errors. Due to their complicated mechanism, threads have to be used with extra care. So, they have performance issues.

Vulnerabilities exhibited with use of strings :-

Strings are unprotected and can be manipulated easily if kept public. Straightforwardly incorporating client contribution to an organization string lets an aggressor infuse design particulars into the arrangement string. This is especially risky in programming dialects. On the off chance that assailants can compose information esteems to memory, they can regularly use that to oversee the framework.

Security of the data types exhibited. :-

The Java language is exacting in its meaning of the language.All crude variables in the language are destined to be a particular size.All tasks are characterized to be acted in a predefined order.Two right Java compilers will never give various outcomes for execution of a program.An get to modifier limits the entrance of a class, constructor, information part and technique in another class. In java we have four access modifiers.These are default, public, private,protected. This prevents leakage of data from a class as in OOPS, we require data to be strictly contained in its domain.