synchronized block in Multithreading

Question

I have a method that calls 2 synchronize block of the method and the code is provided,

    private static int count1 = 0;
    private static int count2 = 0;

    public synchronized static void add() {
    count1++;
    System.out.println("T name: " + Thread.currentThread().getName()
    + "count1 = " + count1);
}

public synchronized static void addAgain() {
    count2++;
    System.out.println("T name: " + Thread.currentThread().getName()
            + "count1 = " + count2);
}

    public static void compute() {
        for(int i=0;i<100;++i) {
            add();
            addAgain();
        }
    }

Here we define 2 threads and call the compute method from each of them. The code snippet is provided below,

        Thread t1 = new Thread(() -> compute());
        Thread t2 = new Thread(() -> compute());

        t1.start();
        t2.start();

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

With the code provided, I have three questions:

When a thread calls the compute method, does it get access to both of the synchronized methods inside and execute the increment operation?
If a thread gets access to the for loop, does it complete the for loop or leave it before the competition to share with the other thread?
If its the case, I assume the other thread is in the wait phase and don't do much. Is this correct?

For matter of discussion, this the result I get after the run:

    Thread name: Thread-0  count1 value = 1
Thread name: Thread-1  count1 value = 2
Thread name: Thread-1 count2 value = 1
Thread name: Thread-1  count1 value = 3
Thread name: Thread-1 count2 value = 2
Thread name: Thread-1  count1 value = 4
Thread name: Thread-1 count2 value = 3
Thread name: Thread-1  count1 value = 5
Thread name: Thread-1 count2 value = 4
Thread name: Thread-1  count1 value = 6
Thread name: Thread-1 count2 value = 5
Thread name: Thread-1  count1 value = 7
Thread name: Thread-1 count2 value = 6
Thread name: Thread-1  count1 value = 8
Thread name: Thread-1 count2 value = 7
Thread name: Thread-1  count1 value = 9
Thread name: Thread-1 count2 value = 8
Thread name: Thread-1  count1 value = 10
Thread name: Thread-1 count2 value = 9
Thread name: Thread-1  count1 value = 11
Thread name: Thread-1 count2 value = 10
Thread name: Thread-1  count1 value = 12
Thread name: Thread-1 count2 value = 11
Thread name: Thread-1  count1 value = 13
Thread name: Thread-1 count2 value = 12
Thread name: Thread-1  count1 value = 14
Thread name: Thread-1 count2 value = 13
Thread name: Thread-1  count1 value = 15
Thread name: Thread-1 count2 value = 14
Thread name: Thread-1  count1 value = 16
Thread name: Thread-1 count2 value = 15
Thread name: Thread-1  count1 value = 17
Thread name: Thread-1 count2 value = 16
Thread name: Thread-1  count1 value = 18
Thread name: Thread-1 count2 value = 17
Thread name: Thread-1  count1 value = 19
Thread name: Thread-1 count2 value = 18
Thread name: Thread-1  count1 value = 20
Thread name: Thread-0 count2 value = 19
Thread name: Thread-0  count1 value = 21
Thread name: Thread-0 count2 value = 20
Thread name: Thread-0  count1 value = 22
Thread name: Thread-0 count2 value = 21
Thread name: Thread-0  count1 value = 23
Thread name: Thread-0 count2 value = 22
Thread name: Thread-0  count1 value = 24
Thread name: Thread-0 count2 value = 23
Thread name: Thread-0  count1 value = 25
Thread name: Thread-0 count2 value = 24
Thread name: Thread-0  count1 value = 26
Thread name: Thread-0 count2 value = 25
Thread name: Thread-0  count1 value = 27
Thread name: Thread-0 count2 value = 26
Thread name: Thread-0  count1 value = 28
Thread name: Thread-0 count2 value = 27
Thread name: Thread-0  count1 value = 29
Thread name: Thread-0 count2 value = 28
Thread name: Thread-0  count1 value = 30
Thread name: Thread-0 count2 value = 29
Thread name: Thread-0  count1 value = 31
Thread name: Thread-0 count2 value = 30
Thread name: Thread-0  count1 value = 32
Thread name: Thread-0 count2 value = 31
Thread name: Thread-0  count1 value = 33
Thread name: Thread-0 count2 value = 32
Thread name: Thread-0  count1 value = 34
Thread name: Thread-0 count2 value = 33
Thread name: Thread-0  count1 value = 35
Thread name: Thread-0 count2 value = 34
Thread name: Thread-0  count1 value = 36
Thread name: Thread-0 count2 value = 35
Thread name: Thread-0  count1 value = 37
Thread name: Thread-0 count2 value = 36
Thread name: Thread-0  count1 value = 38
Thread name: Thread-0 count2 value = 37
Thread name: Thread-0  count1 value = 39
Thread name: Thread-0 count2 value = 38
Thread name: Thread-0  count1 value = 40
Thread name: Thread-0 count2 value = 39
Thread name: Thread-0  count1 value = 41
Thread name: Thread-0 count2 value = 40
Thread name: Thread-0  count1 value = 42
Thread name: Thread-0 count2 value = 41
Thread name: Thread-0  count1 value = 43
Thread name: Thread-0 count2 value = 42
Thread name: Thread-0  count1 value = 44
Thread name: Thread-0 count2 value = 43
Thread name: Thread-0  count1 value = 45
Thread name: Thread-0 count2 value = 44
Thread name: Thread-0  count1 value = 46
Thread name: Thread-0 count2 value = 45
Thread name: Thread-0  count1 value = 47
Thread name: Thread-0 count2 value = 46
Thread name: Thread-0  count1 value = 48
Thread name: Thread-0 count2 value = 47
Thread name: Thread-0  count1 value = 49
Thread name: Thread-0 count2 value = 48
Thread name: Thread-0  count1 value = 50
Thread name: Thread-0 count2 value = 49
Thread name: Thread-0  count1 value = 51
Thread name: Thread-0 count2 value = 50
Thread name: Thread-0  count1 value = 52
Thread name: Thread-0 count2 value = 51
Thread name: Thread-0  count1 value = 53
Thread name: Thread-0 count2 value = 52
Thread name: Thread-0  count1 value = 54
Thread name: Thread-0 count2 value = 53
Thread name: Thread-0  count1 value = 55
Thread name: Thread-0 count2 value = 54
Thread name: Thread-0  count1 value = 56
Thread name: Thread-0 count2 value = 55
Thread name: Thread-0  count1 value = 57
Thread name: Thread-0 count2 value = 56
Thread name: Thread-0  count1 value = 58
Thread name: Thread-0 count2 value = 57
Thread name: Thread-0  count1 value = 59
Thread name: Thread-0 count2 value = 58
Thread name: Thread-0  count1 value = 60
Thread name: Thread-0 count2 value = 59
Thread name: Thread-0  count1 value = 61
Thread name: Thread-0 count2 value = 60
Thread name: Thread-0  count1 value = 62
Thread name: Thread-0 count2 value = 61
Thread name: Thread-0  count1 value = 63
Thread name: Thread-0 count2 value = 62
Thread name: Thread-0  count1 value = 64
Thread name: Thread-0 count2 value = 63
Thread name: Thread-0  count1 value = 65
Thread name: Thread-0 count2 value = 64
Thread name: Thread-0  count1 value = 66
Thread name: Thread-0 count2 value = 65
Thread name: Thread-0  count1 value = 67
Thread name: Thread-0 count2 value = 66
Thread name: Thread-0  count1 value = 68
Thread name: Thread-0 count2 value = 67
Thread name: Thread-0  count1 value = 69
Thread name: Thread-0 count2 value = 68
Thread name: Thread-0  count1 value = 70
Thread name: Thread-0 count2 value = 69
Thread name: Thread-0  count1 value = 71
Thread name: Thread-0 count2 value = 70
Thread name: Thread-0  count1 value = 72
Thread name: Thread-0 count2 value = 71
Thread name: Thread-0  count1 value = 73
Thread name: Thread-0 count2 value = 72
Thread name: Thread-0  count1 value = 74
Thread name: Thread-0 count2 value = 73
Thread name: Thread-0  count1 value = 75
Thread name: Thread-0 count2 value = 74
Thread name: Thread-0  count1 value = 76
Thread name: Thread-0 count2 value = 75
Thread name: Thread-0  count1 value = 77
Thread name: Thread-0 count2 value = 76
Thread name: Thread-0  count1 value = 78
Thread name: Thread-0 count2 value = 77
Thread name: Thread-0  count1 value = 79
Thread name: Thread-0 count2 value = 78
Thread name: Thread-0  count1 value = 80
Thread name: Thread-0 count2 value = 79
Thread name: Thread-0  count1 value = 81
Thread name: Thread-0 count2 value = 80
Thread name: Thread-0  count1 value = 82
Thread name: Thread-0 count2 value = 81
Thread name: Thread-0  count1 value = 83
Thread name: Thread-0 count2 value = 82
Thread name: Thread-0  count1 value = 84
Thread name: Thread-0 count2 value = 83
Thread name: Thread-0  count1 value = 85
Thread name: Thread-0 count2 value = 84
Thread name: Thread-0  count1 value = 86
Thread name: Thread-0 count2 value = 85
Thread name: Thread-0  count1 value = 87
Thread name: Thread-0 count2 value = 86
Thread name: Thread-0  count1 value = 88
Thread name: Thread-0 count2 value = 87
Thread name: Thread-0  count1 value = 89
Thread name: Thread-0 count2 value = 88
Thread name: Thread-0  count1 value = 90
Thread name: Thread-0 count2 value = 89
Thread name: Thread-0  count1 value = 91
Thread name: Thread-0 count2 value = 90
Thread name: Thread-0  count1 value = 92
Thread name: Thread-0 count2 value = 91
Thread name: Thread-0  count1 value = 93
Thread name: Thread-0 count2 value = 92
Thread name: Thread-0  count1 value = 94
Thread name: Thread-0 count2 value = 93
Thread name: Thread-0  count1 value = 95
Thread name: Thread-0 count2 value = 94
Thread name: Thread-0  count1 value = 96
Thread name: Thread-0 count2 value = 95
Thread name: Thread-0  count1 value = 97
Thread name: Thread-0 count2 value = 96
Thread name: Thread-0  count1 value = 98
Thread name: Thread-0 count2 value = 97
Thread name: Thread-0  count1 value = 99
Thread name: Thread-0 count2 value = 98
Thread name: Thread-0  count1 value = 100
Thread name: Thread-0 count2 value = 99
Thread name: Thread-0  count1 value = 101
Thread name: Thread-0 count2 value = 100
Thread name: Thread-0  count1 value = 102
Thread name: Thread-0 count2 value = 101
Thread name: Thread-0  count1 value = 103
Thread name: Thread-0 count2 value = 102
Thread name: Thread-0  count1 value = 104
Thread name: Thread-0 count2 value = 103
Thread name: Thread-0  count1 value = 105
Thread name: Thread-0 count2 value = 104
Thread name: Thread-0  count1 value = 106
Thread name: Thread-0 count2 value = 105
Thread name: Thread-0  count1 value = 107
Thread name: Thread-0 count2 value = 106
Thread name: Thread-0  count1 value = 108
Thread name: Thread-0 count2 value = 107
Thread name: Thread-0  count1 value = 109
Thread name: Thread-0 count2 value = 108
Thread name: Thread-0  count1 value = 110
Thread name: Thread-0 count2 value = 109
Thread name: Thread-0  count1 value = 111
Thread name: Thread-0 count2 value = 110
Thread name: Thread-0  count1 value = 112
Thread name: Thread-0 count2 value = 111
Thread name: Thread-0  count1 value = 113
Thread name: Thread-0 count2 value = 112
Thread name: Thread-0  count1 value = 114
Thread name: Thread-0 count2 value = 113
Thread name: Thread-0  count1 value = 115
Thread name: Thread-0 count2 value = 114
Thread name: Thread-0  count1 value = 116
Thread name: Thread-0 count2 value = 115
Thread name: Thread-0  count1 value = 117
Thread name: Thread-0 count2 value = 116
Thread name: Thread-0  count1 value = 118
Thread name: Thread-0 count2 value = 117
Thread name: Thread-0  count1 value = 119
Thread name: Thread-0 count2 value = 118
Thread name: Thread-1 count2 value = 119
Thread name: Thread-1  count1 value = 120
Thread name: Thread-1 count2 value = 120
Thread name: Thread-1  count1 value = 121
Thread name: Thread-1 count2 value = 121
Thread name: Thread-1  count1 value = 122
Thread name: Thread-1 count2 value = 122
Thread name: Thread-1  count1 value = 123
Thread name: Thread-1 count2 value = 123
Thread name: Thread-1  count1 value = 124
Thread name: Thread-1 count2 value = 124
Thread name: Thread-1  count1 value = 125
Thread name: Thread-1 count2 value = 125
Thread name: Thread-1  count1 value = 126
Thread name: Thread-1 count2 value = 126
Thread name: Thread-1  count1 value = 127
Thread name: Thread-1 count2 value = 127
Thread name: Thread-1  count1 value = 128
Thread name: Thread-1 count2 value = 128
Thread name: Thread-1  count1 value = 129
Thread name: Thread-1 count2 value = 129
Thread name: Thread-1  count1 value = 130
Thread name: Thread-1 count2 value = 130
Thread name: Thread-1  count1 value = 131
Thread name: Thread-1 count2 value = 131
Thread name: Thread-1  count1 value = 132
Thread name: Thread-1 count2 value = 132
Thread name: Thread-1  count1 value = 133
Thread name: Thread-1 count2 value = 133
Thread name: Thread-1  count1 value = 134
Thread name: Thread-1 count2 value = 134
Thread name: Thread-1  count1 value = 135
Thread name: Thread-1 count2 value = 135
Thread name: Thread-1  count1 value = 136
Thread name: Thread-1 count2 value = 136
Thread name: Thread-1  count1 value = 137
Thread name: Thread-1 count2 value = 137
Thread name: Thread-1  count1 value = 138
Thread name: Thread-1 count2 value = 138
Thread name: Thread-1  count1 value = 139
Thread name: Thread-1 count2 value = 139
Thread name: Thread-1  count1 value = 140
Thread name: Thread-1 count2 value = 140
Thread name: Thread-1  count1 value = 141
Thread name: Thread-1 count2 value = 141
Thread name: Thread-1  count1 value = 142
Thread name: Thread-1 count2 value = 142
Thread name: Thread-1  count1 value = 143
Thread name: Thread-1 count2 value = 143
Thread name: Thread-1  count1 value = 144
Thread name: Thread-1 count2 value = 144
Thread name: Thread-1  count1 value = 145
Thread name: Thread-1 count2 value = 145
Thread name: Thread-1  count1 value = 146
Thread name: Thread-1 count2 value = 146
Thread name: Thread-1  count1 value = 147
Thread name: Thread-1 count2 value = 147
Thread name: Thread-1  count1 value = 148
Thread name: Thread-1 count2 value = 148
Thread name: Thread-1  count1 value = 149
Thread name: Thread-1 count2 value = 149
Thread name: Thread-1  count1 value = 150
Thread name: Thread-1 count2 value = 150
Thread name: Thread-1  count1 value = 151
Thread name: Thread-1 count2 value = 151
Thread name: Thread-1  count1 value = 152
Thread name: Thread-1 count2 value = 152
Thread name: Thread-1  count1 value = 153
Thread name: Thread-1 count2 value = 153
Thread name: Thread-1  count1 value = 154
Thread name: Thread-1 count2 value = 154
Thread name: Thread-1  count1 value = 155
Thread name: Thread-1 count2 value = 155
Thread name: Thread-1  count1 value = 156
Thread name: Thread-1 count2 value = 156
Thread name: Thread-1  count1 value = 157
Thread name: Thread-1 count2 value = 157
Thread name: Thread-1  count1 value = 158
Thread name: Thread-1 count2 value = 158
Thread name: Thread-1  count1 value = 159
Thread name: Thread-1 count2 value = 159
Thread name: Thread-1  count1 value = 160
Thread name: Thread-1 count2 value = 160
Thread name: Thread-1  count1 value = 161
Thread name: Thread-1 count2 value = 161
Thread name: Thread-1  count1 value = 162
Thread name: Thread-1 count2 value = 162
Thread name: Thread-1  count1 value = 163
Thread name: Thread-1 count2 value = 163
Thread name: Thread-1  count1 value = 164
Thread name: Thread-1 count2 value = 164
Thread name: Thread-1  count1 value = 165
Thread name: Thread-1 count2 value = 165
Thread name: Thread-1  count1 value = 166
Thread name: Thread-1 count2 value = 166
Thread name: Thread-1  count1 value = 167
Thread name: Thread-1 count2 value = 167
Thread name: Thread-1  count1 value = 168
Thread name: Thread-1 count2 value = 168
Thread name: Thread-1  count1 value = 169
Thread name: Thread-1 count2 value = 169
Thread name: Thread-1  count1 value = 170
Thread name: Thread-1 count2 value = 170
Thread name: Thread-1  count1 value = 171
Thread name: Thread-1 count2 value = 171
Thread name: Thread-1  count1 value = 172
Thread name: Thread-1 count2 value = 172
Thread name: Thread-1  count1 value = 173
Thread name: Thread-1 count2 value = 173
Thread name: Thread-1  count1 value = 174
Thread name: Thread-1 count2 value = 174
Thread name: Thread-1  count1 value = 175
Thread name: Thread-1 count2 value = 175
Thread name: Thread-1  count1 value = 176
Thread name: Thread-1 count2 value = 176
Thread name: Thread-1  count1 value = 177
Thread name: Thread-1 count2 value = 177
Thread name: Thread-1  count1 value = 178
Thread name: Thread-1 count2 value = 178
Thread name: Thread-1  count1 value = 179
Thread name: Thread-1 count2 value = 179
Thread name: Thread-1  count1 value = 180
Thread name: Thread-1 count2 value = 180
Thread name: Thread-1  count1 value = 181
Thread name: Thread-1 count2 value = 181
Thread name: Thread-1  count1 value = 182
Thread name: Thread-1 count2 value = 182
Thread name: Thread-1  count1 value = 183
Thread name: Thread-1 count2 value = 183
Thread name: Thread-1  count1 value = 184
Thread name: Thread-1 count2 value = 184
Thread name: Thread-1  count1 value = 185
Thread name: Thread-1 count2 value = 185
Thread name: Thread-1  count1 value = 186
Thread name: Thread-1 count2 value = 186
Thread name: Thread-1  count1 value = 187
Thread name: Thread-1 count2 value = 187
Thread name: Thread-1  count1 value = 188
Thread name: Thread-1 count2 value = 188
Thread name: Thread-1  count1 value = 189
Thread name: Thread-1 count2 value = 189
Thread name: Thread-1  count1 value = 190
Thread name: Thread-1 count2 value = 190
Thread name: Thread-1  count1 value = 191
Thread name: Thread-1 count2 value = 191
Thread name: Thread-1  count1 value = 192
Thread name: Thread-1 count2 value = 192
Thread name: Thread-1  count1 value = 193
Thread name: Thread-1 count2 value = 193
Thread name: Thread-1  count1 value = 194
Thread name: Thread-1 count2 value = 194
Thread name: Thread-1  count1 value = 195
Thread name: Thread-1 count2 value = 195
Thread name: Thread-1  count1 value = 196
Thread name: Thread-1 count2 value = 196
Thread name: Thread-1  count1 value = 197
Thread name: Thread-1 count2 value = 197
Thread name: Thread-1  count1 value = 198
Thread name: Thread-1 count2 value = 198
Thread name: Thread-1  count1 value = 199
Thread name: Thread-1 count2 value = 199
Thread name: Thread-1  count1 value = 200
Thread name: Thread-1 count2 value = 200
Count1=200  Count2=200

