Joining Threads

[zhamri]

Instruction:

Write a Java program to generate 1000 random numbers between 0 to 1000 and store the numbers in an array. Then execute the following task using FOUR (4) threads.

1. display all the numbers
2. sort the numbers in ascending order and display the sorted numbers
3. display the thread name with all the odd numbers
4. display the thread name with all the even numbers

Task-2 will be executed after Task-1 has completed. Task-3 and Task-4 will be executed after Task-2 has completed. After completing all the tasks, then calculate the execution time.

You are required to solve the problem by using at least FIVE (5) classes.

Example of output (if N=10):

Task-1 0
Task-1 1
Task-1 1
Task-1 2
Task-1 4
Task-1 5
Task-1 5
Task-1 7
Task-1 8
Task-1 9
Task-2 ... 0
Task-2 ... 1
Task-2 ... 1
Task-2 ... 2
Task-2 ... 4
Task-2 ... 5
Task-2 ... 5
Task-2 ... 7
Task-2 ... 8
Task-2 ... 9
Task-3 ...... 0
Task-4 ......... 1
Task-3 ...... 2
Task-4 ......... 1
Task-3 ...... 4
Task-4 ......... 5
Task-3 ...... 8
Task-4 ......... 5
Task-4 ......... 7
Task-4 ......... 9
Execution Time = 75ms

[raihanwidia]

import java.util.Random;

public class MainClass {

    public static int a[] = new int [1001];

    public static void main (String[]args ) {

        Random dom = new Random();

        for (int gwd = 0 ; gwd < a.length ; gwd ++){
          a[gwd] = dom.nextInt(1001);
        }

        DisplayNumbers q = new DisplayNumbers(a);
        SortingNumber p = new SortingNumber(a);
        OddNumber r = new OddNumber(a);
        EvenNumber s = new EvenNumber(a);

        Thread task1 = new Thread(q);
        task1.setName("Task 1 : ");
        Thread task2 = new Thread(p);
        task2.setName("Task 2 : ");
        Thread task3 = new Thread(r);
        task3.setName("Task 3 : ");
        Thread task4 = new Thread(s);
        task4.setName("Task 4 : ");

        task1.start();
        try {
            task1.join();

        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        task2.start();
        try {
            task2.join();

        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        task3.start();
        task4.start();

}
}

public class DisplayNumbers implements Runnable  {

    int [] rans; 

    public DisplayNumbers (int [] m ){

        this.rans = m;

    }

    @Override
    public void run() {
        System.out.println("Display ... ");
        for(int a = 0 ; a < rans.length ; a++) {
            System.out.println(Thread.currentThread().getName() +" "+rans[a]); 
        }

    }

}

import java.util.Arrays;

public class EvenNumber implements Runnable {
    int [] a;

    public EvenNumber(int [] a) {

        this.a = a ;
        Arrays.sort(a);

    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int g = 0 ; g < a.length ; g++) {
            if (a[g]%2 == 0)
            System.out.println(Thread.currentThread().getName() +" "+ a[g]); 
        }

    }

}

import java.util.Arrays;

public class OddNumber implements Runnable {

    int [] a;

    public OddNumber(int [] a) {

        this.a = a ;
        Arrays.sort(a);

    }

    @Override
    public void run() {
        System.out.println("And the rest  ... ");
        for(int g = 0 ; g < a.length ; g++) {
            if (a[g]% 2 != 0 )
            System.out.println(Thread.currentThread().getName() +" "+ a[g]); 
        }

    }

}

import java.util.Arrays;

public class SortingNumber implements Runnable {

    int [] a;
    int temp , n; 

    public SortingNumber(int [] a) {

        this.a = a ;
        Arrays.sort(a);

    }

    @Override
    public void run() {

        System.out.println("Sorting ... ");
        for(int g = 0 ; g < a.length ; g++) {
            System.out.println(Thread.currentThread().getName() +" "+ a[g]); 
        }

    }

}

if n=10

[muhammadbimo1]

Main

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package threadjoin;

import java.util.Random;

/**
 *
 * @author muhammadbimo
 */
public class ThreadJoin {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
                          Random rand = new Random();
          int[] numbers = new int[1001];
        for(int i = 0;i<numbers.length;i++){
            int n = rand.nextInt(1001);
            numbers[i] = n;
        }
        RandomNumbers obj = new RandomNumbers(numbers);
        SortNumbers obj1 = new SortNumbers(numbers);
        Thread t1 =new Thread(obj);
        Thread t2 =new Thread(obj1);
        Thread t3 = new Thread(obj);
        t1.start();
        t2.start();
        t3.start();
    }

}

DIsplay Random Numbers

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package threadjoin;

import java.util.Random;

/**
 *
 * @author muhammadbimo
 */
public class RandomNumbers implements Runnable{
int[]rans;

public RandomNumbers(int[]m){
    this.rans = m;
}
    @Override
    public void run() {
        for(int i = 0;i<rans.length;i++){
            System.out.println(rans[i]);
        }   
    }//To change body of generated methods, choose Tools | Templates.
}

Sort Numbers

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package threadjoin;

import java.util.Arrays;
import java.util.Random;

/**
 *
 * @author muhammadbimo
 */
public class SortNumbers implements Runnable{
int[]rans;

public SortNumbers(int[]m){
    this.rans = m;
}
    @Override
    public void run() {
        int temp;
           for (int i = 1; i < rans.length; i++) {
    for (int j = i; j > 0; j--) {
     if (rans[j] < rans [j - 1]) {
      temp = rans[j];
      rans[j] = rans[j - 1];
      rans[j - 1] = temp;
     }
    }

        }   
    }//To change body of generated methods, choose Tools | Templates.
}

[ShahifahYahya]

Main class

package realtime6;
import java.util.*;
import java.util.Random;

public class Issueran {
    public static void main(String [] args) {
    int[] array = new int[100];

    Random r = new Random();

    for (int i = 0; i < array.length; i++)
        {array[i] = r.nextInt(100);
    Arrays.sort(array);}

    new Thread(new Task1(array)).start();

    }
}

[ShahifahYahya]

package realtime6;

public class Task1 implements Runnable {
int [] array; 

    public Task1 (int [] a ){
        this.array = a;
        }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int x = 0 ; x < array.length ; x++) {
            System.out.println(array[x]); 
        }
    }
}

[ShahifahYahya]

Task 1

package realtime6;

public class Task1 implements Runnable {
int [] array; 

    public Task1 (int [] a ){
        this.array = a;
        }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int x = 0 ; x < array.length ; x++) {
            System.out.println(array[x]); 
        }}}

[ShahifahYahya]

Task 2

package realtime6;

import java.util.Arrays;

public  class Task2 implements Runnable {

int [] array; 

    public Task2 (int [] a ){
        this.array = a;
        }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int x = 0 ; x < array.length ; x++) {
            System.out.println(array[x]); 
            Arrays.sort(array);
        }
    }
    }

``

[Yvevonwen]

Main

import java.util.Random;

public class Issues7 {
     public static int[] arrayBox = new int[10];
     public static void main(String[] args) {   
         long start = System.currentTimeMillis();
         {}
         Random random = new Random();
         for (int i=0;i<arrayBox.length;i++) {
             arrayBox[i]=(int)(Math.random()*1001); 
         }

        Task1 task1 = new Task1(arrayBox);
        Task2 task2 = new Task2(arrayBox);
        Task3 task3 = new Task3(arrayBox);
        Task4 task4 = new Task4(arrayBox);
        Thread t1 = new Thread(task1);
        Thread t2 = new Thread(task2);
        Thread t3 = new Thread(task3);
        Thread t4 = new Thread(task4);
        t1.start();
        try {
            t1.join();
        }catch(InterruptedException e) {
            e.printStackTrace();
        }   
        t2.start();
        try {
            t2.join();
        }catch(InterruptedException e) {
            e.printStackTrace();
        }    
        t3.start();
        t4.start();

        long stop = System.currentTimeMillis();
        long elapsedTime = stop - start;
        System.out.println("The Execute time is : " +elapsedTime + "ms");
     }  
}

Task1

public class Task1 implements Runnable{
    int[] array;

    public Task1(int[] a) {
        this.array= a;
    }
    public void run() {
        for(int i=0;i<array.length;i++) {
            System.out.println(array[i]);
        }

    }   
}

Task2

import java.util.Arrays;

public class Task2 implements Runnable{
    int[] array;

