The topic of this article is transferred from: https://www.cnblogs.com/oracleDBA/archive/2010/05/22/1741642.html
This paper mainly addresses the following three questions:
1. synchronzied effect
2. synchronzied syntax
3. Understanding of synchronized(this)
First, explain the synchronzied effect
The role of the Synchronzied keyword is summarized in one word: thread synchronization. It can be used to modify methods in an object and lock the object. It is equivalent to no matter which thread A runs to this method every time , it must check whether there is any other thread B (or CD , etc.) that is using this method, and if so, wait for thread B (or CD ) that is using this method. After running this method, run this thread A, if not , run it directly.
Then, talk about the synchronzied grammar
The Synchronzied keyword includes two usages: synchronized method and synchronized block.
1. synchronized 方法
如：public synchronized void accessVal(int newVal);
The synchronized method controls access to class member variables: each class instance corresponds to a lock, and each synchronized method must obtain the lock of the class instance that calls the method before it can be executed, otherwise the thread to which it belongs is blocked. The lock is not released until the method returns, after which the blocked thread can acquire the lock and re-enter the executable state. This mechanism ensures that for each class instance at the same time, at most one of its member functions declared as synchronized is in the executable state (because at most one can obtain the lock corresponding to the class instance), thus effectively avoiding class members Access violations for variables (as long as all methods that might access class member variables are declared synchronized ). In Java , not only a class instance, but also a lock for each class, so we can also declare the static member function of the class as synchronized to control its access to the static member variables of the class.
2. synchronized 块
The synchronized method locks the entire method. Declaring a large method as synchronized will greatly affect efficiency. Typically, if the method run() of a thread class is declared as synchronized , since it runs for the entire life of the thread, it will cause it to affect the class. Invocation of any synchronized method will never succeed. Of course, we can solve this problem by placing the code that accesses the class member variables in a special method, declaring it as synchronized , and calling it in the main method, but Java provides us with a better solution, that is synchronized block.
如：synchronized(syncObject) {
// code to allow access control
}
A synchronized block is a block of code in which the code must acquire the lock of the object syncObject (as mentioned earlier, it can be a class instance or a class) before it can be executed. The specific mechanism is the same as mentioned earlier. Since it can target any code block and can arbitrarily specify the locked object, it has high flexibility.
Finally, talk about synchronzied(this) . The following examples are very clear, and only through demos can we understand the knowledge points more thoroughly. It is recommended to run it in the IDE and experience it yourself.
这里先说一下this这个指向问题，我们经常说this指向的是当前对象，可是相信有很多朋友迷惑当前对象到底是谁，小编也有过相同的疑惑，曾经任务当前对象是所在的类。其实不然，一下面的代码为例,其实this指向的就是这个t1，Thread t1=new Thread();在下面的ta和tb中，尽管两个线程的地址不一样，也是两个线程，但是他们持有的线程对象都是t1，这样是为了同步代码块。用一个比较经典的总结就是：钥匙在给代码加锁的那个线程手里，钥匙就是this，这里指向t1.
一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
package ths;
public class Thread1 implements Runnable {
public void run() {
synchronized(this) {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);
}
}
}
public static void main(String[] args) {
Thread1 t1 = new Thread1();
Thread ta = new Thread(t1, "A");
Thread tb = new Thread(t1, "B");
ta.start();
tb.start();
}
}
结果：
A synchronized loop 0 A synchronized loop 1 A synchronized loop 2 A synchronized loop 3 A synchronized loop 4 B synchronized loop 0 B synchronized loop 1 B synchronized loop 2 B synchronized loop 3 B synchronized loop 4
二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
package ths;
public class Thread2 {
public void m4t1() {
synchronized(this) {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
}
public void m4t2() {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
public static void main(String[] args) {
final Thread2 myt2 = new Thread2();
Thread t1 = new Thread(
new Runnable() {
public void run() {
myt2.m4t1();
}
}, "t1"
);
Thread t2 = new Thread(
new Runnable() {
public void run() {
myt2.m4t2();
}
}, "t2"
);
t1.start();
t2.start();
}
}
结果：
t1 : 4 t2 : 4 t1 : 3 t2 : 3 t1 : 2 t2 : 2 t1 : 1 t2 : 1 t1 : 0 t2 : 0
三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
//修改Thread2.m4t2()方法：
public void m4t2() {
synchronized(this) {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
}
结果：
t1 : 4 t1 : 3 t1 : 2 t1 : 1 t1 : 0 t2 : 4 t2 : 3 t2 : 2 t2 : 1 t2 : 0
四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
//修改Thread2.m4t2()方法如下：
public synchronized void m4t2() {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
结果：
t1 : 4 t1 : 3 t1 : 2 t1 : 1 t1 : 0 t2 : 4 t2 : 3 t2 : 2 t2 : 1 t2 : 0
五、以上规则对其它对象锁同样适用:
package ths;
public class Thread3 {
class Inner {
private void m4t1() {
int i = 5;
while(i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : Inner.m4t1()=" + i);
try {
Thread.sleep(500);
} catch(InterruptedException ie) {
}
}
}
private void m4t2() {
int i = 5;
while(i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);
try {
Thread.sleep(500);
} catch(InterruptedException ie) {
}
}
}
}
private void m4t1(Inner inner) {
synchronized(inner) { //使用对象锁
inner.m4t1();
}
}
private void m4t2(Inner inner) {
inner.m4t2();
}
public static void main(String[] args) {
final Thread3 myt3 = new Thread3();
final Inner inner = myt3.new Inner();
Thread t1 = new Thread(
new Runnable() {
public void run() {
myt3.m4t1(inner);
}
}, "t1"
);
Thread t2 = new Thread(
new Runnable() {
public void run() {
myt3.m4t2(inner);
}
}, "t2"
);
t1.start();
t2.start();
}
}
结果：
尽管线程t1获得了对Inner的对象锁，但由于线程t2访问的是同一个Inner中的非同步部分。所以两个线程互不干扰。
t1 : Inner.m4t1()=4 t2 : Inner.m4t2()=4 t1 : Inner.m4t1()=3 t2 : Inner.m4t2()=3 t1 : Inner.m4t1()=2 t2 : Inner.m4t2()=2 t1 : Inner.m4t1()=1 t2 : Inner.m4t2()=1 t1 : Inner.m4t1()=0 t2 : Inner.m4t2()=0
现在在Inner.m4t2()前面加上synchronized：
private synchronized void m4t2() {
int i = 5;
while(i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);
try {
Thread.sleep(500);
} catch(InterruptedException ie) {
}
}
}
结果：
尽管线程t1与t2访问了同一个Inner对象中两个毫不相关的部分,但因为t1先获得了对Inner的对象锁，所以t2对Inner.m4t2()的访问也被阻塞，因为m4t2()是Inner中的一个同步方法。
t1 : Inner.m4t1()=4 t1 : Inner.m4t1()=3 t1 : Inner.m4t1()=2 t1 : Inner.m4t1()=1 t1 : Inner.m4t1()=0 t2 : Inner.m4t2()=4 t2 : Inner.m4t2()=3 t2 : Inner.m4t2()=2 t2 : Inner.m4t2()=1 t2 : Inner.m4t2()=0