Java中synchronized关键字的使用

时间:2021-05-25 18:30:37

Java中synchronized关键字的使用

对于关键字synchronized,研究起来,发现还是有许多让自己模糊的地方,网上也有很多篇博客对synchronized关键字的使用讲解的相当好,自己也受益匪浅。自己之所以还写一篇博客来介绍synchronized的目的只有一个:加深自己对synchronized的理解。

写博客有时候确实是一个好的东西,往往研究某个知识点的时候,自己觉得弄懂了,但是过几天查不多就忘了模糊了,而写博客可以增加对知识点的理解和加深知识的记忆。

synchronized关键字是解决多线程并发同步的方法之一。

synchronized可以修饰如下几个方面。

1、修饰一个代码块,作用的对象是调用这个代码块的对象

2、修饰一个方法,作用的对象是调用这个方法的对象

3、修饰一个静态方法,作用的对象是静态方法所属的类的所有对象

4、修饰一个类,作用的对象是该类的所用对象。

下面一一进行介绍

1、synchronized修饰一个代码块

1.1 一个线程访问一个对象obj中的synchronize(this)同步代码块时,其它线程试图访问该对象obj的synchronize(this)同步块时将会被阻塞。

看下面这个例子

Demo1

    class MyThread implements Runnable{
private static final int NUM = 3;
@Override
public void run() {
synchronized(this){
for(int i =0;i<NUM;i++){
System.out.println(Thread.currentThread().getName()+" running .....");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}
}

}

测试代码如下:

    public class SyncCodeBlock {

public static void main(String[] args) {
MyThread mt = new MyThread();
new Thread(mt,"Thread1").start();
new Thread(mt,"Thread2").start();
}

}

运行结果:

Thread2  running .....
Thread2 running .....
Thread2 running .....
Thread1 running .....
Thread1 running .....
Thread1 running .....

这里,名字为Thread1、Thread2的两个线程都想访问对象mt的同步块synchronized(this),由于只有一个锁,谁拿到的这个锁就该谁访问,也就是说,在任一时刻只能有一个线程访问这一同步代码块。例如,当Thread1线程拿到锁正在执行run里面的代码时,名字为Thread2的线程也想访问同一对象mt的同步块synchroized(this)的同步块将会被阻塞,只有等Thread1访问结束之后释放该对象锁Thread2拿到该对象锁才能访问。

如果我们将测试代码该为如下:

    public static void main(String[] args){
MyThread mt = new MyThread();
MyThread mt2 = new MyThread();
new Thread(mt,"Thread1").start();
new Thread(mt2,"Thread2").start();
}

结果如下:

Thread2  running .....
Thread1 running .....
Thread2 running .....
Thread1 running .....
Thread2 running .....
Thread1 running .....

这里,和上面的第一种测试代码不同,这里有两个不同的MyThread对象,分别对应着两把锁,因此线程Thread1访问同步块是去拿对象mt的锁,而线程Thread2访问同步块是去拿对象mt2的锁,而这两个锁是没有任何关系的,即线程Thread1执行的是对象mt的中的synchronized代码块,而线程Thread2执行的是对象mt2中的synchronized代码块,两者互不相关,因此这两个线程就可以同时进行。

小结:当一个线程访问一个对象obj中的synchronized(this)同步块时,其它线程访问这个对象obj的synchronize(this)就会阻塞

1.2 当一个线程访问一个对象obj中的synchronized(this)同步代码块时,其它的线程可以同时访问该对象obj中的非synchronize(this)代码块

看一个例子

Demo2:多个线程访问synchronized和非synchronized代码块

    class MyThread implements Runnable{
private static final int NUM = 3;
@Override
public void run() {
String name = Thread.currentThread().getName();
if(name.equals("Thread1")){
synMethod();
}
else if(name.equals("Thread2")){
notSynMethod();
}
}
public void synMethod(){
synchronized(this){
for(int i=0;i<NUM;i++){
System.out.println(Thread.currentThread().getName()+"running ....");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public void notSynMethod(){
for(int i=0;i<NUM;i++){
System.out.println(Thread.currentThread().getName()+"running ....");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

}

测试代码:


public static void main(String[] args) {
MyThread mt = new MyThread();
new Thread(mt,"Thread1").start();
new Thread(mt,"Thread2").start();
}

运行结果:

Thread1 running ....
Thread2 running ....
Thread1 running ....
Thread2 running ....
Thread1 running ....
Thread2 running ....

分析:

上面的代码中,有一个使用synchronize(this)同步的方法synMethod,有一个没有使用关键字synchronize(this)同步的方法notSynMethod.

由于线程Thread1和Thread2没有同时访问对象mt的synchronized(this)同步代码块,而是只有Thread1访问,Thread2访问的是对象mt非synchronized(this)代码块。因此这两个线程是可以同时进行的。

注意:这里的“访问对象mt的非synchronized(this)代码块”并不是单单指对象mt中没有用关键字synchronized修饰的代码块,而是还包括对象mt中其它使用类似synchronized(otherRef)修饰的代码块,其中otherRef为不等于this的其它引用对象。

看下面的例子,将上例Demo2中的notSynMethod方法用synchronized(otherRefe)来同步

    private int [] value = new int[0];
public void notSynMethod(){
synchronized(value){
for(int i=0;i<NUM;i++){
System.out.println(Thread.currentThread().getName()+" running ....");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

}

改成这样,线程Thread1、Thead2依然可以同时工作,这是因为他们所需要的锁不一样。

小结:当一个线程访问对象obj的synchronized(this)代码块时,其它线程是可以同时访问该对象obj的非synchronized(this)的代码块

1.3、当多线程并发时,一个线程访问对象obj的synchronized(this)代码块时,其它线程对对象obj中所有其他synchronized(this)同步代码块的访问将被阻塞

看一个例子:MyThread5类中的两个方法都使用了synchronized(this)来进行修饰.

    class MyThread5 implements Runnable{
private static final int NUM = 3;
@Override
public void run() {
String name = Thread.currentThread().getName();
if(name.equals("Thread1")){
synMethod();
}
else if(name.equals("Thread2")){
synMethod2();
}
}
public void synMethod(){
synchronized(this){
for(int i=0;i<NUM;i++){
System.out.println(Thread.currentThread().getName()+" running ....");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public void synMethod2(){
synchronized(this){
for(int i=0;i<NUM;i++){
System.out.println(Thread.currentThread().getName()+" running ...." + i);
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

}

}

测试方法为:

    public static void main(String[] args) {
MyThread5 mt = new MyThread5();
new Thread(mt,"Thread1").start();
new Thread(mt,"Thread2").start();
}

运行结果:

Thread2 running ....0
Thread2 running ....1
Thread2 running ....2
Thread1 running ....
Thread1 running ....
Thread1 running ....

分析:

当线程Thread1访问对象mt的方法synMethod中的synchronized(this)同步代码块时,线程Thread2访问对象mt中另一个方法synMethod2中synchronized(this)同步代码块的访问将被阻塞。这是因为,线程Thread1访问mt的一个synchronized(this)同步代码块时,它就获得了这个mt的对象锁。结果,线程Thread2对该mt对象所有使用synchronized(this)的同步代码部分的访问都被暂时阻塞。

2、synchronized修饰某个方法

synchronized修饰某个方法,作用的对象为调用该方法的对象。

其实,

    public synchronized void method(){
//to do something ....
}

效果等同于:

    public void method(){
synchronized(this){
//to do something ....
}

}

因此,这里不再进行介绍。

不过,有两点需要注意的是

1、一般我们不建议同步整个方法,能同步方法中的某个代码块就同步代码块。同步安全往往是以性能为代价的。

2、synchronized关键字同步的方法不能继承。虽然可以使用synchronized来修饰某个方法,但是synchronized并不属于方法定义的一部分,因此,synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字,而在子类中覆盖了这个方法,在子类中的这个方法默认情况下并不是同步的,而必须显式地在子类的这个方法中加上synchronized关键字才可以。

3.synchronized关键字修饰静态代码块

synchronized关键字修饰静态代码块,作用的是该类的所用对象。

Demo3:synchronized关键字修饰静态代码块

    class MyThread2 implements Runnable{

private static final int NUM = 3;
@Override
public void run() {
print();
}

public synchronized static void print() {
for(int i=0;i<NUM;i++){
System.out.println(Thread.currentThread().getName()+" running... "+i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

}

测试代码:

    public static void main(String[] args) {
MyThread2 mt = new MyThread2();
MyThread2 mt2 = new MyThread2();
new Thread(mt,"Thread1").start();
new Thread(mt2,"Thread2").start();

}

分析:

我们都知道静态方法是属于类的,不是属于对象的。

MyThread2类中的静态方法print使用了synchronized修饰,尽管在测试代码中使用了两个不同的对象mt/mt2,但是这里的锁不再是锁对象mt/mt2.而是锁”类MyThread2”这个对象,mt/mt2都是属性类MyThread的,因此mt/mt2就相当于同一把锁。,因此,这两个线程在访问此静态方法print时就需要取得锁之后才能访问,访问完之后释放锁。

4、synchronized修饰一个类

synchronized修饰一个类,作用为该类的所用对象

    class MyThread3 implements Runnable{

private static final int NUM = 3;
@Override
public void run() {
synchronized(MyThread3.class){
for(int i=0;i<NUM;i++){
System.out.println(Thread.currentThread().getName()+" running... "+i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

}

测试代码如下:

    public static void main(String[] args) {
MyThread3 mt = new MyThread3();
MyThread3 mt2 = new MyThread3();
new Thread(mt,"Thread1").start();
new Thread(mt2,"Thread2").start();
}

运行结果如下:

Thread2 running... 0
Thread2 running... 1
Thread2 running... 2
Thread1 running... 0
Thread1 running... 1
Thread1 running... 2

由于mt/mt2都是属于类MyThread3的,而synchronized修饰的是MyThread3这整个类,因此所有的MyThread访问此代码块都是互斥的,任一时刻都只能有一个线程能够访问。

不知道大家有没有这样的疑问,反正我是有的,既然synchronized修饰的静态方法和修饰的整个类都是作用与该类的全部对象,那么这两者是不是互斥的呢??

上面的问题具体一点来描述:有一个MyThread类,MyThread类中的一个方法中的代码块Block1用synchronize(MyThread.class)同步,MyThread类中一个静态方法method用synchronized同步,有两个线程Thread1、Thread2,Thread1访问Block1,Thread2访问method是否可以同时进行???

答案是:可以的,这是因为虽然都作用与该类的所用对象,但是锁却不是同一个锁,因此不是互斥的,可以同时访问

看如下的例子

    class MyThread4 implements Runnable{

private static final int NUM = 3;
@Override
public void run() {
String name = Thread.currentThread().getName();
if(name.equals("Thread1")){
synClassMethod();
}
else if(name.equals("Thread2")){
synStaticCodeBlock();
}
}

public void synClassMethod(){
synchronized(MyThread4.class){
for(int i=0;i<NUM;i++){
System.out.println(Thread.currentThread().getName()+" running... "+i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void synStaticCodeBlock(){
for(int i=0;i<NUM;i++){
System.out.println(Thread.currentThread().getName()+" running... "+i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}

}

测试代码如下:

    public static void main(String[] args) {
MyThread4 mt = new MyThread4();
MyThread4 mt2 = new MyThread4();
new Thread(mt,"Thread1").start();
new Thread(mt2,"Thread2").start();
}

运行结果为:

Thread2 running... 0
Thread1 running... 0
Thread2 running... 1
Thread1 running... 1
Thread2 running... 2
Thread1 running... 2

总结

1、当两个线程Thread1、Thread2访问一个对象obj的synchronized(this)代码块时,每个时刻都只能有一个访问此代码块,当Thread1访问时,Thread2只有在Thread1线程执行完这段代码块并释放锁后取得锁才能访问。

2、当两个线程并发时,一个线程访问对象obj的synchronized(this)代码块时,其它的线程可以访问对象obj的synchronized(this)代码块。

3、当多线程并发时,一个线程访问对象obj的synchronized(this)代码块时,其它线程对对象obj中所有其他synchronized(this)同步代码块的访问将被阻塞。这是因为,当一个线程访问obj的一个synchronized(this)同步代码块时,它就获得了这个obj的对象锁。结果,其它线程对该obj对象所有同步代码部分的访问都被暂时阻塞。

4、第3个结论同样适用其它同步代码块。例如,如果一个线程访问对象lock的synchronized(lock)的同步代码块,其中private int[] lock = new int[0],则其它线程在在其它方法中出现的
synchronized(lock)的同步代码块的访问将被阻塞。

5、上面所有的结论都适用于其它对象锁。

参考资料

1、http://blog.csdn.net/luoweifu/article/details/46613015

2、http://www.cnblogs.com/GnagWang/archive/2011/02/27/1966606.html