    public Task2(int[] a) {
        this.array = a;

    }
    public void run() {
        System.out.println("\nAfter sort ascending number: ");
        for(int i=0;i<array.length;i++) {
            Arrays.sort(array);     
            System.out.println(array[i]);
        }
    }
}

Task3

public class Task3 implements Runnable{
    int[] array; 

    public Task3(int[] a) {
        this.array = a; 
    }
    public void run() {
        System.out.println("\nOdd Number:");
        for(int i=0;i<array.length;i++) {
            if(array[i]%2!=0) {
            System.out.println(array[i]);}
        }       
    }
}

Task4

public class Task4 implements Runnable{
    int[] array; 

    public Task4(int[] a) {
        this.array = a; 
    }
    public void run() {
        System.out.println("\nEven Number:");
        for(int i=0;i<array.length;i++) {
            if(array[i]%2 == 0) {
            System.out.println(array[i]);}
        }
    }
}

[ChanJunLiang]

Issue6 main

public class Issue6{

        public static int r[] = new int[10];

        public static void main(String args[]) {

            long startTime = System.currentTimeMillis();
            {}

            for(int x = 0; x < 10 ; x++)
            {
            double random = Math.random();
            random = random * 1000;
            int rand = (int)random;

            r[x] = rand;
            }

        Thread t1 = new Thread(new Randnum(r),"Task 1.");
        t1.start();

        try{
            t1.join();
        } catch (InterruptedException e){
            e.printStackTrace();
        }

        Thread t2 = new Thread(new Sort(r),"Task 2..");
        t2.start();

        try{
            t2.join();
        } catch (InterruptedException e){
            e.printStackTrace();
        }

        Thread t3 = new Thread(new OddNumber(r),"Task 3...");
        t3.start();

        Thread t4 = new Thread(new EvenNumber(r),"Task 4....");
        t4.start();

        try{
            t4.join();
        } catch (InterruptedException e){
            e.printStackTrace();
        }

        long stopTime = System.currentTimeMillis();
        long elapsedTime = stopTime - startTime;
        System.out.println("Execute time is : " +elapsedTime + "ms");

    }
}

Task1

class Randnum implements Runnable{
    int r[];

    public Randnum(int rn[]){
        this.r = rn;
    }

    public void run() {
        for(int i = 0 ; i < 10 ; i++) {
        System.out.println(Thread.currentThread().getName() + r[i]); 
        }

    }

}

Task2

import java.util.Arrays;

class Sort implements Runnable {

int r[];

public Sort(int r[]){
    this.r = r;
    Arrays.sort(r);
}

  public void run () {
   for (int s = 0; s < 10; ++s) {
    System.out.println(Thread.currentThread().getName() + "" + r[s]);
  }
}

}

Task3

class OddNumber implements Runnable{

        int r[];

        public OddNumber(int odd[]){
            this.r = odd;
        }

        public void run(){

            for (int o = 0; o < 10; o++) {
                if (r[o] % 2 != 0) {
                    System.out.println(Thread.currentThread().getName() + ":" + r[o]);
                }
            }

        }

}

Task4

class EvenNumber implements Runnable{

        int r[];

        public EvenNumber(int even[]){
            this.r = even;
        }

        public void run(){

            for (int e = 0; e < 10; e++) {
                if (r[e] % 2 == 0) {
                    System.out.println(Thread.currentThread().getName() + ":" + r[e]);
                }
            }

        }

}

output

[HENGZHIYONG]

Main

  package JoiningThreads;

  import java.util.Random;

  public class Main {
      public static int number[] = new int[10];
      public static void main(String[] args){
          long start = System.currentTimeMillis();
          {}

          Random random = new Random();

          for(int i=0 ; i<number.length;i++) {
            number[i] = random.nextInt(1001);
          }

          Thread t1 = new Thread(new Task_1(number),"Task1 :");
          t1.start();
          try {
            t1.join();
          }catch(Exception ex) {
            ex.printStackTrace();
          }
          Thread t2 = new Thread(new Task_2(number),"Task2 ...:");
          t2.start();
          try {
            t2.join();
          }catch(Exception ex) {
            ex.printStackTrace();
          }
          Thread t3 = new Thread(new Task_3(number),"Task3 ......:");
          t3.start();
          Thread t4 = new Thread(new Task_4(number),"Task4 .........:");
          t4.start();
          try {
            t4.join();
          }catch(Exception ex) {
            ex.printStackTrace();
          }

          long stop = System.currentTimeMillis();
          long elapsedTime = stop - start;
          System.out.println("The Execute time is : "+elapsedTime + "ms");      
        }   
  }

Task 1

package JoiningThreads;

public class Task_1 implements Runnable{

    int [] ran;

    public Task_1 (int [] m) {
        this.ran = m;
    }

    @Override
    public void run() {
        for(int a =0 ; a< ran.length ; a++) {
            System.out.println(Thread.currentThread().getName()+" "+ran[a]);
        }

    }

}

Task 2

package JoiningThreads;

import java.util.Arrays;

public class Task_2 implements Runnable{

int [] ran;

    public Task_2 (int [] m) {
        this.ran = m;
        Arrays.sort(ran);
    }

    @Override
    public void run() {
        for(int a =0 ; a< ran.length ; a++) {
            System.out.println(Thread.currentThread().getName()+" "+ran[a]);
        }
    }
}

Task 3

package JoiningThreads;

public class Task_3 implements Runnable{

int [] ran;

    public Task_3 (int [] m) {
        this.ran = m;
    }

    @Override
    public void run() {
        for(int a =0 ; a< ran.length ; a++) {
            if(ran[a]%2 != 0) {
            System.out.println(Thread.currentThread().getName()+" "+ran[a]);
        }
    }
   }
}

Task 4

package JoiningThreads;

public class Task_4 implements Runnable{

int [] ran;

    public Task_4 (int [] m) {
        this.ran = m;
    }

    @Override
    public void run() {
        for(int a =0 ; a< ran.length ; a++) {
            if(ran[a]%2 == 0) {
            System.out.println(Thread.currentThread().getName()+" "+ran[a]);
        }
    }
   }
}

OUTPUT

[porstuart]

Main Class

import java.util.Random;

public class JoiningThread{

