Java基础: 全面了解synchronized关键词

最新推荐文章于 2024-07-11 23:19:16 发布

gaolhjy

最新推荐文章于 2024-07-11 23:19:16 发布

阅读量1.2k

点赞数

分类专栏： JavaSe基础文章标签：异步关键字 synchronized 线程安全

本文链接：https://blog.csdn.net/gaolh89/article/details/94352986

版权

JavaSe基础专栏收录该内容

26 篇文章 2 订阅

订阅专栏

synchronized关键字属于Java基础的知识范畴,主要用于多线程使用场景。
掌握它,可以更好地掌握Java多线程知识,同时由于synchronized在Android源码中较为常见,掌握它可以更好的阅读源码。

一.基本认知

1.作用

保证同一时刻最多只有1个线程执行被Synchronized修饰的方法 / 代码。

(即:其他线程必须等待当前线程执行完该方法 / 代码块后才能执行该方法 / 代码块)

2.应用场景

保证线程安全，解决多线程中的并发同步问题（实现的是阻塞型并发），具体场景如下：

修饰实例方法 / 代码块时，（同步）保护的是同一个对象方法的调用 & 当前实例对象
修饰静态方法 / 代码块时，（同步）保护的是静态方法的调用 & class 类对象

3.语法

synchronized (obj){
      .....
     //此处的代码就是同步代码块   
}

上述语法格式中synchronized 后括号里的obj就是同步监视器,上述代码的含义是: 线程开始执行同步代码块之前,必须先获得对同步监视器的锁定。

提示:
(1)任何时刻,只能有一个线程可以获得对同步监视器的锁定,但同步代码块执行完成后,该线程会释放对该同步监视器的锁定。

(2)synchronized关键字可以修饰方法,可以修饰代码块,但不能修饰构造器、成员变量等。

二.使用规则

在Java代码中使用synchronized可以使用在代码块和方法中，根据synchronized用的位置可以有这些使用场景：

在这里插入图片描述
如图，synchronized可以用在方法上也可以使用在代码块中，其中方法是实例方法和静态方法分别锁的是该类的实例对象和该类的对象。而使用在代码块中也可以分为三种，具体的可以看上面的表格。这里的需要注意的是：如果锁的是类对象的话，尽管new多个实例对象，但他们仍然是属于同一个类依然会被锁住，即线程之间保证同步关系。

在Java中,虽然程序允许使用任何对象作为同步监视器,但想一下同步监视器的目的: 阻止两个线程对同一个共享资源进行并发访问,因为通常推荐使用可能被并发访问的共享资源充当同步监视器。

三.测试demo

1、没有同步的情况：

代码如下:

public class SynchronizedTest1 {

    public static void main(String[] args) {

        final SynchronizedTest1 test = new SynchronizedTest1();

        new Thread(new Runnable() {
            @Override
            public void run() {
                test.method1();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                test.method2();
            }
        }).start();
    }


