This question already has answers here:
Threading and synchronized methods
(3 answers)
Closed 4 years ago.
I'm very novice in multithreading in java, so would be very appreciate if someone give me brief explanation of the following:
here is my code:
public class Lesson6 {
private static volatile Long value = 0L;
public static void main(String[] args) throws InterruptedException {
Thread inc = new Thread(new Runnable() {
#Override
public void run() {
for (int i = 0; i < 100_000; i++) {
synchronized (this){
++value;
}
}
}
});
inc.start();
Thread dec = new Thread(new Runnable() {
#Override
public void run() {
for (int i = 0; i < 100_000; i++) {
synchronized (this){
--value;
}
}
}
});
dec.start();
inc.join();
dec.join();
System.out.println(value);
}
}
It seems for me, that the output should be zero, but it's never zero. Debugger shows that THIS is always different from time to time as run() methods go. Why does this happen?
Thanx.
Debugger shows that THIS is always different from time to time as run() methods go
Each new Runnable is a different object so this is different in each case.
If you use a common object, the program should work.
BTW I suggest using a primitive long for the value instead of a reference to a Long
public class Lesson6 {
private static volatile long value = 0L;
public static void main(String[] args) throws InterruptedException {
final Object locked = new Object();
Thread inc = new Thread(new Runnable() {
#Override
public void run() {
for (int i = 0; i < 100_000; i++) {
synchronized (locked){
++value;
}
}
}
});
inc.start();
Thread dec = new Thread(new Runnable() {
#Override
public void run() {
for (int i = 0; i < 100_000; i++) {
synchronized (locked){
--value;
}
}
}
});
dec.start();
inc.join();
dec.join();
System.out.println(value);
}
}
prints
0
Related
I want to learn how to use the synchronized method in java and implemented the following code.
public class checkThread {
volatile int i = 0;
public void increment() {
i++;
}
}
public class TestSync extends checkThread{
public static void main(String[] args) {
checkThread ct1 = new checkThread();
Object iLock = new Object();
for(int i = 0 ; i < 10 ; i++) {
extracted(ct1, iLock);
}
}
private static void extracted(checkThread ct1, Object iLock) {
synchronized (iLock) {
Thread t1 = new Thread(new Runnable() {
#Override
public void run() {
for(int a = 0; a < 1000; a++) {
ct1.increment();
}
}
});
t1.start();
}
synchronized (iLock) {
Thread t2 = new Thread(new Runnable() {
#Override
public void run() {
for(int a = 0; a < 1000; a++) {
ct1.increment();
}
}
});
t2.start();
}
synchronized (iLock) {
System.out.println(ct1.i);
}
}
}
However the output I get is not at all synchronized!
1000
2000
4000
6000
8000
9000
11575
13575
15575
17459
Why am I getting such an output and not the desired value of i in the multiples of 1000?
If you are trying to make sure that the run() method will be completed by one thread before the other one start; then you need to synchronize the content inside the run method, not the thread creation part.
In your specific example, you need to have an object that can be accessed by both the threads, and then acquire the lock of that object.
Let me add an example below by changing your code; but this may not be the best way; just trying to explain the point.
checkThread iLock = new checkThread();
public void someMethod() {
Thread t1 = new Thread(new Runnable() {
#Override
public void run() {
synchronized (iLock) {
for(int a = 0; a < 1000; a++) {
ct1.increment();
}
}
});
t1.start();
}
Thread t2 = new Thread(new Runnable() {
#Override
public void run() {
synchronized (iLock) {
for(int a = 0; a < 1000; a++) {
ct1.increment();
}
}
});
t2.start();
}
synchronized (iLock) {
System.out.println(ct1.i);
}
}
In this code I'm using 10 threads updating an AtomicInteger variable. I expect the final result of Counter.getInstance().holder.n to be 1000000, but it prints out random number like 991591.
What's wrong with my code?
public class Test {
public static void main(String[] args) {
List<Thread> list = new ArrayList<Thread>();
for (int i = 0; i < 10; i++) {
list.add(new Thread() {
public void run() {
for (int i = 0; i < 100000; i++) {
Counter.getInstance().holder.n.incrementAndGet();
}
}
});
}
for (Thread thread : list) {
thread.start();
}
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Counter.getInstance().holder.n);
}
}
class Counter {
private static Counter counter;
Holder holder = new Holder();
public static Counter getInstance() {
if (counter == null) {
counter = new Counter();
}
return counter;
}
class Holder {
AtomicInteger n = new AtomicInteger(0);
}
}
You have two major concurrent issues here:
You don't wait for every Thread to finish work correctly. There are multiple ways to achieve that, the simplest is to use Thread.join().
Your singleton implementation doesn't seem correct. I suppose you intended to implement it with an inner class. It seems that this answer can help to understand what's happening here.
Here is the implementation that seems more or less correct.
class Test {
public static void main(String[] args) throws InterruptedException {
List<Thread> list = new ArrayList<Thread>();
for (int i = 0; i < 10; i++) {
list.add(new Thread() {
public void run() {
for (int i = 0; i < 100000; i++) {
Counter.getInstance().n.incrementAndGet();
}
}
});
}
for (Thread thread : list) {
thread.start();
}
for (Thread thread : list) {
thread.join();
}
System.out.println(Counter.getInstance().n);
}
}
class Counter {
public AtomicInteger n = new AtomicInteger(0);
public static Counter getInstance() {
return Holder.instance;
}
private static class Holder {
private static final Counter instance = new Counter();
}
}
You can use something like CountDownLatch as well. For example:
final int count = 10;
CountDownLatch latch = new CountDownLatch(count);
List<Thread> list = new ArrayList<Thread>();
for (int i = 0; i < count; i++) {
list.add(new Thread() {
public void run() {
for (int i = 0; i < 100000; i++) {
Counter.getInstance().n.incrementAndGet();
}
latch.countDown();
}
});
}
for (Thread thread : list) {
thread.start();
}
latch.await();
System.out.println(Counter.getInstance().n);
Why is count 0?
I start the thread 1 then I start thread 2. Count should be 2000. But it shows count to be 0. Someone please explain in simple terms.
public class App {
private int count = 0;
public static void main(String[] args) {
App app = new App();
app.doWork();
}
public void doWork(){
Thread t1 = new Thread(new Runnable(){
public void run(){
for(int i = 0;i < 10000;i++){
count++;
}
}
});
Thread t2 = new Thread(new Runnable(){
public void run(){
for(int i = 0;i < 10000;i++){
count++;
}
}
});
t1.start();
t2.start();
System.out.println("Count is: " + count);
}
}
At the time you're printing out your thread count, the threads have not finished executing yet.
To demonstrate, add a Thread.sleep() instruction before printing out the thread count:
public class App {
private int count = 0;
public static void main(String[] args) throws InterruptedException {
App app = new App();
app.doWork();
}
public void doWork() throws InterruptedException {
Thread t1 = new Thread(new Runnable() {
public void run() {
for (int i = 0; i < 10000; i++) {
count++;
}
}
});
Thread t2 = new Thread(new Runnable() {
public void run() {
for (int i = 0; i < 10000; i++) {
count++;
}
}
});
t1.start();
t2.start();
Thread.sleep(5000);
System.out.println("Count is: " + count); // Count is: 20000
}
}
Also note that operations on primitives are not thread-safe and that the count++ operation is not atomic. You should synchronize access to your count variable, or use an AtomicInteger or LongAdder instead of an int. As it stands, you might end up with a count anywhere between zero and 20,000.
Integer's increment is not safe to multithreading. You should use AtmoicInteger like this:
public class App {
private AtomicInteger count = new AtomicInteger(0);
public static void main(String[] args) throws InterruptedException {
App app = new App();
app.doWork();
}
public void doWork() throws InterruptedException {
Thread t1 = new Thread(new Runnable(){
public void run(){
for(int i = 0;i < 10000;i++){
count.getAndIncrement();
}
}
});
Thread t2 = new Thread(new Runnable(){
public void run(){
for(int i = 0;i < 10000;i++){
count.getAndIncrement();
}
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("Count is: " + count);
}
}
It is because you are printing count in main thread.
Main thread executed in its normal way , before child thread started.
That's why your count is 0 ,
try to print count after a while , like put Thread.sleep(2000) before printing it.
You need to make the code block which increments the count as synchronized in order to avoid the race condition.
In addition to this there are multiple ways to solve this problem-
1. Hard code Thread.sleep(miliseconds value) in Main thread. [Not recommended]
2. join() the two threads to the main Thread so that the control returns to the main thread only when the execution of the two threads is complete.
public class App implements Runnable {
private int count = 0;
public static void main(String[] args) throws InterruptedException {
App app = new App();
app.doWork();
}
public void doWork() throws InterruptedException {
Thread t1 = new Thread(this, "Thread - 1");
Thread t2 = new Thread(this, "Thread - 2");
t1.start();
t2.start();
//1.
t1.join();
t2.join();
//2.
//Thread.sleep(1000);
System.out.println("Count is: " + count); // Count is: 2000
}
#Override
public synchronized void run() {
for (int i = 0; i < 1000; i++) {
count++;
}
}
}
ERROR: local variable t is accessed from within inner class need to be declared final And local variable t1 is accessed from within the class.same with t1.start(); why do I need to declare them final?
public class sync {
public int count = 0;
public static void main(String args[]) {
sync obj = new sync();
obj.dowork();
sync obj1 = new sync();
obj1.dowork1();
System.out.println(count);
}
public void dowork() {
Thread t = new Thread(new Runnable() {
public void run() {
for (int i = 0; i < 1000; i++) {
count++;
}
t.start();
}
});
}
public void dowork1() {
Thread t1 = new Thread(new Runnable() {
public void run() {
for (int i = 0; i < 1000; i++) {
count++;
}
t1.start();
}
});
}
}
I did what you told me really helpful now it's just Showing: System.out.println("count"+count);
Identifier expected plus reach end of file while parsing
t and t1 objects are limited to scope of methods, make them member variables. Secondly, method calls and statements are called from inside a method..here t.start() & t1.start() are just floating loose inside class ... Same goes for print statement it
should also be called from inside a method.
Call to start method should be after the threads (t,t1) has been initialized. Currently they are used inside the initialization process.
It should be like this :
public void dowork(){
Thread t=new Thread (new Runnable (){
public void run(){
for (int i=0;i<1000;i++){
count++;}
}});
t.start();
}
Also count should be a static variable, as you cannot refer non-static variable from inside a static main method.
Your code be like, following think are corrected:
You make count variable static since it is been access with in static main method.
You trying to call Thread.start with in the run method which is wrong, since Thread.start method will call run method.
public class sync {
public static int count = 0;
public static void main(String args[]) {
sync obj = new sync();
obj.dowork();
sync obj1 = new sync();
obj1.dowork1();
System.out.println(count);
}
public void dowork() {
Thread t = new Thread(new Runnable() {
public void run() {
for (int i = 0; i < 1000; i++) {
count++;
}
}
});
t.start();
}
public void dowork1() {
Thread t1 = new Thread(new Runnable() {
public void run() {
for (int i = 0; i < 1000; i++) {
count++;
}
}
});
t1.start();
}
}
public class sync {
static int count = 0;
public static void main(String args[]) {
sync obj = new sync();
obj.dowork();
sync obj1 = new sync();
obj1.dowork1();
System.out.println(count);
}
public void dowork() {
Thread t = new Thread(new Runnable() {
public void run() {
for (int i = 0; i < 1000; i++) {
count++;
}
}
});
t.start();
}
public void dowork1() {
Thread t1 = new Thread(new Runnable() {
public void run() {
for (int i = 0; i < 1000; i++) {
count++;
}
}
});
t1.start();
}
}
I run below snippet and I got unexpected behaviour. Probably it is working in correct way, but I need to make it working in other way. Details below.
import java.util.ArrayList;
import java.util.List;
public class TaskExample {
public static void main(String[] args) throws InterruptedException {
final PositionHolder holder = new PositionHolder();
final List<Integer> data = new ArrayList<Integer>();
List<Thread> threads = new ArrayList<Thread>();
for (int i = 0; i < 20; i++) {
holder.setPosition(i);
Thread t = new Thread() {
#Override
public void run() {
data.add(holder.getPosition());
}
};
t.start();
threads.add(t);
}
for (Thread thread : threads) {
thread.join();
}
for(int i : data){
System.out.println(i);
}
}
}
class PositionHolder {
int position = 0;
public void setPosition(int position) {
this.position = position;
}
public int getPosition() {
return this.position;
}
}
And I got result:
10 12 9 8 6 6 5 4 2 1 16 16 18 19 19 19 19 19 19 19
Why? I'd like to get:
1 2 3 4 ...... 20
Is there any options to do imporve this snippet?
Try this code ;)
import java.util.ArrayList;
import java.util.List;
public class ogr
{
public static void main(String[] args) throws InterruptedException {
final PositionHolder holder = new PositionHolder();
final List<Integer> data = new ArrayList<Integer>();
for (int i = 0; i < 20; i++) {
holder.setPosition(i);
Thread t = new Thread() {
#Override
public void run() {
data.add(holder.getPosition());
}
};
t.start();
t.join();
}
for (int i : data) {
System.out.println(i);
}
}
}
class PositionHolder
{
int position = 0;
public void setPosition(int position) {
this.position = position;
}
public int getPosition() {
return this.position;
}
}
You cannot guarantee that the holder.getPosition() will get the same position values you set using holder.setPosition(i) as the getHolder call is part of a different thread and is called by multiple threads. This is because you are sharing the same PlaceHolder across all threads. If you want to get the output you desire, I would suggest using a different instance of PlaceHolder for each thread.
import java.util.ArrayList;
import java.util.List;
public class TaskExample {
public static void main(String[] args) throws InterruptedException {
final List<Integer> data = new ArrayList<Integer>();
List<Thread> threads = new ArrayList<Thread>();
for (int i = 0; i < 20; i++) {
// Create new instance
final PositionHolder holder = new PositionHolder(i);
Thread t = new Thread() {
#Override
public void run() {
data.add(holder.getPosition());
}
};
t.start();
threads.add(t);
for (Thread thread : threads) {
thread.join();
}
for(int i : data){
System.out.println(i);
}
}
class PositionHolder {
private int position = 0;
public PositionHolder(int position) {
this.position = position;
}
public int getPosition() {
return this.position;
}
}`
There is no way to guarantee execution order of the thread without synchronization mechanism like join() (see code proposed by Fincio).
You are getting the same number several times because you are using the same PositionHolder object for all your thread, therefore, the variable position get modified by every thread you started. Trying to do the same with an Object instead of an int would probably got you a ConcurrentAccessException. To avoid this, each thread should have its own PositionHolder instance (like in code provided by Saket). But even with that, there is no guarantee about the order in which thread will be executed.
programming using threads sometimes requires some tricks to make the threading efficient. Obviously it won't be as natural. for example check the following.
import java.util.ArrayList;
import java.util.List;
public class ogr{
public static void main(String[] args) throws InterruptedException {
ArrayList<PositionHolder> holders=new ArrayList<PositionHolder>();
final PositionHolder holder = new PositionHolder();
final List<Integer> data = new ArrayList<Integer>();
for (int i = 0; i < 20; i++) {
Thread t = new Thread() {
#Override
public void run() {
data.add(getSetPosition());
}
};
holders.add(holder)
t.start();
}
for (Thread thread : threads) {
thread.join();
}
SortByPosition(holders); //you can implement this easy by sorting arraylist by their positions
for (int i : data) {
System.out.println(i);
}
}
}
class PositionHolder{
static int staticPosition=0;
int position = 0;
public int synchronized getSetPosition() {
this.position = staticPosition++;
return position;
}
// public void setPosition(int position) {
// this.position = position;
// }
public int getPosition() {
return this.position;
}
}