We Keep Coding

Can FairSync guarantee the order of execution?

My first question, Thank for your help!
I'm trying to print odd and even numbers 1~100 alternatively using two threads.
Expected results：
pool-1-thread-1=> 1
pool-1-thread-2=> 2
pool-1-thread-1=> 3
pool-1-thread-2=> 4
......
pool-1-thread-1=> 99
pool-1-thread-2=> 100
I think i can use FairSync, but it can only guarantee that most of the print is correct. like this：
pool-1-thread-1=> 55
pool-1-thread-2=> 56
pool-1-thread-1=> 57
pool-1-thread-2=> 58
pool-1-thread-2=> 59 //※error print※
pool-1-thread-1=> 60
pool-1-thread-2=> 61
pool-1-thread-1=> 62
I don't know why is the order lost in very few cases?
You can criticize my code and my English.
Here is my code:
private static final int COUNT = 100;
private static final int THREAD_COUNT = 2;
private static int curr = 1;
static ReentrantLock lock = new ReentrantLock(true);
static ExecutorService executorService = Executors.newCachedThreadPool();
public static void main(String[] args) {
Runnable task = () -> {
for (; ; ) {
try {
lock.lock();
if (curr <= COUNT) {
System.out.println(Thread.currentThread().getName() + "=> " + curr++);
} else {
System.exit(0);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
};
for (int i = 0; i < THREAD_COUNT; i++) {
executorService.execute(task);
}
}

No dear your implementation is not correct. Which thread get's the opportunity to RUN is decided by the OS. Thread 1 & 2 will execute one after another cannot be guaranteed.
You can fix your code by checking the previous value of the variable curr and if the value is not what this thread expects don't increment and print.
for eg :
if(curr.threadName.equals("Thread 2") && (curr%2 !=0))
{
// Print
// Increment
}

You cant use single lock to achieve this. Even ReentrantLock gives fairness but it cant control thread schedule.
We can achieve throw inter thread communication like Semaphore. Semaphore controls the thread execution.
We create two threads, an odd thread, and an even thread. The odd thread would print the odd numbers starting from 1, and the even thread will print the even numbers starting from 2.
Create two semaphores, semOdd and semEven which will have 1 and 0 permits to start with. This will ensure that odd number gets printed first.
class SharedPrinter {
private Semaphore semEven = new Semaphore(0);
private Semaphore semOdd = new Semaphore(1);
void printEvenNum(int num) {
try {
semEven.acquire();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
System.out.println(Thread.currentThread().getName() + num);
semOdd.release();
}
void printOddNum(int num) {
try {
semOdd.acquire();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
System.out.println(Thread.currentThread().getName() + num);
semEven.release();
}
}
class Even implements Runnable {
private SharedPrinter sp;
private int max;
// standard constructor
#Override
public void run() {
for (int i = 2; i <= max; i = i + 2) {
sp.printEvenNum(i);
}
}
}
class Odd implements Runnable {
private SharedPrinter sp;
private int max;
// standard constructors
#Override
public void run() {
for (int i = 1; i <= max; i = i + 2) {
sp.printOddNum(i);
}
}
}
public static void main(String[] args) {
SharedPrinter sp = new SharedPrinter();
Thread odd = new Thread(new Odd(sp, 10),"Odd");
Thread even = new Thread(new Even(sp, 10),"Even");
odd.start();
even.start();
}
Refer : here

Print numbers 1,2,3 using thread1 and 4,5,6 using thread2, and 7,8,9 using thread3 and again 10,11,12 using thread1

I am trying a write a simple program with wait and notify in which I will create 3 threads.
The first thread should print 1, 2, 3.
The second thread should print 4, 5, 6.
The third thread should print 7, 8, 9.
After that, the first thread should print 10, 11, 12 and so on.
Below is a sample code for the same exercise, but I am unable to print the desired output.
public class MyThread2 extends Thread {
public final static Object obj = new Object();
int threadNo;
static volatile int threadNoToRun;
static volatile int counter = 1;
public MyThread2(int threadNo){
this.threadNo= threadNo;
}
#Override
public void run() {
synchronized (obj) {
try {
if(threadNoToRun != threadNo)
obj.wait();
else{
for(int i = 1 ; i < 4 ; i++){
if(threadNoToRun == threadNo){
System.out.println(threadNo + " counter value is "+counter);
counter++;
System.out.println(threadNo + " counter value is "+counter);
counter++;
System.out.println(threadNo + " counter value is "+counter);
counter++;
if(threadNoToRun == 1){
threadNoToRun = 2;
}
else if(threadNoToRun == 2){
threadNoToRun = 3;
}
else if(threadNoToRun == 3){
threadNoToRun = 1;
}
}
}
obj.notifyAll();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main (String args[]) {
/*
* Creating as many threads as needed.
*/
MyThread2 th1 = new MyThread2(1);
MyThread2 th2 = new MyThread2(2);
MyThread2 th3 = new MyThread2(3);
MyThread2.threadNoToRun = 1;
th1.start();
th2.start();
th3.start();
}
}
The output looks like:
1 counter value is 1
1 counter value is 2
1 counter value is 3
2 counter value is 4
2 counter value is 5
2 counter value is 6

Here, it was just a few changes.
Nonetheless, I have to point out that this kind of concurrency does NOT increase computation speed. Only one thread is alive at all times.
public class MyThread2 extends Thread {
public final static Object obj = new Object();
int threadNo;
static volatile int threadNoToRun;
static volatile int counter = 1;
public MyThread2(int threadNo) {
this.threadNo = threadNo;
}
#Override
public void run() {
synchronized (obj) {
try {
while (counter < 100) {
if (threadNoToRun != threadNo)
obj.wait();
else {
System.out.println(threadNo + " counter value is " + counter);
counter++;
System.out.println(threadNo + " counter value is " + counter);
counter++;
System.out.println(threadNo + " counter value is " + counter);
counter++;
if (threadNoToRun == 1) {
threadNoToRun = 2;
} else if (threadNoToRun == 2) {
threadNoToRun = 3;
} else if (threadNoToRun == 3) {
threadNoToRun = 1;
}
obj.notifyAll();
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String args[]) {
/*
* Creating as many threads as needed.
*/
MyThread2 th1 = new MyThread2(1);
MyThread2 th2 = new MyThread2(2);
MyThread2 th3 = new MyThread2(3);
MyThread2.threadNoToRun = 1;
th1.start();
th2.start();
th3.start();
}
}

Java multithreading query

Hi I am a newbie in concurrent programming domain, I was testing the below code and seems the while loop is not terminating for threads. Could someone help explain whats happening here.
public class PrimePrinter{
public long counter = 0;
public synchronized long getCounter() {
return counter++;
}
public Thread makeThread() {
Runnable rn = new Runnable() {
/* (non-Javadoc)
* #see java.lang.Runnable#run()
*/
#Override
public void run() {
while (counter < 100) {
try {
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + " : " +getCounter());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
return new Thread(rn);
}
public static void main(String[] args) {
int n = 10;
Thread[] threads = new Thread[10];
PrimePrinter pp = new PrimePrinter();
for(int i = 1; i < n; i++) {
threads[i] = pp.makeThread();
threads[i].start();
}
}
}
Last few lines of output
Thread-4 : 81
Thread-5 : 87
Thread-7 : 91
Thread-5 : 97
Thread-2 : 95
Thread-4 : 98
Thread-6 : 96
Thread-8 : 90
Thread-1 : 93
Thread-3 : 92
Thread-0 : 94
Thread-2 : 99
Thread-6 : 107
Thread-3 : 103
Thread-0 : 104
Thread-1 : 105
Thread-8 : 106
Thread-5 : 102
Thread-4 : 101
Thread-7 : 100

This is not working for one reason that is crucial not to miss. Consider the way your code actually runs. It checks the counter value, then sleeps, THEN prints THEN increments.
You have 9 threads running at once. Then, 8 of these threads check the value, and at the time, the value is less than 100. So they pass the test and keep going. All 8 then sleep for 1000ms. Meanwhile, your other thread has just incremented the value... and 8 more are about to come out of their sleep.
So, if your value is 99 (which it inevitably will be), you'll now get a value of 100 from the thread that just incremented. Then, those 8 that already passed the test are also going to be incrementing, giving the counter a resulting value of 108.
However, the very last thread to run will show a value of 107 because you print THEN increment for all runs.
If you did this the other way around (like in the code below), you would not run into this problem.
The following code works correctly:
public class PrimePrinter {
public long counter = 0;
public synchronized long getCounter() {
return counter;
}
public synchronized void incrementCounter() {
counter++;
}
public Thread makeThread() {
Runnable rn = new Runnable() {
/*
* (non-Javadoc)
*
* #see java.lang.Runnable#run()
*/
#Override
public void run() {
while (getCounter() < 100) {
try {
incrementCounter();
System.out.println(Thread.currentThread().getName()
+ " : " + getCounter());
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
return new Thread(rn);
}
public static void main(String[] args) {
int n = 10;
Thread[] threads = new Thread[10];
PrimePrinter pp = new PrimePrinter();
for (int i = 1; i < n; i++) {
threads[i] = pp.makeThread();
threads[i].start();
}
}
}

Each thread waits a second after having tested that counter < 100, during this second, other threads can increment the counter.
UPDATE: You could do something like this:
while (true) {
long current = getCounter();
if (current >= 100) {
break;
}
try {
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + " : " + current);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

How to use intrinsic locks in java?

I'm reading the official Java Tutorial provided by Oracle and I wanted to put my knowledge into practice.
I wanted to see Thread Interference in action and solving it using Intrinsic Locks and Synchronization. So I created a class called Counter with:
Two fields that are both initialized to 0.
Methods for incrementing and decrementing their values.
Method for printing out the values.
.
public class Apple {
public static void main(String[] args) {
Counter myCounter = new Counter();
Thread a = new Thread(myCounter);
Thread b = new Thread(myCounter);
a.start();
b.start();
}
}
class Counter implements Runnable {
public int a = 0;
public int b = 0;
void incA() {
++a;
}
void decA() {
--a;
}
void incB() {
++b;
}
void decB() {
--b;
}
void printValues() {
System.out.println("a: " + a + " | b: " + b);
}
public void run() {
for (int i = 0; i < 10; i++) {
incA();
decA();
incB();
decB();
printValues();
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
First I run my program without using intrinsic locks or synchronization and the output was what I expected, thread interference.
...
a: 0 | b: 0
a: 0 | b: 1
a: 0 | b: 0
a: 1 | b: 0
a: 0 | b: 0
...
Now I wanted to sort this problem using intrinsic locks so that while one thread is incrementing or decrementing a, the other thread can change b at the same time, rather than using synchronized methods which would prevent that.
So I added two new fields (locks) and synchronized blocks using the intrinsic locks. Here's the new code:
class Counter implements Runnable {
public int a = 0;
public int b = 0;
Object lock1 = new Object();
Object lock2 = new Object();
void incA() {
synchronized (lock1) {
++a;
}
}
void decA() {
synchronized (lock1) {
--a;
}
}
void incB() {
synchronized (lock2) {
++b;
}
}
void decB() {
synchronized (lock2) {
--b;
}
}
void printValues() {
System.out.println("a: " + a + " | b: " + b);
}
public void run() {
for (int i = 0; i < 10; i++) {
incA();
decA();
incB();
decB();
printValues();
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
I haven't made any change to the main method so I didn't include it. But I ran this code three times and this was the output on the last try:
...
a: 0 | b: 0
a: 0 | b: 0
a: 0 | b: 1
a: 0 | b: 0
What did I do wrong? How should the code look like?
I just want a simple example code that uses intrinsic locks.

printValues() reads and prints the values while another thread increments or decrements them: it's not synchronized. And even if it was, it could read and print b between the calls to incB() and decB() of the other thread.
So you can have
thread 1 increments b --> b = 1
thread 2 reads and prints b --> b is printed as 1
thread 1 decrements b --> b = 0
If nobody is ever supposed to see b different from 0, then incB();decB() should be a single atomic operation, by putting these two calls in a single synchronized block, and the read of b should also be put into a synchronized block, using the same lock:
class Counter implements Runnable {
private int a = 0;
private int b = 0;
private final Object lock1 = new Object();
private final Object lock2 = new Object();
private void incA() {
++a;
}
private void decA() {
--a;
}
private void incB() {
++b;
}
private void decB() {
--b;
}
private void printValues() {
System.out.println("a: " + a + " | b: " + b);
}
public void run() {
for (int i = 0; i < 10; i++) {
synchronized (lock1) {
incA();
decA();
}
synchronized (lock2) {
incB();
decB();
}
synchronized (lock1) {
synchronized (lock2) {
printValues();
}
}
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

How about you remove printValues() from run() method and in your main thread you wait for all thread to finish before printing? So main would be:
public static void main(String[] args) throws InterruptedException {
Counter myCounter = new Counter();
Thread a = new Thread(myCounter);
Thread b = new Thread(myCounter);
a.start();
b.start();
a.join();
b.join();
myCounter.printValues();
}

Threads - simple concurrency issue

Ok this is the problem: the following code is obviously not written thread safe, cause the method increment() is not syncronized. The output varies, and doesn't go like: 1,2,3,4,5,6...
For example the output can be this: 1,2,3,4,5,1...
but then it continues like this 6,7,8,... and reaches 100. I don't understand how can it reach 100, shouldnt after second 1 come 2 again, at least in some cases, couse the balance was wrongly updated by the other thread. The question is this: why after 1 it continues normally with 6, 7...
class Job implements Runnable{
private int balance;
public void run(){
for (int i = 0; i < 50; i++) {
increment();
System.out.println(balance);
int a = 3;
int b = 4;
a = b;
}
}
public void increment(){
int i = balance;
balance = i+1;
}
}
public class ThreadsDemo{
public static void main(String[] args) {
Job job = new Job();
Thread alpha = new Thread(job);
Thread beta = new Thread(job);
alpha.setName("alpha");
beta.setName("beta");
alpha.start();
beta.start();
}
}
To explain further, here is one of the possible outcomes:
Thread 1:
balance - 0
i - 0 (thread 1 put back to runnable)
Thread 2:
balance - 0, 1, 2, 3, 4, 5
i - 0, 1, 2, 3, 4, (thread 2 put back to runnable)
Thread 1 (put to running):
balance - ... 1, 2
i - 0, 1
(In some cases it can update normaly, but in 50 iterations it must come some abnormal update)
How does every outcome reach 100, is this some IDE optimization to deal with thread interleaving or what?
ANSWER:
So no need for latch in this example, just that the thread was "blocking" on print, and the other could finish the update in the meantime. Ty Affe
class Job implements Runnable{
public int balance = 0;
//public static CountDownLatch latch = new CountDownLatch(1);
public void run(){
for (int i = 0; i < 50000; i++) {
increment();
}
}
public void increment(){
int i = balance;
balance = i+1;
}
}
public class ThreadsDemo{
public static void main(String[] args) {
Job job = new Job();
Thread alpha = new Thread(job);
Thread beta = new Thread(job);
alpha.setName("alpha");
beta.setName("beta");
alpha.start();
beta.start();
try {
alpha.join();
beta.join();
} catch (Exception ex) { }
System.out.println(job.balance +" "+ alpha.isAlive() + " " + beta.isAlive());
}
}
The output is around 60 000, as it was expected.

You calculation is very fast and starting threads is very slow. The first one is completely done before the second one ever begins. The out-of-place numbers in the output are likely just issues with buffer flushing in the operating system.
Add a latch so that both threads actually start at the same time, and use a sufficiently large number, and you will see a total that doesn't add up.
public static CountDownLatch latch = new CountDownLatch(1);
private static class Job implements Runnable{
private int balance;
public void run(){
try {
latch.await();
} catch (InterruptedException e) {}
for (int i = 0; i < 50000; i++) {
//existing code
}
}
public void increment(){
int i = balance;
//make it work harder so there's more opportunity for an actual interleave
balance = new BigInteger(Integer.toString(i)).add(BigInteger.ONE).intValue();
}
}
public static void main(String[] args) {
//existing code
alpha.start();
beta.start();
try {
Thread.sleep(100);
} catch (InterruptedException e) {}
latch.countDown();
}