I have multiple methods in a class and most of the methods are having critical sections(shared data). So I made those methods as synchronized. Say thread t1 is running one of the synchronized block . At the same time thread t2 can access the other methods critical section ?
class Sample{
synchronized public void method1(){
}
synchronized public void method2(){
}
synchronized public void method3(){
}
public void method4(){
}
}
synchronized is always locking on an object. In case of a synchronized method, the object is this
. So basically these two methods do the same:
synchronized public void method1() {
// do something
}
and
public void method1() {
synchronized(this){
// do something
}
}
As long as one thread has the lock on the lock object, no other thread can lock this object. So in your example, the synchronized methods (one, two and three) can never be executed at the same time. method4
is not synchronized, so it can access the object anytime.
If you want a more fine-grained locking, because method1
and method2
should be exclusive and method3
and method4
you could use for example something like this:
class Sample{
private final Object lock1 = new Object();
private final Object lock2 = new Object();
public void method1(){
synchronized(lock1) {
// do something
}
}
public void method2(){
synchronized(lock1) {
// do something
}
}
public void method3(){
synchronized(lock2) {
// do something
}
}
public void method4(){
synchronized(lock2) {
// do something
}
}
}
You can then even use the synchonized(lock)
method to just wrap the statements that need to be synchronized, not the whole method:
public void method() {
// some code
synchronized(lock) {
// code that must be synchronized
}
// some other code
}
With this approach you can keep the lock duration to a minimum.
It is not possible for two invocations of synchronized methods on the same object to interleave. When one thread is executing a synchronized method for an object, all other threads that invoke synchronized methods for the same object block (suspend execution) until the first thread is done with the object.
When a synchronized method exits, it automatically establishes a happens-before relationship with any subsequent invocation of a synchronized method for the same object. This guarantees that changes to the state of the object are visible to all threads
In the case
Sample sample1 = new Sample();
Multiple threads can't access
sample1.method1(),sample1.method2(),sample1.method3()
But Multiple threads can access concurrently
sample1.method4()
if we have 2 objects
Sample sample1 = new Sample();
Sample sample2 = new Sample();
Multiple threads can access cocurrently
sample1.method1(),sample2.method1() etc.
so the lock is at object level
The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.