So, when a thread does get the access, it holds both of the synchronized methods to it. The counter values are updated and be remmembered when the contrils switches from one thrad to another.

As this is such a tight loop I would imagine that the `first` thread would have finished by the time the second thread has started — Scary Wombat, Mar 16 '18 at 08:35
Essentially the synchronized method call will grab the objects monitor on each call. So there *could* be a switch between add and addAgain. 1. no; 2 there is no 'access to the for loop'; 3. One thread will wait to enter a synchronized block until it can enter. — matt, Mar 16 '18 at 08:41
The conclusion you are drawing from your update just now is simply wrong. The JVM decided to give your threads a certain amount if time, in that time they: Go in the `add` method, do a `++` go out again, go in the `addAgain` method and do a `++` there. Maybe. Maybe the JIT even optimized it, made a synchronized block around both calls and just removed the method overhead. You can't know. Which is exactly what people are trying to get at. — Ben, Mar 16 '18 at 08:49
You can run your code again. Run it twice. Run it three hundred times. Every time the output will be different. Maybe slightly, maybe dramatically. Make your method a bit more complex: The output will change more dramatically. Maybe add a short sleep in the synchronized method. Run it 20 times. See what happens... I guarantee you that you will probably not get the same result twice. — Ben, Mar 16 '18 at 08:51
@Arefe see [Synchronization and System.out.println](https://stackoverflow.com/questions/9459657/synchronization-and-system-out-println) — Scary Wombat, Mar 16 '18 at 08:57

Ben · Accepted Answer · 2018-03-16T09:06:06.253

3

What will happen is that both threads call the compute() method, go in the for loop and end up at the first call of add().

One of the two will be there before the other so he will enter the synchronized method. While he is in the method the second thread might arrive at the add() call. It's a might as you can't say which thread is where at what point in time. It's undefined the JVM decides which threads can do operations at what time. But let's assume that the second thread arrives at the add() call and now wants to execute the method. It can't do so as it's synchronized and another thread is already calling it currently. So the thread goes to a waiting state. The first thread finishes his call of add(). Now the second thread might enter the add(), do the call, get back out of the add() and enter the addAgain(). This now leaves the first thread waiting.

This might sound confusing and that's exactly what I am trying to get at:

You can not say which thread calls what method when. The JVM might decide to let your first thread do the 100 calls of both methods first and then the second thread gets to do the same. It might decide that they call them alternating. The reality will probably be somewhere in between. One of the two threads might not even enter the compute() method before the other is even done initializing. You can't tell. It all depends on your system, the amounts of processors, code and cpu optimization that happens, which algorithm scheduler is in use and so on.

As soon as you do multithreading it's out of your hands when what happens. By calling join you can wait for the task to finish. But there is no deterministic way to guarantee that this will be the case in 1ms, 2ms or 250ms.

So your questions:

When a thread calls the compute method, does it get access to both of the synchronized methods inside and execute the increment operation?

No it does not. By calling add it gets access to this method. It doesn't automatically get access to the second method.

If a thread gets access to the for loop, does it complete the for loop or leave it before the competition to share with the other thread?

You can not say. It is neither guaranteed to complete the loop nor to be interrupted before completion.

If its the case, I assume the other thread is in the wait phase and don't do much. Is this correct?

A thread will be in a waiting state if it tries to access a synchronized method while it's already accessed by another thread.

edited Mar 16 '18 at 09:06

answered Mar 16 '18 at 08:40

Ben

1,665
1
11
22

@MarkRotteveelt thanks for the heads up. Yes, obviously I wanted to say "no deterministic way". – Ben Mar 16 '18 at 08:45
@Ben the answer is enlighting. Is it possible that the thread 1 doing increment with the `add` method while at the same time the thread 2 doing the increment with the `addAgain` method? The conclusion I try to draw Is not correct and I agree with you – Arefe Mar 16 '18 at 08:58
@Ben while I don't need much of multithreading and parallel computing stuff for the work, these topics are interesting. I will keep on learning :) – Arefe Mar 16 '18 at 09:03
It's a good topic to pick up as you will certainly get to the point where you need to work with it. And it's a tough nut to crack and makes debugging a pain in the arse at times so starting early is a good idea. Good luck with it :) – Ben Mar 16 '18 at 09:04
2

