3 Themes Printing numbers in sequence

Question

I am trying to write simple code for serial output of numbers. The script is similar to

Thread Number T1 1 T2 2 T3 3 T1 4 T2 5 T3 6 T1 7 T2 8 T3 9 ...and so on. 

Here

 public class ThreadNumberPrinter { Object monitor = new Object(); AtomicInteger number = new AtomicInteger(1); public static void main(String[] args) { ThreadNumberPrinter tnp = new ThreadNumberPrinter(); Thread t1 = new Thread(tnp.new Printer(1, 3)); Thread t2 = new Thread(tnp.new Printer(2, 3)); Thread t3 = new Thread(tnp.new Printer(3, 3)); t3.start(); t1.start(); t2.start(); } class Printer implements Runnable { int threadId; int numOfThreads; public Printer(int id, int nubOfThreads) { threadId = id; this.numOfThreads = nubOfThreads; } public void run() { print(); } private void print() { try { while (true) { Thread.sleep(1000l); synchronized (monitor) { if (number.get() % numOfThreads != threadId) { monitor.wait(); } else { System.out.println("ThreadId [" + threadId + "] printing -->" + number.getAndIncrement()); monitor.notifyAll(); } } } } catch (InterruptedException e) { e.printStackTrace(); } } } } 

But immediately after the 2nd thread starts and prints number 2, the whole thread falls into the waiting stage, and nothing is printed. I am not sure where I am doing wrong. Any help would be greatly appreciated.

Answer 1

Well, the problem is that modulo 3 % 3 is 0 . Change threadId to 0..2 instead of 1..3 and hopefully it should work.

Answer 2

We can use a semaphore for communication between threads to print alternative numbers using 3 threads-

Create 3 semaphores as follows-

  Semaphore one = new Semaphore(1); Semaphore two = new Semaphore(0); Semaphore three = new Semaphore(0); 

Pass this to threads as follows-

  PrintOneNumber printOneNumber = new PrintOneNumber(one, two); PrintTwoNumber printTwoNumber = new PrintTwoNumber(two, three); PrintThreeNumber printThreeNumber = new PrintThreeNumber(three, one); 

The first thread will have

 @Override public void run() { for (int i = 1;; i = i + 3) { try { sempahoreOne.acquire(); System.out.println(i); sempahoreTwo.release(); } catch (InterruptedException e) { e.printStackTrace(); } } } 

The second topic will have

 @Override public void run() { for (int i = 2;; i = i + 3) { try { sempahoreTwo.acquire(); Thread.sleep(1000); System.out.println(i); sempahoreThree.release(); } catch (InterruptedException e) { e.printStackTrace(); } } } 

The third thread will have

 @Override public void run() { for (int i = 3;; i = i + 3) { try { sempahoreThree.acquire(); Thread.sleep(1000); System.out.println(i); sempahoreOne.release(); } catch (InterruptedException e) { e.printStackTrace(); } } } 

Detailed explanations with diagrams and source code -
Java semaphore - printing a sequence of alternative numbers using three streams

Answer 3

Below, the code uses the notification logic of the next thread to print the number, and then incrementing it by 1, then notifying the next thread again, and then goes into a wait state until some thread notifies it. For instance. T1 first prints the value, and then makes a logical “second” value for T2 to print the next number. T2 after printing the number makes the logical "third" truth for T3. T3 does the same, making the logical “first” true for T1 to print the next number.