    public static void main(String [] args){

        long start = System.currentTimeMillis();
        int [] randNum = new int[1000];
        Random num = new Random();

        for(int index = 0; index < 10; index++){
            randNum[index] = 0 + num.nextInt(1001 - 0);
        }

        Thread t1 = new Thread(new Task1(randNum), "Task1");
        t1.start();
        try{
            t1.join();
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        Thread t2 = new Thread(new Task2(randNum), "Task2 ... ");
        t2.start();
        try{
            t2.join();
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        Thread t3 = new Thread(new Task3(randNum), "Task3 ...... ");
        t3.start();
        Thread t4 = new Thread(new Task4(randNum), "Task4 ......... ");
        t4.start();
        try{
            t4.join();
        }catch(InterruptedException e){
            e.printStackTrace();
        }

        long stop = System.currentTimeMillis();
        long elapsedTime = stop - start;
        System.out.println("The Execute time is : " +elapsedTime + "ms");
    }
}

Task1

public class Task1 implements Runnable{

    int num[];

    public Task1(int num[]){
        this.num = num;
    }

    public void run(){
        for(int index = 0; index < 10; index++){
            System.out.println(Thread.currentThread().getName() + " " +num[index]);
        }
    }
}

Task2

public class Task2 implements Runnable{

    int num[];
    int temp;

    public Task2(int num[]){
        this.num = num;
    }

    public void run(){
        for (int index = 1; index < 10; index++) {
            for (int j = index; j > 0; j--) {
                if (num[j] < num [j - 1]) {
                    temp = num[j];
                    num[j] = num[j - 1];
                    num[j - 1] = temp;
                }
            }
        }
        for (int index = 0; index < 10; index++) {
            System.out.println(Thread.currentThread().getName() + " " +num[index]);
        }
    }
}

Task3

public class Task3 implements Runnable{

    int num[];

    public Task3(int num[]){
        this.num = num;
    }

    public void run(){
        for(int index = 0; index < 10; index++){
            if((num[index] % 2) != 0){
                System.out.println(Thread.currentThread().getName() + " " +num[index]);
            }
        }
    }
}

Task4

public class Task4 implements Runnable{

    int num[];

    public Task4(int num[]){
        this.num = num;
    }

    public void run(){
        for(int index = 0; index < 10; index++){
            if((num[index] % 2) == 0){
                System.out.println(Thread.currentThread().getName() + " " +num[index]);
            }
        }
    }
}

[roflinasuha]

Main

package issues7;

import java.util.Random;
class issues7 
{
    public static int [] pick= new int[10];
    public static void main(String[] args){
{
    Random rand = new Random();
    long startTime = System.currentTimeMillis();

      for (int j = 0; j<pick.length; j++)
      {
          pick[j] = rand.nextInt(1000);

  }
      Thread T1 =new Thread (new numbers(pick));
      T1.start();
      try{
          T1.join();
      } catch (InterruptedException e){
          e.printStackTrace();
      }
      Thread T2 =new Thread (new sort(pick));
      T2.start();
      try{
          T2.join();
      } catch (InterruptedException e){
          e.printStackTrace();
      }
      Thread T3 =new Thread (new oddNumber(pick));
      T3.start();
      try{
          T3.join();
      } catch (InterruptedException e){
          e.printStackTrace();
      }
      Thread T4 =new Thread (new evenNumber(pick));
      T4.start();
      try {
            T4.join();
          }catch(Exception ex) {
            ex.printStackTrace();
          }

      long endTime = System.currentTimeMillis();
      long totalTime = endTime - startTime;
      System.out.println("The Execute time is : "+totalTime + "ms");
}
}
}

Task 1

package issues7;

import java.util.Random;
class numbers implements Runnable
{

int [] pick; 

    public numbers (int [] nums ){

        this.pick = nums;

    }

    @Override
    public void run() {
        for(int w = 0 ; w < pick.length ; w++) {
            System.out.println("Task 1 : "+ pick[w]); 
        }

  }
}

Task 2

package issues7;

import java.lang.reflect.Array;
import java.util.Arrays;

public class sort implements Runnable {

int [] pick; 

    public sort (int [] nums ){

        this.pick = nums;
        Arrays.sort(pick);

    }

    @Override
    public void run() {
        for(int w = 0 ; w < pick.length ; w++) {
            System.out.println("Task 2 : "+ pick[w]); 
        }

  }

}

Task 3

package issues7;
public class oddNumber implements Runnable {
int [] pick; 

    public oddNumber (int [] nums ){

        this.pick = nums;

    }

    @Override
    public void run() {
        for(int w = 0 ; w < pick.length ; w++) {
            if (w % 2 != 0) {
            System.out.println("Task 3 : "+pick[w]); 
        }
    }       
  }
}

Task 4

package issues7;

public class evenNumber implements Runnable {
int [] pick; 

    public evenNumber (int [] nums ){

        this.pick = nums;

    }

    @Override
    public void run() {
        for(int w = 0 ; w < pick.length ; w++) {
            if(pick[w]%2==0) {
            System.out.println("Task 4 : "+pick[w]); 
        }
    }       
  }
}

[shyyahcheang]

Main class

import java.util.Random;

public class RandomNumber {

    public static void main(String[] args) {

        long start = System.currentTimeMillis(); 
        {}
        int [] array = new int[10];
        Random r = new Random();
        for(int y = 0; y < array.length; y++ ) {
            array[y] = r.nextInt(1001);
        }

        Thread t1 = new Thread(new Task_1(array), "Task-1 ");
        t1.start();
        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Thread t2 = new Thread(new Task_2(array), "Task-2 ... ");
        t2.start();
        try {
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Thread t3 = new Thread(new Task_3(array), "Task-3 ...... ");
        t3.start();

        Thread t4 = new Thread(new Task_4(array), "Task-4 ......... ");
        t4.start();
        try{
            t4.join();
        }catch(InterruptedException e){
            e.printStackTrace();
        }

        long stop = System.currentTimeMillis();
        long elapsedTime = stop - start;
        System.out.println("The execute time is " + elapsedTime + "ms");
    }    
}

Task 1

public class Task_1 implements Runnable {

    int arrayNum[];

    public Task_1 (int arrayNum[]) {
        this.arrayNum = arrayNum;
    }

    public void run() {
        for(int counter = 0; counter < arrayNum.length; counter++) {
            System.out.println(Thread.currentThread().getName() + " " + arrayNum[counter]); 
        }
    }   
}

Task 2

import java.util.Arrays;

public class Task_2 implements Runnable {

    int arrayNum[];

    public Task_2 (int arrayNum[]) {
        this.arrayNum = arrayNum;
        Arrays.sort(arrayNum);
    }

    public void run() {
        for(int counter = 0; counter < arrayNum.length; counter++) {
            System.out.println(Thread.currentThread().getName() + " " + arrayNum[counter]);
        }
    }
}

Task 3

public class Task_3 implements Runnable{

    int arrayNum[];

    public Task_3 (int arrayNum[]) {
        this.arrayNum = arrayNum;
    }

    public void run() {
        for(int counter = 0; counter < arrayNum.length; counter++) {
            if((arrayNum[counter]%2) != 0 ) {
                System.out.println(Thread.currentThread().getName() + " " + arrayNum[counter]);
            }
        }
    }
}

Task 4

public class Task_4 implements Runnable{

    int arrayNum[];

    public Task_4 (int arrayNum[]) {
        this.arrayNum = arrayNum;
    }

    public void run() {
        for(int counter = 0; counter < arrayNum.length; counter++) {
            if ((arrayNum[counter]%2) == 0) {
                System.out.println(Thread.currentThread().getName() + " " + arrayNum[counter]);
            }
        }
    }
}

Output

[lancelot9927]

Issue7 Main:

import java.util.Random;
import java.util.ArrayList;

/**
 *
 * @author Administrator
 */
public class Issuse7 {
          public static int nums[] = new int [10];
        public static void main(String[] args) throws InterruptedException {
            long start = System.currentTimeMillis();
            Random rand = new Random();
            for(int i = 0;i<nums.length;i++){
            int a = rand.nextInt(1000);
            nums[i] = a;  

    }

       display display = new display(nums);
       Thread t1 = new Thread(display);
       ascending ascending = new ascending(nums);
       Thread t2 = new Thread(ascending);
       oddnumber oddnumber = new oddnumber(nums);
       Thread t3 = new Thread(oddnumber);
       evennumber evennumber = new evennumber(nums);
       Thread t4 = new Thread(evennumber);

         t1.start();
        try{
            t1.join();
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        t2.start();
        try{
            t2.join();
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        t3.start();
        try{
            t3.join();
        }catch(InterruptedException e){
            e.printStackTrace();
        }
       t4.start();
        try{
            t4.join();
        }catch(InterruptedException e){
            e.printStackTrace();
        }

        long stop = System.currentTimeMillis();
        long elapsedTime = stop - start;
        System.out.println("The Execute time is : " +elapsedTime + "ms");
        }
}

Display

public class display  implements Runnable{
    int [] rand; 

    public display (int [] m ){

        this.rand = m;

    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i = 0 ; i < rand.length ; i++) {

            System.out.println(rand[i]); 
        }

    }   
}

Ascending

import java.util.Arrays;

/**
 *
 * @author Administrator
 */
public class ascending implements Runnable {
     int [] rand; 

    public ascending (int [] m ){

        this.rand = m;

    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
            System.out.println(" sorted numbers:");
        for(int i = 0 ; i < rand.length ; i++) {
                        Arrays.sort(rand);
            System.out.println(rand[i]); 
        }
    }   
}

Odd numbers

public class oddnumber implements Runnable{
        int [] rand; 

    public oddnumber (int [] m ){

        this.rand = m;

    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
            int b;
            System.out.println("Odd numbers:");
        for(int i = 0 ; i < rand.length ; i++) {
                     b = rand[i];
                     if (b%2>0){
            System.out.println(rand[i]); 
                     }
        }
    }
}

Even numbers

public class evennumber implements Runnable{
      int [] rand; 

    public evennumber (int [] m ){

        this.rand = m;

    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
            int b;
            System.out.println("even numbers:");
        for(int i = 0 ; i < rand.length ; i++) {
                     b = rand[i];
                     if (b%2==0){
            System.out.println(rand[i]); 
                     }
        }   
        }
}

Output

[mwng97]

Main

import java.util.Random;

public class main {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        try {
            int number[] = new int[10];

            System.out.println("Display all the numbers: ");
            for (int x = 0; x < number.length; x++) {
                Random random = new Random();
                number[x] = random.nextInt(1000);
            }
            Thread t1 = new Thread(new Task1(number));
            t1.start();
            t1.join();

            Thread t2 = new Thread(new Task2(number));
            t2.start();
            t2.join();

            Thread t3 = new Thread(new Task3(number));
            t3.start();
            t3.join();

            Thread t4 = new Thread(new Task4(number));
            t4.start();
            t4.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long stop = System.currentTimeMillis();
        long elapsedTime = stop - start;
        System.out.println("\nThe execute time is " + elapsedTime + "ms");
    }
}

Task 1

public class Task1 implements Runnable{

    int number[];

    Task1 (int number[]){
        this.number=number;
    }

    @Override
    public void run() {
        for(int i=0;i<number.length;i++){
            System.out.println((i+1)+".) Task1 : "+number[i]);
        }
    }
}

Task 2

import java.util.Arrays;

public class Task2 implements Runnable{

    int number[];

    Task2(int[] number) {
        this.number=number;
        Arrays.sort(number);
    }

    @Override
    public void run() {
        System.out.println("\nAscending order: ");
        for(int i=0;i<number.length;i++){
            System.out.println((i+1)+".) Task2 : "+number[i]);
        }
    }
}

Task 3

import java.util.Arrays;
public class Task3 implements Runnable {

    int number[];

    Task3(int[] number) {
        this.number=number;
        Arrays.sort(number);
    }

    @Override
    public void run() {
        System.out.println("\nOdd numbers: ");
        for(int i=1;i<number.length;i++) {
            if (number[i] % 2 != 0) {
                System.out.println("Task3 : " + number[i]);
            }
        }
    }
}

Task 4

import java.util.Arrays;

public class Task4 implements Runnable {

    int number[];

    Task4(int[] number) {
        this.number=number;
        Arrays.sort(number);
    }

    @Override
    public void run() {
        System.out.println("\nEven numbers: ");
        for(int i=0;i<number.length;i++) {
            if (number[i] % 2 == 0) {
                System.out.println("Task4 : " + number[i]);
            }
        }
    }
}

Output

[limxinyii]

Main

import java.util.Random;

public class MainClass {

    public static int num[] = new int [10];

    public static void main (String[]args ) {
        long startTime = System.currentTimeMillis();
        Random rdm = new Random();

        for (int i = 0 ; i< num.length ; i++){
          num[i] = rdm.nextInt(1000);
        }

        Thread t1 = new Thread(new Task1(num));
        t1.start();
        try {
            t1.join();

        }catch (InterruptedException ex) {
            ex.printStackTrace();
        }

        Thread t2 = new Thread(new Task2(num));
        t2.start();
        try {
            t2.join();

        }catch (InterruptedException ex) {
            ex.printStackTrace();
        }

        Thread t3 = new Thread(new Task3(num));
        t3.start();

        Thread t4 = new Thread(new Task4(num));
        t4.start();
        try {
            t4.join();

        }catch (InterruptedException ex) {
            ex.printStackTrace();
        }

        long endTime = System.currentTimeMillis();
        long duration = (endTime - startTime);  
         System.out.println("The Execute time is : "+ duration + "ms");
    }       
}

Task 1

public class Task1 implements Runnable {
    int [] num; 

    public Task1 (int[]num) {
        this.num = num;
    }

    @Override
    public void run() {

        for(int a = 0 ; a < num.length ; a++) {
            System.out.println("Task-1 " + num[a]); 
        }

    }
}

Task 2

import java.util.Arrays;

public class Task2 implements Runnable {
    int [] num; 

    public Task2 (int[] num) {
        this.num = num;
    }

    @Override
    public void run() {

        for(int a = 0 ; a < num.length ; a++) {
            Arrays.sort(num);
            System.out.println("Task-2 ... "+ num[a]);
        }
    }
}

Task 3

public class Task3 implements Runnable {    
    int [] num;

    public Task3 (int[] num) {
        this.num = num;
    }

    @Override
    public void run() {

        for(int a = 0 ; a < num.length ; a++) {
            if(num[a] % 2 == 1){
            System.out.println("Task-3 ...... " + num[a]);  
            }
        }

    }
}

Task 4

public class Task4 implements Runnable {    

    int [] num;

    public Task4 (int[] num) {
        this.num = num;     
    }

    @Override
    public void run() {
        for(int a = 0 ; a < num.length ; a++) {
            if(num[a] % 2 == 0){
            System.out.println("Task-4 ......... " + num[a]);   
         }

        }   

    }
}   

Output

[AhKitt]

Main

import java.util.*;

public class Issue6{

    public static int randNum [] = new int[10];
    public static void main(String[]args){
        Random randN = new Random();
        long startTime = System.currentTimeMillis();

        for (int i=0; i<10; i++){
            randNum[i] = randN.nextInt(10)+1;
        }

        Thread task1 = new Thread(new Task1(randNum), "Task1..");
        Thread task2 = new Thread(new Task2(randNum), "Task2...");

        try{
            task1.start();
            task1.join();
        }catch(InterruptedException e){
            e.printStackTrace();
        }

        try{
            task2.start();
            task2.join();
        }catch(InterruptedException e){
            e.printStackTrace();
        }

        Thread task3 = new Thread(new Task3(randNum), "Task3....");
        task3.start();
        Thread task4 = new Thread(new Task4(randNum), "Task4.....");
        task4.start();

        try{
            task4.join();
        }catch(InterruptedException e){
            e.printStackTrace();
        }

        long stopTime = System.currentTimeMillis();
        long executeTime = stopTime - startTime;
        System.out.println("Execute time is : " +executeTime + "ms");
    }
}

Task1

public class Task1 implements Runnable{

    int [] rand; 

    public Task1 (int [] rand ){
        this.rand = rand;
    }

    public void run() {
        for(int i = 0 ; i < rand.length ; i++) {
            System.out.println(Thread.currentThread().getName() + " " + rand[i]); 
        }
    }
}

Task2

import java.util.*;

public class Task2 implements Runnable{

    int rand [];

    public Task2(int [] rand){
        this.rand = rand;
        Arrays.sort(rand);
    }

    public void run(){
        try{
            for (int j=0; j<rand.length; j++){
                System.out.println(Thread.currentThread().getName() + " " + rand[j]);
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

Task3

public class Task3 implements Runnable{

    int rand[];

    public Task3(int []rand){
        this.rand = rand;
    }

    public void run(){
        try{
            for (int i=0; i<rand.length; i++){
                if(rand[i]%2 != 0){
                    System.out.println(Thread.currentThread().getName() + " "+ rand[i]);
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

Task4

public class Task4 implements Runnable{

    int rand[];

    public Task4(int []rand){
        this.rand = rand;
    }

    public void run(){
        try{
            for (int i=0; i<rand.length; i++){
                if(rand[i]%2 == 0){
                    System.out.println(Thread.currentThread().getName() + " "+ rand[i]);
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

Output

[lingzhongli]

import java.util.Random;
public class Number {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        long start = System.currentTimeMillis();{}
        Random r =new Random();
        int []num =new int [1000];

        for(int i=0;i<num.length;i++){
            num[i]=r.nextInt(1000);

        }
        Thread t1= new Thread(new display(num));
        t1.start();
        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Thread t2= new Thread(new sort(num));
        t2.start();
        try {
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Thread t3= new Thread(new odd(num));
        t3.start();
        try {
            t3.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Thread t4= new Thread(new even(num));
        t4.start();
        try {
            t4.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        long stop = System.currentTimeMillis();
        long elapsedTime = stop - start;
        System.out.println("The execute time is " + elapsedTime + "ms");

    }

}

public class display implements Runnable {

    int[] nums;

    display(int[] nums) {
       this.nums=nums;
    }

    public void run(){
    for (int i=0;i<nums.length;i++){
        System.out.println("Task 1: "+" "+nums[i]);
    }

    }   
}

public class sort implements Runnable {

    int[] nums;

    sort(int[] num) {
       this.nums=num;
       Arrays.sort(nums);
    }

     @Override
    public void run(){
        System.out.println("");
        System.out.println("Assending Order:");
    for (int i=0;i<nums.length;i++){
        System.out.println("Task 2: "+" "+nums[i]);
    }

    } 

    } 

public class odd implements Runnable {

    int[] nums;

    odd(int[] nums) {
       this.nums=nums;
    }

    public void run(){
        System.out.println("");
        System.out.println("Odd Number:");
    for (int i=0;i<nums.length;i++){
        if(nums[i] % 2!= 0)
        System.out.println("Task 3: "+" "+nums[i]);
    }

    }

}

public class even implements Runnable {
    int[] nums;

    even(int[] nums) {
       this.nums=nums;
    }

    public void run(){
        System.out.println("");
        System.out.println("Even Number:");
    for (int i=0;i<nums.length;i++){
        if(nums[i] % 2== 0)
        System.out.println("Task 4: "+" "+nums[i]);
    }

    }

}

[mimiothman]

Main

import java.util.Random;

    public class randomNum { 
    public static void main(String[] args) { 
        long startTime = System.currentTimeMillis();
    Random rgen = new Random();
    int[] nums = new int[10];

        for (int i=0; i<nums.length; i++) {
            nums[i] = rgen.nextInt(1000);
        }

        Thread t1 =new Thread(new task1(nums));
        t1.start();
        try {
            t1.join();

        }catch (InterruptedException ex) {
            ex.printStackTrace();
        }

        Thread t2 = new Thread(new task2(nums));
        t2.start();
        try {
            t2.join();

        }catch (InterruptedException ex) {
            ex.printStackTrace();
        }

        Thread t3 = new Thread(new task3(nums));
        t3.start();

        Thread t4 = new Thread(new task4(nums));
        t4.start();
        try {
            t4.join();

        }catch (InterruptedException ex) {
            ex.printStackTrace();
        }

        long endTime = System.currentTimeMillis();
        long duration = (endTime - startTime);  
         System.out.println("The Execute time is : "+ duration + "ms");
    }       
}

Task 1

public class task1 implements Runnable{
    int[] array;

    public task1(int[] a) {
        this.array= a;
    }
    public void run() {
        for(int i=0;i<array.length;i++) {
            System.out.println("task 1 " + array[i]); 
        }

    }   
}

Task 2

import java.util.Arrays;

public class task2 implements Runnable { int nums[];

    public task2(int rn[]){
        this.nums = rn;
            Arrays.sort(nums);   
    }

    public void run() {
        for(int i = 0 ; i < nums.length ; i++) {
            System.out.println("task 2 :" + nums[i]); 
        }
    } 
}

Task 3

public class task3 implements Runnable {    
    int [] nums;

    public task3 (int[] nums) {
        this.nums = nums;
    }

    @Override
    public void run() {

        for(int a = 0 ; a < nums.length ; a++) {
            if(nums[a] % 2 == 1){
            System.out.println("task 3: " + nums[a]);   
            }
        }

    }
}

Task 4

public class task4 implements Runnable {    

    int [] nums;

    public task4 (int[] nums) {
        this.nums = nums;       
    }

    @Override
    public void run() {
        for(int a = 0 ; a < nums.length ; a++) {
            if(nums[a] % 2 == 0){
            System.out.println("task 4:" + nums[a]);    
         }

        }   

    }
}   

[SINHUI]

Main Class

import java.util.Random;
public class Main {
    public static void main(String[] args) {

        long time_start =System.currentTimeMillis();
        Random random =new Random();
        int[] num=new int[10]; {}

        for(int i=0;i<num.length; i++) {
            num[i]=random.nextInt(1001);

        }
        Thread t1 = new Thread(new Task_1(num));
        t1.start();
        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Thread t2 = new Thread(new Task_2(num));
        t2.start();
        try {
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Thread t3 = new Thread(new Task_3(num));
        Thread t4 = new Thread(new Task_4(num));

        t3.start();
        t4.start();
        try {
            t4.join();
        }catch (InterruptedException e) {
            e.printStackTrace();
        }

        long time_end =System.currentTimeMillis();
        long time_used= time_end - time_start;
        System.out.println("Execution Time = "+time_used+"ms");

    }
}

Task 1

public class Task_1 implements Runnable{
    int[] num;

    public Task_1(int[]num) {
        this.num=num;
    }

    @Override
    public void run() {
        System.out.println("\nTASK 1 :  ");
        for (int i=0;i<num.length;i++) {
            System.out.println("Task 1 =  "+num[i]);
        }
    }
}

Task 2

import java.util.Arrays;
public class Task_2 implements Runnable {

        int[] num;

    public Task_2(int[]num) {
        this.num=num;
        Arrays.sort(num);
    }

    @Override
    public void run() {
        System.out.println("\nTASK 2 :  ");
        for (int i=0;i<num.length;i++) {
            System.out.println("Task 2 ..... "+num[i]);
        }
    }
}

Task 3

public class Task_3 implements Runnable {

    int [] num;

    public Task_3(int[]num) {
        this.num=num;
    }

    @Override 
    public void run() {
        System.out.println("\nTASK 3 :  ");
        for (int i =0;i<num.length;i++) {
            if(num[i]%2 !=0)
                System.out.println("Task 3....."+num[i]);
        }
    }
}

Task 4

public class Task_4 implements Runnable {
int [] num;

    public Task_4(int[]num) {
        this.num=num;
    }

    @Override 
    public void run() {
        System.out.println("\nTASK 4 :  ");
        for (int i =0;i<num.length;i++) {
            if(num[i]%2 ==0)
                System.out.println("Task 4....."+num[i]);
        }
    }
}

Output

[ChongMeiYong]

Main Task

import java.util.Random;

public class MainTask {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        long time_start =System.currentTimeMillis();
        Random random =new Random();
        int[] num=new int[10]; {}

        for(int i=0;i<num.length; i++) {
            num[i]=random.nextInt(1001);
        }

        Thread t1 = new Thread(new Task1(num));
        t1.start();
        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Thread t2 = new Thread(new Task2(num));
        t2.start();
        try {
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Thread t3 = new Thread(new Task3(num));
        t3.start();
        try {
            t3.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Thread t4 = new Thread(new Task4(num));
        t4.start();
        try {
            t4.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        long time_end =System.currentTimeMillis();
        long time_used= time_end - time_start;
        System.out.println("Execution Time = "+time_used+"ms");
    }
}

Task 1

public class Task1 implements Runnable{
    // TODO Auto-generated method stub
    int[] num;

    public Task1(int[]num) {
        this.num=num;
    }

    @Override
    public void run() {
        System.out.println("\nTASK 1 (Display All Number):  ");
        for (int i=0;i<num.length;i++) {
            System.out.println("Task-1 "+num[i]);
        }
    }
}

Task 2

import java.util.Arrays;

public class Task2 implements Runnable {
    // TODO Auto-generated method stub
    int[] num;

    public Task2(int[]num) {
        this.num=num;
        Arrays.sort(num);
    }

    @Override
    public void run() {
        System.out.println("\nTASK 2 (Sorting):  ");
        for (int i=0;i<num.length;i++) {
            System.out.println("Task-2 ... "+num[i]);
        }
    }
}

Task 3

public class Task3 implements Runnable {
    // TODO Auto-generated method stub
    int [] num;

    public Task3(int[]num) {
        this.num=num;
    }

    @Override 
    public void run() {
        System.out.println("\nTASK 3 (Odd Number):  ");
        for (int i =0;i<num.length;i++) {
            if(num[i]%2 !=0)
                System.out.println("Task-3 ......"+num[i]);
        }
    }
}

Task 4

public class Task4 implements Runnable {
    // TODO Auto-generated method stub
    int [] num;

    public Task4(int[]num) {
        this.num=num;
    }

    @Override 
    public void run() {
        System.out.println("\nTASK 4 (Even Number):  ");
        for (int i =0;i<num.length;i++) {
            if(num[i]%2 ==0)
                System.out.println("Task-4 ........"+num[i]);
        }
    }
}

Output

[lishaobin]

Main class

package issue;

import java.util.Arrays;
import java.util.Random;

/**
 *
 * @author 11474
 */
public class Issue {
public static  int a[] =new int[10];
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
       long start = System.currentTimeMillis();

        Random r=new Random();  

      for (int x=0;x<10;x++){
          int n = r.nextInt(1001);
                    a[x] =n;
      }
      Thread t1 =new Thread(new T1(a));
      Thread t2 =new Thread(new T2(a));
      Thread t3 =new Thread(new T3(a));
      Thread t4 =new Thread(new T4(a));
      t1.start();
        try{
            t1.join();
        } catch (InterruptedException e){
            e.printStackTrace();
        }
 t2.start();
         try{
            t2.join();
        } catch (InterruptedException e){
            e.printStackTrace();
        }
          t3.start();
         try{
            t3.join();
        } catch (InterruptedException e){
            e.printStackTrace();
        }
           t4.start();
         try{
            t4.join();
        } catch (InterruptedException e){
            e.printStackTrace();
        }
          long stopTime = System.currentTimeMillis();
        long elapsedTime = stopTime - start;
        System.out.println("Execute time is : " +elapsedTime + "ms");

      }
}

Task 1

   public static class T1 implements Runnable {
   int rand[];
        public T1(int[] a) {
            this.rand=a;
        }
        public void run() {
         System.out.println("Task 1 : \n");   
        for(int i = 0 ; i < 10 ; i++) {
        System.out.println( rand[i]); 
        }
        System.out.println(""); 

    }
    }

Task 2

    private static class T2 implements Runnable {
       int rand[];
        public T2(int[] a) {
            this.rand=a;
            Arrays.sort(rand);
        }
   public void run () {
        System.out.println("Task 2 :  \n");   
   for (int x = 0; x < 10; x++) {
    System.out.println( rand[x]);
  }
     System.out.println(" "); 
}

    }

Task 3

 private static class T3 implements Runnable {
       int rand[];
        public T3(int[] a) {
            this.rand=a;
        }
        public void run(){
            System.out.println("Task 3 : \n "); 
            for (int x=0;x<10;x++)
               if (rand[x]%2 !=0)
                   System.out.println(rand[x]);
                     System.out.println(""); 
        }

    }

Task 4

    private static class T4 implements Runnable {
       int rand[];
        public T4(int[] a) {
               this.rand=a;
        }
        public void run(){
            System.out.println("Task 4 :  \n"); 
            for (int x=0;x<10;x++)
               if (rand[x]%2 ==0)
                   System.out.println(rand[x]);
                     System.out.println(""); 
        }
    }

Output

[tanyujia]

Main Class

package javaapplication20;

import java.util.Random;

public class JavaApplication20 {

    public static void main(String[] args) {

        long start = System.currentTimeMillis();
        Random ran = new Random();
        int abc[] = new int[1000];

        for (int i = 0; i < 1000; i++) {
            abc[i] = ran.nextInt(1000);
        }

        Thread t1 = new Thread(new DisplayNumber(abc));
        t1.start();
        try {
            t1.join();
        } catch (InterruptedException e) {
        }

        Thread t2 = new Thread(new SortNumber(abc));
        t2.start();
        try {
            t2.join();
        } catch (InterruptedException e) {
        }

        Thread t3 = new Thread(new OddNumber(abc), "Task 3");
        t3.start();
        try {
            t3.join();
        } catch (InterruptedException e) {
        }

        Thread t4 = new Thread(new EvenNumber(abc), "Task 4");
        t4.start();
        try {
            t4.join();
        } catch (InterruptedException e) {
        }

        long stop = System.currentTimeMillis();
        long elapsedTime = stop - start;
        System.out.println("The Execute time is : " + elapsedTime + "ms");
    }
}

Task 1

package javaapplication20;

public class DisplayNumber implements Runnable {

    private int number[];

    public DisplayNumber(int i[]) {
        number = i;
    }

    @Override
    public void run() {
        System.out.println("Display all the random number: ");
        for (int i = 0; i < number.length; i++) {
            System.out.println(number[i]);
        }        
    }
}

Task 2

import java.util.Arrays;

public class SortNumber implements Runnable {

    private int number[];

    public SortNumber(int i[]) {
        number = i;
        Arrays.sort(number);
    }

    @Override
    public void run() {
        System.out.println("Display number in ascending order");
        for (int i = 0; i < number.length; i++) {
            System.out.println(number[i]);
        }
    }
}

Task 3

package javaapplication20;

public class OddNumber extends Thread {

    private int number[];

    public OddNumber(int i[]) {
        number = i;
    }

    @Override
    public void run() {
        for (int i = 0; i < number.length; i++) {
            if (number[i] % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + "...." + number[i]);
            }
        }
    }
}

Task 4

package javaapplication20;

public class EvenNumber extends Thread {

    private int number[];

    public EvenNumber(int i[]) {
        number = i;
    }

    @Override
    public void run() {
        for (int i = 0; i < number.length; i++) {
            if (number[i] % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + "..." + number[i]);
            }
        }

    }
}

Output

[prevenkumar]

Main Page

package issue_7;
import java.util.Random;
public class MainClass {

    public static int nums[] = new int [10];
    public static void main (String[]args ) {
    long s_time = System.currentTimeMillis();

        Random r = new Random();

         for (int i = 0 ; i < nums.length ; i++){
          nums[i] = r.nextInt(1000);
        }

        Thread t1 = new Thread(new Task1(nums));
        t1.start();
        try{
            t1.join();
            }
            catch(InterruptedException e){
            e.printStackTrace();
            }
        Thread t2 = new Thread(new Task2(nums));
        t2.start();
        try{
            t2.join();
            }
            catch(InterruptedException e){
            e.printStackTrace();
            }
        Thread t3 = new Thread(new Task3(nums));
        t3.start();
        try{
            t3.join();
            }
            catch(InterruptedException e){
            e.printStackTrace();
            }
        Thread t4 = new Thread(new Task4(nums));
        t4.start();
        try{
            t4.join();
            }
            catch(InterruptedException e){
            e.printStackTrace();
            }
    long e_time = System.currentTimeMillis();
    long EndedTime = e_time - s_time;
    System.out.println("The Execute time is : " +EndedTime + "ms");
}
}

Task 1

package issue_7;
public class Task1 implements Runnable {
int [] nums; 

    public Task1 (int [] nums ){

        this.nums = nums;   
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i = 0 ; i < nums.length ; i++) {
            System.out.println("Task 1 :" +nums[i]); 
        }   
    }   
}

Task 2

package issue_7;
import java.util.Arrays;
public class Task2 implements Runnable {
int [] nums; 

    public Task2 (int [] nums ){

        this.nums = nums;
        Arrays.sort(nums);
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i = 0 ; i < nums.length ; ++i) {
            System.out.println("Task 2 :" +nums[i]); 
        }   
    }   
}

Task 3

package issue_7;

import java.util.Arrays;
public class Task3 implements Runnable {    
int [] nums;

public Task3 (int [] nums ){
        this.nums = nums;
        Arrays.sort(nums);
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i = 0 ; i < nums.length ; ++i) {
            if (nums[i] % 2 != 0)

            System.out.println("Task 3 :" +nums[i]); 

    }   }   }

Task 4

package issue_7;
import java.util.Arrays;
public class Task4 implements Runnable {

int [] nums;

public Task4 (int [] nums ){
        this.nums = nums;
        Arrays.sort(nums);
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i = 0 ; i < nums.length ; ++i) {
            if (nums[i] % 2 == 0)

            System.out.println("Task 4 :" +nums[i]); 
        }}}

OUTPUT

[TanShiJet]

Main class

import java.util.Random;

public class issue  {

    public static void main(String[] args) {

        long start = System.currentTimeMillis();
        Random rand = new Random(); 
        int a[]= new int[10];

        for (int i = 0; i < 10; i++) {

            a[i]=rand.nextInt(9)+1;
        }

        Thread t1 = new Thread(new RandamNo(a),"Task-1 ");
        Thread t2 = new Thread(new sortn0(a),"Task-2 ... ");
        odd t3 =(new odd(a));
        t3.setName("Task-3 ...... ");
        even t4 =(new even(a));
        t4.setName("Task-4 ......... ");

        t1. start();

            try {
                t1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        t2.start();

            try {
                t2.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        t3.start();
        t4.start();

            try {
                t3.join();
                t4.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        long end = System.currentTimeMillis();
        long ms = end - start;
        System.out.println("Execution Time = " + ms +"ms");
    }

}

Task 1 - display

public class RandamNo implements Runnable{

    int[] a;

    public RandamNo(int[] a) {

        this.a=a;
    }

    @Override
    public void run() {

        for (int i = 0; i < 10; i++) {

        System.out.println(Thread.currentThread().getName() + a[i]);

        } 
    }

}

Task 2 - Sort

public class sortn0 implements Runnable{

    int[] a;

    public sortn0(int[]a) {

        this.a=a;

    }

    @Override
    public void run() {

        Arrays.sort(a);
        for (int i = 0; i < 10; i++) {

               System.out.println(Thread.currentThread().getName() + a[i]);

        }

    }
}

Task 3 - Odd

public class odd extends Thread {

    int[] a;

    public odd(int[] a) {

        this.a=a;
    }

    @Override
    public void run() {

        for (int i = 0; i < 10; i++) {

            if(a[i]%2==1)

                System.out.println(Thread.currentThread().getName() + a[i]);

        }
    }
}

Task 4 - Even

public class even extends Thread {

    int []a;

    public even (int []a) {

        this.a=a;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {

            if(a[i]%2==0)

                System.out.println(Thread.currentThread().getName() + a[i]);

        }

    }

}

Output

[WongKinSin13]

Main.java

import java.util.Random;
public class Main {

    public static void main(String [] args) {

        Random dom = new Random();
        int [] randomNum = new int [10];
        long startTime = System.currentTimeMillis();

        for (int x = 0 ; x < randomNum.length ; x ++){
              randomNum[x] = dom.nextInt(1000);
            }       

        Thread t1 = new Thread(new task1(randomNum), "Task 1");
        t1.start();

        try {
            t1.join();
        }catch (InterruptedException e) {
            e.printStackTrace();
        }

        Thread t2 = new Thread(new task2(randomNum), "Task 2...");
        t2.start();
        try {
            t2.join();
        }catch (InterruptedException e) {
            e.printStackTrace();
        }

        Thread t3 = new Thread(new task3(randomNum), "Task 3 ......");
        t3.start();

        Thread t4 = new Thread(new task3(randomNum), "Task 4 .........");
        t4.start();
        try {
            t4.join();
        }catch (InterruptedException e) {
            e.printStackTrace();
        }

        long stopTime = System.currentTimeMillis();
        long elapsedTime = stopTime - startTime;
        System.out.println("The Execute time is : " +elapsedTime + "ms");
    }
}

task1.java

public class task1 implements Runnable  {
    int [] nums; 

    public task1 (int [] nums ){
        this.nums = nums;
    }

    @Override
    public void run() {
        for(int x = 0 ; x < nums.length ; x++) {
            System.out.println(Thread.currentThread().getName() + " " +nums[x]);
        }
    }
    }

task2.java

import java.util.Arrays;
public class task2 implements Runnable{
    int [] nums;

    public task2(int[]nums) {
        this.nums=nums;
        Arrays.sort(nums);
    }

    @Override
    public void run(){
        for(int x=0;x<10;x++) {
            System.out.println(Thread.currentThread().getName() + " " +nums[x]);
        }
    }
}

task3.java

import java.util.Arrays;
public class task3 implements Runnable{
    int [] nums;

    public task3(int[]nums) {
        this.nums=nums;
        Arrays.sort(nums);
    }

    @Override
    public void run() {
    for(int x = 0 ; x < nums.length ; x++) {
        if((nums[x] % 2) != 0){
            System.out.println(Thread.currentThread().getName() + " " +nums[x]);
        }
    }
}
}

task4.java

import java.util.Arrays;

public class task4 implements Runnable{
    int [] nums;

    public task4(int[]nums) {
        this.nums=nums;
        Arrays.sort(nums);
    }

    @Override
    public void run() {
        for(int x = 0 ; x < nums.length ; x++) {
        if((nums[x] % 2) == 0){
            System.out.println(Thread.currentThread().getName() + " " +nums[x]);
    }
        }
}
}

Output

[muhamaddarulhadi]

MAIN CLASS

package joining_threads;

import java.util.Random;

public class Main 
{
    public static void main(String[] args)
    {
        long start = System.currentTimeMillis();

        Random rand = new Random();

        int num[] = new int [1000];

        for(int q=0; q<1000; q++)
        {
            num[q] = rand.nextInt(1000);
        }   

        Thread t1 = new Thread(new task1(num));
        t1.start();

        try
        {
            t1.join();
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }

        Thread t2 = new Thread(new task2(num));
        t2.start();

        try
        {
            t2.join();
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }

        Thread t3 = new Thread(new task3(num));
        Thread t4 = new Thread(new task4(num));
        t3.start();
        t4.start();;

        try
        {
            t3.join();
            t4.join();
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }

        long stop = System.currentTimeMillis();
            long duration = stop - start;
            System.out.println("\nExecution Time = " +duration+ "ms");
    }
}

TASK 1

package joining_threads;

public class task1 implements Runnable
{
    int num[];

    public task1(int num[])
    {
        this.num = num ;
    }

    @Override
    public void run() 
    {
    for(int q=0; q<1000; q++)
    {
         System.out.println(Thread.currentThread() +" , "+num[q]); 
    }
     }
}

TASK 2

package joining_threads;

import java.util.Arrays;

public class task2 implements Runnable
{
    int num[];

    public task2(int num[])
    {
        this.num = num ;
        Arrays.sort(num);   

    }

    @Override
    public void run() 
    {
    for(int q=0; q<1000; q++)
    {
          System.out.println(Thread.currentThread() +" , "+num[q]); 
    }
     }
}

TASK 3

package joining_threads;

public class task3 implements Runnable
{

    int num[];

    public task3(int num[])
    {
        this.num = num ;
    }

   @Override
    public void run() 
    {
       for(int q=0; q<1000; q++)
       {
       if(num[q] % 2 != 0)
       {
        System.out.println(Thread.currentThread() +" , "+num[q]); 
       }
    }
    }
}

TASK 4

package joining_threads;

public class task4 implements Runnable
{

    int num[];

    public task4(int num[])
    {
        this.num = num ;
    }

    @Override
    public void run() 
    {
    for(int q=0; q<1000; q++)
    {
        if (num[q] % 2 == 0)
        {
            System.out.println(Thread.currentThread() +" , "+num[q]); 
        }
    }
    }
}

OUTPUT

When number = 10.

[FatihahFauzi]

package com.company;

import java.util.Random;

public class Main  {

    public static void main(String[] args) {

        long start = System.currentTimeMillis();
        Random rand = new Random();
        int a[]= new int[10];

        for (int i = 0; i < 10; i++) {

            a[i]=rand.nextInt(9)+1;
        }

        Thread t1 = new Thread(new RandamNo(a),"Task-1 ");
        Thread t2 = new Thread(new sortno(a),"Task-2 ... ");
        odd t3 =(new odd(a));
        t3.setName("Task-3 ...... ");
        even t4 =(new even(a));
        t4.setName("Task-4 ......... ");

        t1. start();

        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t2.start();

        try {
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t3.start();
        t4.start();

        try {
            t3.join();
            t4.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        long end = System.currentTimeMillis();
        long ms = end - start;
        System.out.println("Execution Time = " + ms +"ms");
    }

}

package com.company;

public class RandamNo implements Runnable{

    int[] a;

    public RandamNo(int[] a) {

        this.a=a;
    }

    @Override
    public void run() {

        for (int i = 0; i < 10; i++) {

            System.out.println(Thread.currentThread().getName() + a[i]);

        }
    }

}

package com.company;

import java.util.Arrays;

public class sortno implements Runnable{

    int[] a;

    public sortno(int[]a) {

        this.a=a;

    }

    @Override
    public void run() {

        Arrays.sort(a);
        for (int i = 0; i < 10; i++) {

            System.out.println(Thread.currentThread().getName() + a[i]);

        }

    }
}

package com.company;

public class odd extends Thread {

    int[] a;

    public odd(int[] a) {

        this.a=a;
    }

    @Override
    public void run() {

        for (int i = 0; i < 10; i++) {

            if(a[i]%2==1)

                System.out.println(Thread.currentThread().getName() + a[i]);

        }
    }
}

package com.company;

public class even extends Thread {

    int []a;

    public even (int []a) {

        this.a=a;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {

            if(a[i]%2==0)

                System.out.println(Thread.currentThread().getName() + a[i]);

        }

    }

}

[sonyhana7]

MAIN CLASS

public class MainClass {
        public static int rans[] = new int[10];

        public static void main(String args[]) {

            long startTime = System.currentTimeMillis();
            {}

            for(int x = 0; x < 10 ; x++)
            {
                double random = Math.random();
                random = random * 1000;
                int rand = (int)random;

                rans[x] = rand;
            }

            Thread t1 = new Thread(new Task1(rans),"Task 1.");
            t1.start();

            try{
                t1.join();
            } catch (InterruptedException e){
                e.printStackTrace();
            }

            Thread t2 = new Thread(new Task2(rans),"Task 2..");
            t2.start();

            try{
                t2.join();
            } catch (InterruptedException e){
                e.printStackTrace();
            }

            Thread t3 = new Thread(new Task3(rans),"Task 3...");
            t3.start();

            Thread t4 = new Thread(new Task4(rans),"Task 4....");
            t4.start();

            try{
                t4.join();
            } catch (InterruptedException e){
                e.printStackTrace();
            }

            long stopTime = System.currentTimeMillis();
            long elapsedTime = stopTime - startTime;
            System.out.println("Execute time is : " +elapsedTime + "ms");

        }
    }

###  TASK 1

public class Task1 implements  Runnable{

        int rans[];

        public Task1(int k[]){
            this.rans = k;
        }

        public void run() {
            for(int i = 0 ; i < 10 ; i++) {
                System.out.println(Thread.currentThread().getName() + rans[i]);
            }

        }

    }

TASK 2

import java.util.Arrays;

public class Task2 implements Runnable{

    int rans[];

    public Task2(int rans[]){
        this.rans = rans;
        Arrays.sort(rans);
    }

    public void run () {
        for (int sort = 0; sort < 10; ++sort) {
            System.out.println(Thread.currentThread().getName() + "" + rans[sort]);
        }
    }

}

TASK 3

public class Task3 implements Runnable {

    int rans[];

    public Task3(int oddNums[]){
        this.rans = oddNums;
    }

    public void run(){

        for (int m = 0; m < 10; m++) {
            if (rans[m] % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + ":" + rans[m]);
            }
        }

    }

}

TASK 4

public class Task4 implements Runnable {

    int rans[];

    public Task4(int evenNums[]){
        this.rans = evenNums;
    }

    public void run(){

        for (int l = 0; l < 10; l++) {
            if (rans[l] % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + rans[l]);
            }
        }

    }

}

[rahimahsahar]

Main

import java.util.Random;
public class Main {
    public static void main(String[] args) {

        long time_start =System.currentTimeMillis();
        Random random =new Random();
        int[] num=new int[10]; {}

        for(int i=0;i<num.length; i++) {
            num[i]=random.nextInt(1001);

        }
        Thread t1 = new Thread(new Task1(num));
        t1.start();
        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Thread t2 = new Thread(new Task2(num));
        t2.start();
        try {
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Thread t3 = new Thread(new Task3(num));
        Thread t4 = new Thread(new Task4(num));

        t3.start();
        t4.start();
        try {
            t4.join();
        }catch (InterruptedException e) {
            e.printStackTrace();
        }

        long time_end =System.currentTimeMillis();
        long time_used= time_end - time_start;
        System.out.println("Execution Time = "+time_used+"ms");

    }
}

Task 1

public class Task1 implements Runnable{
    int[] num;

    public Task1(int[]num) {
        this.num=num;
    }

    @Override
    public void run() {
        System.out.println("\nTASK 1 :  ");
        for (int i=0;i<num.length;i++) {
            System.out.println("Task 1 =  "+num[i]);
        }
    }
}
}

Task 2

import java.util.Arrays;
public class Task2 implements Runnable {

        int[] num;

    public Task2(int[]num) {
        this.num=num;
        Arrays.sort(num);
    }

    @Override
    public void run() {
        System.out.println("\nTASK 2 :  ");
        for (int i=0;i<num.length;i++) {
            System.out.println("Task 2 ..... "+num[i]);
        }
    }
}

Task 3

public class Task3 implements Runnable {

    int [] num;

    public Task3(int[]num) {
        this.num=num;
    }

    @Override 
    public void run() {
        System.out.println("\nTASK 3 :  ");
        for (int i =0;i<num.length;i++) {
            if(num[i]%2 !=0)
                System.out.println("Task 3....."+num[i]);
        }
    }
}

Task 4

    public Task4(int[]num) {
        this.num=num;
    }

    @Override 
    public void run() {
        System.out.println("\nTASK 4 :  ");
        for (int i =0;i<num.length;i++) {
            if(num[i]%2 ==0)
                System.out.println("Task 4....."+num[i]);
        }
    }
}

[trinanda98]

package JoinThread;

import java.util.Random;

public class RandomNumber {
        public static int[] randArray = new int[1000];

        public static void main(String[] args) {
            Random randNum = new Random();
            for(int i = 0; i < randArray.length; i++) {
                randArray[i] = randNum.nextInt(1001);
            }

            DisplayAll display = new DisplayAll(randArray);
            SortNumber sort = new SortNumber(randArray);
            EvenNumber even = new EvenNumber(randArray);
            OddNumber odd = new OddNumber(randArray);

            Thread task1 = new Thread(display);
            task1.setName("Task 1");
            Thread task2 = new Thread(sort);
            task2.setName("Task 2");
            Thread task3 = new Thread(even);
            task3.setName("Task 3");
            Thread task4 = new Thread(odd);
            task4.setName("Task 4");

            task1.start();
            try {
                task1.join();
            }catch(Exception e) {
                e.printStackTrace();
            }

            task2.start();
            try {
                task2.join();
            }catch(Exception e) {
                e.printStackTrace();
            }

            task3.start();
            try {
                task3.join();
            }catch(Exception e) {
                e.printStackTrace();
            }

            task4.start();

        }
}

package JoinThread;

public class DisplayAll implements Runnable{
    private int[] randArray;
    public DisplayAll(int[] randArray) {
        this.randArray = randArray;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i = 0; i < randArray.length; i++) {
            System.out.println(Thread.currentThread().getName() + " : " + randArray[i]);
        }
    }

}

package JoinThread;

import java.util.Arrays;

public class SortNumber implements Runnable{
    private int[] randArray;

    public SortNumber(int[] randArray) {
        this.randArray = randArray;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        Arrays.sort(randArray);

        for(int i = 0; i < randArray.length; i++) {
            System.out.println(Thread.currentThread().getName() + " : " + randArray[i]);
        }
    }

}

package JoinThread;

public class EvenNumber implements Runnable{
    private int[] randArray;
    public EvenNumber(int[] randArray) {
        this.randArray = randArray;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i = 0; i < randArray.length; i++) {
            if(randArray[i]%2 == 0) {
            System.out.println(Thread.currentThread().getName() + " : " + randArray[i]);}
        }
    }

}

package JoinThread;

public class OddNumber implements Runnable{
    private int[] randArray;

    public OddNumber(int[] randArray) {
        this.randArray = randArray;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i = 0; i < randArray.length; i++) {
            if(randArray[i]%2 != 0) {
                System.out.println(Thread.currentThread().getName() + " : " + randArray[i]);
            }
        }

    }

}

Output:

[alfmrza]

MAIN CLASS

package COM.STIW3054.Test;

import java.util.Random;

public class issue3 {
    public static int array[] = new int[1001];

    public static void main(String[] args) {
        Random rand = new Random();
        for (int gwd = 0; gwd < array.length; gwd++) {
            array[gwd] = rand.nextInt(1001);
        }
        issue3DisplayNum a = new issue3DisplayNum(array);
        issue3EvenNum b = new issue3EvenNum(array);
        issue3OddNum c = new issue3OddNum(array);
        issue3SortNum d = new issue3SortNum(array);

        Thread t1 = new Thread(a);
        t1.setName("Task 1: ");
        Thread t2 = new Thread(d);
        t2.setName("Task 2: ");
        Thread t3 = new Thread(c);
        t3.setName("Task 3: ");
        Thread t4 = new Thread(b);
        t4.setName("Task 4: ");

        t1.start();
        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();
        try {
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t3.start();
        try {
            t3.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t4.start();
        try {
            t4.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

DISPLAY NUMBERS

package COM.STIW3054.Test;

public class issue3DisplayNum implements Runnable{
    int[] rand;

    public issue3DisplayNum(int[] m) {
        this.rand = m;
    }

    public void run() {
        System.out.println("Display ...");
        for (int a = 0; a < rand.length; a++) {
            System.out.println(Thread.currentThread().getName() + " " + rand[a]);
        }
    }
}

ODD NUMBERS

package COM.STIW3054.Test;
import java.util.Arrays;

public class issue3OddNum implements Runnable {

    int [] a;

    public issue3OddNum(int [] a) {

        this.a = a ;
        Arrays.sort(a);

    }

    public void run() {
        System.out.println("And the rest  ... ");
        for(int g = 0 ; g < a.length ; g++) {
            if (a[g]% 2 != 0 )
            System.out.println(Thread.currentThread().getName() +" "+ a[g]); 
        }

    }
}

EVEN NUMBERS

package COM.STIW3054.Test;

import java.util.Arrays;

public class issue3EvenNum implements Runnable {
    int[] a;

    public issue3EvenNum(int[] a) {

        this.a = a;
        Arrays.sort(a);

    }

    public void run() {
        // TODO Auto-generated method stub
        for (int g = 0; g < a.length; g++) {
            if (a[g] % 2 == 0)
                System.out.println(Thread.currentThread().getName() + " " + a[g]);
        }

    }

}

SORT NUMBERS

package COM.STIW3054.Test;
import java.util.Arrays;

public class issue3SortNum implements Runnable {

    int [] a;
    int temp , n; 

    public issue3SortNum(int [] a) {

        this.a = a ;
        Arrays.sort(a);

    }

    public void run() {

        System.out.println("Sorting ... ");
        for(int g = 0 ; g < a.length ; g++) {
            System.out.println(Thread.currentThread().getName() +" "+ a[g]); 
        }

    }

}