Impression uniforme impair avec fil

public class Number_Thread extends Thread {

String thread;
int limit;

public Number_Thread(String thread,int limit){
    this.thread=thread;
    this.limit=limit;
                                             }

Object lock=new Object();

public  void run()
{

    synchronized (lock) 
    {

          //------------------- "print even"--------------------//

      if(thread.equals("even"))
        {
            for (int i = 2; i <=limit; i+=2) 
            {

                 System.out.println(thread+" thread "+i);
            try {

            lock.wait(1000);
                 continue;

                }
              catch (InterruptedException e) {}
            }
            lock.notifyAll();
        }

         //------------------- "print odd"--------------------//

    if(thread.equals("odd"))
         {
         for (int i = 1; i <=limit; i+=2) 
             {
                System.out.println(thread+" thread  "+i);
            try {

                lock.wait(1000);
                    continue;
                }
            catch (InterruptedException e) {}
            }
            lock.notifyAll();
         }
      }
   }
}

     //------------------thread creater class------------------//
import java.util.Scanner;

public class Main_Thread {
private static Scanner s;
    public static void main(String[] args) throws InterruptedException {
        System.out.print("enter limit:\t ");
        s=new Scanner(System.in);
    int n=s.nextInt();
     s.close();
    Thread t1=new Number_Thread("even",n);
    Thread t2=new Number_Thread("odd",n);
    t2.start();
    Thread.sleep(100);
    t1.start();

 }

}
output for limit 5:enter limit:     5odd  thread 1
even thread 2
odd  thread  3
even thread 4
odd  thread  5

J'ai mis en œuvre de telle manière, sur la base de l'argument, aucun des threads sera engendré et sera le non respectif de la manière de Round Robin. I.e., si le nombre de threads est 3, le fil 1 imprimera 1,4 ...; Le fil 2 imprimera 2,5, ... et le fil 3 imprimera 3,6 ...

public class ThreadSynchronizer
{

    public static void main(String[] args)
    {
    // BASED ON THE ARGUMENT MULTIPLE THREADS WILL BE CREATED AND EACH WILL PRINT ITS RESPECTIVE NO
    // IE, IF THREAD COUNT IS 3, THREAD 1 WILL PRINT 1,4 ..., THREAD2 WILL PRINT 2,5,... AND THREAD3 WILL PRINT 3,6...
    // LIMITED THE DISPLAY TO 1000 NOS
    int threadCnt = Integer.parseInt(args[0]);

    ReentrantLock lckArray[] = new ReentrantLock[threadCnt + 1];

    for (int i = 0; i < threadCnt + 1; i++)
    {
        ReentrantLock lck = new ReentrantLock();
        lck.lock();
        lckArray[i] = lck;
    }

    for (int i = 0; i < threadCnt; i++)
    {
        Thread th = new Thread(new Printer(lckArray, i + 1));
        th.start();
    }

    for (int i = 1; i < threadCnt + 1; i++)
    {
        lckArray[i].unlock();

        while (!lckArray[i].isLocked())
        {

        }
    }
    lckArray[0].unlock();
    }
}

class Printer implements Runnable
{

    private ReentrantLock[] lckArray;
    private int index;

    Printer(ReentrantLock[] lckArray, int startValue)
    {
    this.lckArray = lckArray;
    this.index = startValue;
    }

    @Override public void run()
    {
    ReentrantLock prevLock = null;
    int printCounter = index;

    for (int counter = 0; printCounter <= 1000; counter++)
    {
        int remCounter = counter % lckArray.length;
        int incCounter = lckArray.length - remCounter;
        int indexPostion = index + incCounter;
        int curElementIndex = indexPostion % lckArray.length;

        lckArray[curElementIndex].lock();
        if (prevLock != null)
        prevLock.unlock();
        prevLock = lckArray[curElementIndex];

        if (curElementIndex == 0)
        {
        System.out.println("Printed by Thread " + index + " " + printCounter);
        printCounter = printCounter + lckArray.length - 1;
        }

    }

    if (prevLock != null)
    {
        if (prevLock.isHeldByCurrentThread())
        prevLock.unlock();
    }

    }

}

Programme pour deux threads, imprimez alternativement des nombres impairs et paires.

#Implégement en utilisant le concept "Verrouillage d'objet". P>

class Increment{
private int count;
    public void increment(){
        count++;
        System.out.println(Thread.currentThread().getName()+"::::::::::::::::::"+count);
    }
}


class SimpleThread extends Thread{
 
 Increment obj = null;
 
 SimpleThread(Increment obj){
    this.obj=obj;
 }  
 
 public void run(){
     try {
    Thread.sleep(100);
         while(true){
            synchronized(obj){
                   obj.increment();
                   Thread.sleep(1000);
                   obj.notify();
                   obj.wait();  
            }
         }
     } catch(InterruptedException ie) {
        ie.printStackTrace(); 
     }
 } 
 
}

public class Main
{
    public static void main(String[] args) {
        
        Increment increment = new Increment();
        SimpleThread t1 = new SimpleThread(increment);
        SimpleThread t2 = new SimpleThread(increment);
       
        t1.start();
        t2.start();

        System.out.println(Thread.currentThread().getName()+"::::::::::::::"+"Hello World");
        System.out.println(Runtime.getRuntime().availableProcessors()+"::::::::::::::"+"CORE SIZE");
    }
}

Je l'ai mis en place d'une manière très simple, de 1 à 40> xxx