@Arefe No, as both methods are static and synchronized, it is not possible for thread 1 to be active in `add` and thread 2 active in `addAgain` at the same time. One or the other will be be blocked waiting for the monitor lock. – Mark Rotteveel Mar 16 '18 at 09:48
@MarkRotteveel This is good to know. `a.` So, in the case of `static` `synchronized` methods, only one thread will execute one of the synchronized at any time and the other thread will be in the wait phase. Is this correct? `b.` is it possible for the same thread to access and work with both of the `synchronized` methods at the same time? – Arefe Mar 16 '18 at 09:53
1

@MarkRotteveel you are right. I totally forgot about that in Java static synchronized methods are using the class lock not the method lock! My bad for giving wrong advice. – Ben Mar 16 '18 at 09:53
@Ben I assume you would be correct if this is not the case of the `static` method? – Arefe Mar 16 '18 at 09:54
1

@Arefe exactly. A static method uses a lock associated with the class. A non-static method uses a lock associated with the method itself. – Ben Mar 16 '18 at 09:55
1

You can work around that by creating the locks yourself (e.g. by `final Object myLock = new Object();`and wrapping the whole method body in a `synchronized(myLock)`). If you use different locks for different methods you can access them at the same time. – Ben Mar 16 '18 at 09:56
@Ben can one thread that get the lock to the class execute both of the `synchronized` methods at the same time? – Arefe Mar 16 '18 at 09:56
1

Assuming no optimization happens, no. If the JIT optimizes the methods into a single one (as that's theoretically possible) it could happen, yes. But we are moving too far away from the original questions (as StackOverflow just told me) by discussing in the comments. – Ben Mar 16 '18 at 09:58
@Ben I think I understand what do you mean by this "You can work around that by creating the locks yourself `synchronized(myLock){ // method body goes inside}`". You may also elaborate the answer too if you get time. – Arefe Mar 16 '18 at 09:59
2

@Ben No, a non-static method with synchronized locks on the instance (the object, not the method). – Mark Rotteveel Mar 16 '18 at 10:15
Good job. Keep it up. – Ravindra babu Mar 18 '18 at 18:11

synchronized block in Multithreading

1 Answers1