    public void method1() {

        System.out.println("Method 1 start");
        try {
            System.out.println("Method 1 execute");
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Method 1 end");
    }

    public void method2() {
        System.out.println("Method 2 start");
        try {
            System.out.println("Method 2 execute");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Method 2 end");
    }
}

执行结果如下，线程1和线程2同时进入执行状态，线程2执行速度比线程1快(线程2 sleep1000,线程1 sleep 3000)，所以线程2先执行完成，这个过程中线程1和线程2是同时执行的。

Method 1 start
Method 1 execute
Method 2 start
Method 2 execute
Method 2 end
Method 1 end

2、对普通方法同步：

代码如下:

public class SynchronizedTest2 {

    public static void main(String[] args) {

        final SynchronizedTest2 test = new SynchronizedTest2();

        new Thread(new Runnable() {
            @Override
            public void run() {
                test.method1();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                test.method2();
            }
        }).start();
    }


    public synchronized void method1() {

        System.out.println("Method 1 start");
        try {
            System.out.println("Method 1 execute");
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Method 1 end");
    }

    public synchronized void method2() {
        System.out.println("Method 2 start");
        try {
            System.out.println("Method 2 execute");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Method 2 end");
    }
}

执行结果如下，跟代码段一比较，可以很明显的看出，线程2需要等待线程1的method1执行完成才能开始执行method2方法。

Method 1 start
Method 1 execute
Method 1 end
Method 2 start
Method 2 execute
Method 2 end

3、静态方法（类）同步：

代码如下:

public class SynchronizedTest3 {

    public static void main(String[] args) {

        final SynchronizedTest3 test = new SynchronizedTest3();
        final SynchronizedTest3 test33 = new SynchronizedTest3();

        new Thread(new Runnable() {
            @Override
            public void run() {
                test.method1();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                test33.method2();
            }
        }).start();
    }


    public static synchronized void method1() {

        System.out.println("Method 1 start");
        try {
            System.out.println("Method 1 execute");
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Method 1 end");
    }

    public static synchronized void method2() {
        System.out.println("Method 2 start");
        try {
            System.out.println("Method 2 execute");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Method 2 end");
    }
}

执行结果如下，**对静态方法的同步本质上是对类的同步（静态方法本质上是属于类的方法，而不是对象上的方法），所以即使test和test2属于不同的对象，但是它们都属于SynchronizedTest类的实例，**所以也只能顺序的执行method1和method2，不能并发执行。

Method 1 start
Method 1 execute
Method 1 end
Method 2 start
Method 2 execute
Method 2 end

4、代码块同步：

代码如下:

public class SynchronizedTest4 {

    public static void main(String[] args) {

        final SynchronizedTest4 test = new SynchronizedTest4();

        new Thread(new Runnable() {
            @Override
            public void run() {
                test.method1();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                test.method2();
            }
        }).start();
    }


    public void method1() {

        System.out.println("Method 1 start");
        try {
            synchronized (this) {
                System.out.println("Method 1 execute");
                Thread.sleep(3000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Method 1 end");
    }

    public void method2() {
        System.out.println("Method 2 start");
        try {
            synchronized (this) {
                System.out.println("Method 2 execute");
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Method 2 end");
    }
}

执行结果如下，虽然线程1和线程2都进入了对应的方法开始执行，但是线程2在进入同步块之前，需要等待线程1中同步块执行完成。

Method 1 start
Method 1 execute
Method 2 start
Method 2 execute
Method 1 end
Method 2 end

四.synchronized的原理和本质:

我们了解一下synchronized的原理，再回头上面的问题就一目了然了。我们先通过反编译下面的代码来看看synchronized是如何实现对代码块进行同步的：

反编译结果：
在这里插入图片描述

关于这两条指令的作用，我们直接参考JVM规范中描述：

monitorenter ：

Each object is associated with a monitor. A monitor is locked if and only if it has an owner. The thread that executes monitorenter attempts to gain ownership of the monitor associated with objectref, as follows:

• If the entry count of the monitor associated with
objectref is zero, the thread enters the monitor and sets its entry count to one. The thread is then the owner of the monitor.
• If the thread already owns the monitor associated with objectref, it reenters the monitor, incrementing its entry count.
• If another thread already owns the monitor associated with objectref, the thread blocks until the monitor’s entry count is zero, then tries again to gain ownership.

这段话的大概意思为：

每个对象有一个监视器锁（monitor）。当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的所有权，过程如下：

1、如果monitor的进入数为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者。

2、如果线程已经占有该monitor，只是重新进入，则进入monitor的进入数加1.

3.如果其他线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再重新尝试获取monitor的所有权。

monitorexit：

The thread that executes monitorexit must be the owner of the monitor associated with the instance referenced by objectref.
The thread decrements the entry count of the monitor associated with objectref. If as a result the value of the entry count is zero, the thread exits the monitor and is no longer its owner. Other threads that are blocking to enter the monitor are allowed to attempt to do so.

这段话的大概意思为：

执行monitorexit的线程必须是objectref所对应的monitor的所有者。

指令执行时，monitor的进入数减1，如果减1后进入数为0，那线程退出monitor，不再是这个monitor的所有者。其他被这个monitor阻塞的线程可以尝试去获取这个 monitor 的所有权。

通过这两段描述，我们应该能很清楚的看出Synchronized的实现原理，Synchronized的语义底层是通过一个monitor的对象来完成，其实wait/notify等方法也依赖于monitor对象，这就是为什么只有在同步的块或者方法中才能调用wait/notify等方法，否则会抛出java.lang.IllegalMonitorStateException的异常的原因。

我们再来看一下同步方法的反编译结果：
在这里插入图片描述

源代码：

package com.paddx.test.concurrent;

 public class SynchronizedMethod {
    public synchronized void method() {
        System.out.println("Hello World!");
    }
}

从反编译的结果来看，方法的同步并没有通过指令monitorenter和monitorexit来完成（理论上其实也可以通过这两条指令来实现），不过相对于普通方法，其常量池中多了ACC_SYNCHRONIZED标示符。JVM就是根据该标示符来实现方法的同步的：当方法调用时，调用指令将会检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置，如果设置了，执行线程将先获取monitor，获取成功之后才能执行方法体，方法执行完后再释放monitor。在方法执行期间，其他任何线程都无法再获得同一个monitor对象。其实本质上没有区别，只是方法的同步是一种隐式的方式来实现，无需通过字节码来完成。

运行结果解释

有了对synchronized原理的认识，再来看上面的程序就可以迎刃而解了。

1、代码段2结果：

虽然method1和method2是不同的方法，但是这两个方法都进行了同步，并且是通过同一个对象去调用的，所以调用之前都需要先去竞争同一个对象上的锁（monitor），也就只能互斥的获取到锁，因此，method1和method2只能顺序的执行。

2、代码段3结果：

虽然test和test2属于不同对象，但是test和test2属于同一个类的不同实例，由于method1和method2都属于静态同步方法，所以调用的时候需要获取同一个类上monitor（每个类只对应一个class对象），所以也只能顺序的执行。

3、代码段4结果：

对于代码块的同步实质上需要获取Synchronized关键字后面括号中对象的monitor，由于这段代码中括号的内容都是this，而method1和method2又是通过同一的对象去调用的，所以进入同步块之前需要去竞争同一个对象上的锁，因此只能顺序执行同步块。

synchronized的本质:

synchronized的本质,是保证方法内部或代码块内部资源(数据)的互斥访问.即同一时间、由同一个Monitor监视的代码,最多只能有一个线程在访问。

保证线程之间对监视资源的数据同步,即,任何线程在获取到Monitor后的第一时间,会先将共享内存中的数据复制到自己的缓存中;任何线程在释放Monitor的第一时间,会先从缓存的数据复制到共享内存中。

五.性能提示:

可变类的线程安全是以降低程序的运行效率作为代价的,为了减少线程安全所带来的负面影响,程序可以采取如下策略:

(1) 不要对线程安全类的所有方法都进行同步,只对那些会改变竞争资源(竞争资源也就是共享资源)的方法进行同步。

(2)如果可变类有两种运行环境: 单线程环境和多线程环境,则应该为该可变类提供两种版本,即线程不安全版本和线程安全版本.在单线程环境中使用线程不安全版本以保证性能,在多线程环境中使用线程安全版本。

JDK所提供的StringBuilder、StringBuffer就是为了照顾单线程和多线程环境所提供的类,在单线程环境下应该使用StringBuilder来保证较好的性能;当需要保证多线程安全时,就应该使用StringBuffer。

gaolhjy

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础: 全面了解synchronized关键词

synchronized关键字属于Java基础的知识范畴,但在Android的framework层源码中,极其常见。掌握它,是更好的阅读、学习Android源码的前提。一.基本认知1.作用保证同一时刻最多只有1个线程执行被Synchronized修饰的方法 / 代码。(即:其他线程必须等待当前线程执行完该方法 / 代码块后才能执行该方法 / 代码块)2.应用场景保证线程安全，解决...
复制链接

扫一扫

专栏目录