T1 → T2 → T3 → T1 → T2 → T3 → ........ etc.

 public class Test{ public static volatile int i = 0; public static void main(String[] args) throws InterruptedException { Object monitor = new Object(); Notifier notifier = new Notifier(monitor); Thread thread1 = new Thread(notifier, "T1"); Thread thread2 = new Thread(notifier, "T2"); Thread thread3 = new Thread(notifier, "T3"); thread1.start(); thread2.start(); thread3.start(); } } class Notifier implements Runnable { private Object monitor = null; private static int i = 1; private static boolean first = true; private static boolean second = false; private static boolean third = false; public Notifier(Object objcurr) { this.monitor = objcurr; } @Override public void run() { try { while (true) { synchronized (monitor) { String Tname = Thread.currentThread().getName(); if (first && Tname.equalsIgnoreCase("T1")) { print(); first = false; second = true; monitor.notifyAll(); monitor.wait(); } else if (second && Tname.equalsIgnoreCase("T2")) { print(); second = false; third = true; monitor.notifyAll(); monitor.wait(); } else if (third && Tname.equalsIgnoreCase("T3")) { print(); third = false; first = true; monitor.notifyAll(); monitor.wait(); } else { monitor.wait(); } } Thread.sleep(1000); } } catch (Exception e) { e.printStackTrace(); } } private void print() { System.out.println(Thread.currentThread().getName() + " - " + Notifier.i++); } 

Answer 4

  public class TestClass { private volatile Integer count = 1; private volatile Integer threadIdToRun = 1; private Object object = new Object(); public static void main(String[] args) { TestClass testClass = new TestClass(); Thread t1 = new Thread(testClass.new Printer(1)); Thread t2 = new Thread(testClass.new Printer(2)); Thread t3 = new Thread(testClass.new Printer(3)); t1.start(); t2.start(); t3.start(); } class Printer implements Runnable { private int threadId; public Printer(int threadId) { super(); this.threadId = threadId; } @Override public void run() { try { while (count <= 20) { synchronized (object) { if (threadId != threadIdToRun) { object.wait(); } else { System.out.println("Thread " + threadId + " printed " + count); count += 1; if (threadId == 1) threadIdToRun = 2; else if (threadId == 2) threadIdToRun = 3; else if (threadId == 3) threadIdToRun = 1; object.notifyAll(); } } } } catch (Exception e) { e.printStackTrace(); } } } } 

Above the program produces output

 Thread 1 printed 1 Thread 2 printed 2 Thread 3 printed 3 Thread 1 printed 4 Thread 2 printed 5 Thread 3 printed 6 Thread 1 printed 7 Thread 2 printed 8 Thread 3 printed 9 Thread 1 printed 10 Thread 2 printed 11 Thread 3 printed 12 Thread 1 printed 13 Thread 2 printed 14 Thread 3 printed 15 Thread 1 printed 16 Thread 2 printed 17 Thread 3 printed 18 Thread 1 printed 19 Thread 2 printed 20 

Answer 5

Although this is a bad way to use threads, if we still want a common solution that we can have a worker thread that will store its identifier:

 class Worker extends Thread { private final ResourceLock resourceLock; private final int threadNumber; private final AtomicInteger counter; private volatile boolean running = true; public Worker(ResourceLock resourceLock, int threadNumber, AtomicInteger counter) { this.resourceLock = resourceLock; this.threadNumber = threadNumber; this.counter = counter; } @Override public void run() { while (running) { try { synchronized (resourceLock) { while (resourceLock.flag != threadNumber) { resourceLock.wait(); } System.out.println("Thread:" + threadNumber + " value: " + counter.incrementAndGet()); Thread.sleep(1000); resourceLock.flag = (threadNumber + 1) % resourceLock.threadsCount; resourceLock.notifyAll(); } } catch (Exception e) { System.out.println("Exception: " + e); } } } public void shutdown() { running = false; } } 

The ResourceLock class will store the flag and the maximum number of threads:

 class ResourceLock { public volatile int flag; public final int threadsCount; public ResourceLock(int threadsCount) { this.flag = 0; this.threadsCount = threadsCount; } } 

And then the main class can use it as shown below:

 public static void main(String[] args) throws InterruptedException { final int threadsCount = 3; final ResourceLock lock = new ResourceLock(threadsCount); Worker[] threads = new Worker[threadsCount]; final AtomicInteger counter = new AtomicInteger(0); for(int i=0; i<threadsCount; i++) { threads[i] = new Worker(lock, i, counter); threads[i].start(); } Thread.sleep(10000); System.out.println("Will try to shutdown now..."); for(Worker worker: threads) { worker.shutdown(); } } 

Here, after some delay, we can stop the count, and the shutdown method in worker provides this condition.

Answer 6

  package com.sourav.mock.Thread; import java.util.concurrent.atomic.AtomicInteger; public class ThreeThreadComunication implements Runnable { AtomicInteger counter; int[] array; static final Object mutex = new Object(); public ThreeThreadComunication(int[] array, AtomicInteger counter){ this.counter = counter; this.array = array; } @Override public void run() { int i = 0; while(i < array.length){ synchronized(mutex){ if(Integer.parseInt(Thread.currentThread().getName()) == counter.get()){ System.out.println(array[i]); if(counter.get() == 3){ counter.getAndSet(1); }else{ int c = counter.get(); counter.getAndSet(++c); } i++; } mutex.notifyAll(); try { mutex.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } } } package com.sourav.mock.Thread; import java.util.concurrent.atomic.AtomicInteger; public class ThreeThreadComunicationTest { public static void main(String[] args) { AtomicInteger counter = new AtomicInteger(1); int[] array1 = new int[]{1, 4, 7}; int[] array2 = new int[]{2, 5, 8}; int[] array3 = new int[]{3, 6, 9}; ThreeThreadComunication obj1 = new ThreeThreadComunication(array1, counter); ThreeThreadComunication obj2 = new ThreeThreadComunication(array2, counter); ThreeThreadComunication obj3 = new ThreeThreadComunication(array3, counter); Thread t1 = new Thread(obj1, "1"); Thread t2 = new Thread(obj2, "2"); Thread t3 = new Thread(obj3, "3"); t1.start(); t2.start(); t3.start(); } } 

Answer 7

 public class EvenOdd1 { //public static String str ="str1"; public static void main(String[] args) { // TODO Auto-generated method stub EvenOdd1 edd1 = new EvenOdd1(); AbThread tr2 = new AbThread(0,edd1); AbThread tr3 = new AbThread(1,edd1); AbThread tr4 = new AbThread(2,edd1); tr2.start(); tr3.start(); tr4.start(); } } class AbThread extends Thread { int mod; int mod_count=1; EvenOdd1 edd1; public static int count=1; int num_thread=3; public AbThread(int mod,EvenOdd1 edd1){ this.mod = mod; this.edd1 = edd1; } public void run() { synchronized(edd1) { try{ while(true){ while(count%num_thread!=mod) edd1.wait(); if(count==30) break; print(); edd1.wait(); } } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } public void print() { int val = mod==1?2*mod_count:(mod==2?3*mod_count:4*mod_count); System.out.println(Thread.currentThread().getName() + " : " + val); edd1.notifyAll(); count=count+1; this.mod_count++ ; } } 

Answer 8

 public class PrintThreadsSequentially { static int number = 1; static final int PRINT_NUMBERS_UPTO = 20; static Object lock = new Object(); static class SequentialThread extends Thread { int remainder = 0; int noOfThreads = 0; public SequentialThread(String name, int remainder, int noOfThreads) { super(name); this.remainder = remainder; this.noOfThreads = noOfThreads; } @Override public void run() { while (number < PRINT_NUMBERS_UPTO) { synchronized (lock) { while (number % noOfThreads != remainder) { // wait for numbers other than remainder try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println(getName() + " value " + number); number++; lock.notifyAll(); } } } } public static void main(String[] args) { SequentialThread first = new SequentialThread("First Thread", 0, 4); SequentialThread second = new SequentialThread("Second Thread", 1, 4); SequentialThread third = new SequentialThread("Third Thread", 2, 4); SequentialThread fourth = new SequentialThread("Fourth Thread", 3, 4); first.start(); second.start(); third.start(); fourth.start(); } 

}

Answer 9

The ThreadSynchronization class can be used to print numbers between 'n' no. threads in sequence. The logic is to create a common object between each of the sequential streams and use "wait", "notify" to print numbers sequentially. Note: the last thread will share the object with the first thread.

You can change the value of maxThreads to increase or decrease the number of threads in the program before running it.

 import java.util.ArrayList; import java.util.List; public class ThreadSynchronization { public static int i = 1; public static final int maxThreads = 10; public static void main(String[] args) { List<Object> list = new ArrayList<>(); for (int i = 0; i < maxThreads; i++) { list.add(new Object()); } Object currObject = list.get(maxThreads - 1); for (int i = 0; i < maxThreads; i++) { Object nextObject = list.get(i); RunnableClass1 a = new RunnableClass1(currObject, nextObject, i == 0 ? true : false); Thread th = new Thread(a); th.setName("Thread - " + (i + 1)); th.start(); currObject = list.get(i); } } } class RunnableClass implements Runnable { private Object currObject; private Object nextObject; private boolean firstThread; public RunnableClass(Object currObject, Object nextObject, boolean first) { this.currObject = currObject; this.nextObject = nextObject; this.firstThread = first; } @Override public void run() { int i = 0; try { if (firstThread) { Thread.sleep(5000); firstThread = false; System.out.println(Thread.currentThread().getName() + " - " + ThreadSynchronization.i++); synchronized (nextObject) { nextObject.notify(); } } while (i++ < Integer.MAX_VALUE) { synchronized (currObject) { currObject.wait(); } System.out.println(Thread.currentThread().getName() + " - " + ThreadSynchronization.i++); Thread.sleep(1000); synchronized (nextObject) { nextObject.notify(); } } } catch (Exception e) { e.printStackTrace(); } } } 

Answer 10

How about this?

 public class PrintNumbers implements Runnable { public static final int NO_OF_THREADS = 3; public static final int MAX_DIGIT = 20; public static final String THREAD_NAME_PREFIX = "t"; volatile int current = 1; private Object lock = new Object(); public static void main(String[] args) { PrintNumbers printNumbers = new PrintNumbers(); for (int i = 1; i <= NO_OF_THREADS; i++) { new Thread(printNumbers, THREAD_NAME_PREFIX + i).start(); } } @Override public void run() { String printThread; while (current < MAX_DIGIT) { synchronized (lock) { if (current % NO_OF_THREADS != 0) { printThread = THREAD_NAME_PREFIX + current % NO_OF_THREADS; } else { printThread = THREAD_NAME_PREFIX + NO_OF_THREADS; } if (!printThread.equals(Thread.currentThread().getName())) { try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } if (printThread.equals(Thread.currentThread().getName())) { System.out.println(String.format("Thread %s : %s", Thread.currentThread().getName(), current)); current = current + 1; } lock.notifyAll(); } } } } 

Answer 11

Below I tried a simple way to print in sequence using three threads, and it works well.

 public class AppPrint123 { static int count = 1; static int counter = 1; static Object lock = new Object(); public static void main(String[] args) { Thread t1 = new Thread(new Runnable() { public void run() { while (true) { synchronized (lock) { try { Thread.sleep(100); while (count != 1) { lock.wait(); } System.out.println(Thread.currentThread().getName() + ": " + counter); count++; counter++; } catch (InterruptedException e) { e.printStackTrace(); } lock.notifyAll(); } } } }, "T1"); Thread t2 = new Thread(new Runnable() { public void run() { while (true) { synchronized (lock) { try { Thread.sleep(100); while (count != 2) { lock.wait(); } System.out.println(Thread.currentThread().getName() + ": " + counter); counter++; } catch (InterruptedException e) { e.printStackTrace(); } lock.notifyAll(); } } } }, "T2"); Thread t3 = new Thread(new Runnable() { public void run() { while (true) { synchronized (lock) { try { Thread.sleep(100); while (count != 3) { lock.wait(); } System.out.println(Thread.currentThread().getName() + ": " + counter); count = count - 2; counter++; } catch (InterruptedException e) { e.printStackTrace(); } lock.notifyAll(); } } } }, "T3"); t1.start(); t2.start(); t3.start(); } } 

Instead, you can print the count variable if you want to generate output, for example 123123123, using three streams.

Answer 12

A bad way to do this, but to ask is to implement multiple threads:

 private static AtomicInteger currentThreadNo = new AtomicInteger(0); private static int currentNo = 1; private static final Object lock = new Object(); 

Above these values ​​are static so they remain the same for all work objects.

 import java.util.concurrent.atomic.AtomicInteger; public class PrintNumbersUsingNThreads implements Runnable { private final int threadNo; private final int totalThreads; private static AtomicInteger currentThreadNo = new AtomicInteger(0); private static int currentNo = 1; private static final Object lock = new Object(); public PrintNumbersUsingNThreads(int threadNo, int totalThreads) { this.threadNo = threadNo; this.totalThreads = totalThreads; } @Override public void run() { while (true) { while (currentThreadNo.get() % totalThreads != threadNo) { try { synchronized (lock) { lock.wait(); } } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println(Thread.currentThread().getName() + " printing " + currentNo); currentNo++; int curr = currentThreadNo.get(); if (curr == totalThreads) { currentThreadNo.set(1); } else { currentThreadNo.incrementAndGet(); } try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (lock) { lock.notifyAll(); } } } public static void main(String[] args) { int totalThreads = 3; for(int i = 0; i < totalThreads; i++){ new Thread(new PrintNumbersUsingNThreads(i,totalThreads),"thread"+i).start(); } } } 

Answer 13

 public class ThreadTask implements Runnable { private int counter; private int threadID; private final Object lock; private int prev; public ThreadTask(Object obj, int threadid, int counter){ this.lock = obj; // monitor this.threadID = threadid; //id of thread this.counter = counter; this.prev =threadid + 1; } public void run(){ while(counter<100){ synchronized(lock){ if(counter == this.prev && this.threadID % 3 == this.threadID){ System.out.println("T" + this.threadID + " = " + this.prev); this.prev = this.prev + 3; } counter++; lock.notifyAll(); try{ lock.wait(); }catch(Exception e){ e.printStackTrace(); } } } } } public class ThreadMain { static volatile int counter = 1; public static void main(String args[]) throws InterruptedException{ final Object lock = new Object(); ThreadTask first = new ThreadTask(lock, 0, counter); ThreadTask second = new ThreadTask(lock, 1, counter); ThreadTask third = new ThreadTask(lock, 2, counter); Thread t1 = new Thread(first, "first"); Thread t2 = new Thread(second, "second"); Thread t3 = new Thread(third, "third"); t1.start(); t2.start(); t3.start(); t1.join(); t2.join(); t3.join(); } } 

Answer 14

 package ThreadCoreConcepts; import java.util.ArrayList; import java.util.List; /** * 3 Thread T1,T2,T3 will print output {1,2,3 4,5,6 7,8,9} Where T1 will print * {1,4,7} , T2 will print { 2,5,8} and T3 will print {3,6,9} * * @author harsmahe * */ public class ThreeThreadSequenceGen { private volatile static int value = 1; public static void main(String args[]) throws InterruptedException { ThreeThreadSequenceGen gen = new ThreeThreadSequenceGen(); Object mutex = new Object(); Thread t1 = new Thread(gen.new RunThread(1, mutex)); t1.setName("1"); Thread t2 = new Thread(gen.new RunThread(2, mutex)); t2.setName("2"); Thread t3 = new Thread(gen.new RunThread(3, mutex)); t3.setName("3"); t1.start(); t2.start(); t3.start(); } class RunThread implements Runnable { private int start = 0; private Object mutex; private List<Integer> list = new ArrayList<Integer>(); public RunThread(final int start, Object mutex) { // TODO Auto-generated constructor stub this.start = start; this.mutex = mutex; } @Override public void run() { try { while (value <= 9) { // while (true) { // TODO Auto-generated method stub int name = Integer.valueOf(Thread.currentThread().getName()); // System.out.println("[" + Thread.currentThread().getName() // + "]"); // notifyAll(); synchronized (mutex) { if (name == 1 && value == start) { list.add(value); System.out.println("[" + Thread.currentThread().getName() + "]" + value); start = start + 3; value++; mutex.notifyAll(); mutex.wait(); } else if (name == 2 && value == start) { System.out.println("[" + Thread.currentThread().getName() + "]" + value); list.add(value); start = start + 3; value++; mutex.notifyAll(); mutex.wait(); } else if (name == 3 && value == start) { System.out.println("[" + Thread.currentThread().getName() + "]" + value); list.add(value); start = start + 3; value++; mutex.notifyAll(); if (value < 9) { mutex.wait(); } } else { mutex.notifyAll(); // mutex.wait(); } } } } catch (Exception e) { e.printStackTrace(); } finally { // System.out.println(list); } } } } enter code here