synchronized详解以及线程同步

最新推荐文章于 2024-07-03 23:39:10 发布

超人不会飞、

最新推荐文章于 2024-07-03 23:39:10 发布

阅读量163

点赞数

本文链接：https://blog.csdn.net/Cheng_MY/article/details/102259695

版权

多线程专栏收录该内容

9 篇文章 0 订阅

订阅专栏

synchronized详解以及线程同步

其实很容易发现，无论是加了锁的方法还是加了锁的代码块，不管加的是对象锁还是类锁，只要上的是同一把锁，那么它们的访问规则就应该是相同的。也就是上了同一把锁的东西，要么一起可以被访问，要么一起禁止别人访问。因此，如果想搞清楚访问的规则，我们首先要搞清楚锁的类型。然后判断，只要上的是同一把锁，访问的规则就应该相同。那么java中的锁有那些类型呢。可以简单的总结为两种类型：

java中共有两种类型的锁：
（1）类锁：只有synchronized修饰静态方法或者修饰一个类的class对象时，才是类锁。
（2）对象锁：除了类锁，所有其他的上锁方式都认为是对象锁。比如synchronized修饰普通方法或者synchronized（this)给代码块上锁等

应该注意的是，因为一个类只有一个.class对象，因此所有的访问者在访问被加了类锁的东西时，都是共用同一把锁，而类的实例却可以有很多个，因此不同对象访问加了对象锁的东西，它们的访问互不干扰。

知道了锁的类型，那么我们就可以总结出一个通用且清晰的规则了。如下：

这个规则很简单：
（1）加了相同锁的东西，它们的访问规则是相同的，即当某个访问者获得该锁时，它们一起向该访问者开放访问，向其他没有获得该锁的访问者关闭访问；
（2）加了不同锁的东西访问互相不干扰
（3）而没有加锁的东西随时都可以任意访问，不受任何限制。

然后再来看怎么判断什么情况下是相同的锁。如下：

怎么判断是一把相同的锁，遵循下面的规则：
（1）不同类型的锁不是同一把锁。
（2）加的是对象锁，那么必须是同一个对象实例才是同一把锁
（3）加的是类锁，那必须是同一类才是同一把锁。

好了，也就是说我们判断访问的规则，就是基于这个步骤：

1.首先判断是不是同一把锁

2.然后判断各自的访问规则

举例说明

实验一

public class TestThread {

    private synchronized void test1() {
        for(int i = 0; i < 3; i++){
            System.out.println(i + "我们是test1");
        }
    }

    private void test2() {
        synchronized(this){
            for(int i = 0; i < 3; i++){
                System.out.println(i + "我们是test2");
            }
        }
    }

    public static void main(String[] args) {
        final TestThread tt = new TestThread();
        Thread t1 = new Thread(new Runnable() {public void run() {
            tt.test1();
        }});
        Thread t2 = new Thread(new Runnable() {public void run() {
            tt.test2();
        }});
        t1.start();
        t2.start();
    }
}

在代码中，可以看到我们给test1方法上了对象锁，加锁的方式是给方法加锁，加的是当前对象锁；而给test2方法上也上了对象锁，加锁的方式给代码块加锁，注意上的是当前对象锁，你也可以将this替换成任意其他对象。然后我们在main方法中看到，新建了两个线程，都是用同一个对象来调用这两个方法。因此，可以判定线程t1和t2使用的是同一把锁，因此访问规则就是t1获得了这把锁后，test1方法和test2中被加锁的代码块都允许t1访问，都拒绝t2访问，等t1运行完，t2才会获得该锁，进行访问。因此输出的结果很明显了，t1执行完，再执行t2。我们运行下程序，看看我们按照规则来推理的是否正确，运行结果如下：

在这里插入图片描述

实验二

然后我们再做个试验，比如将main方法中的代码改成下面的：

public static void main(String[] args) {
        final TestThread st = new TestThread();
        final TestThread st2 = new TestThread();
        Thread t1 = new Thread(new Runnable(){public void run() {
            st.test1();
        }});
        Thread t2 = new Thread(new Runnable(){public void run() {
            st2.test2();
        }});
        t1.start();
        t2.start();
    }

只是多出一个实例而已，然后线程t2通过st2来调用test2。那么就test1和test2加的都是当前对象的锁，显然它们的当前对象不同吧。所以它们不是同一把锁，互相不干扰。那么我们运行程序，效果如下：

在这里插入图片描述

实验三

public class TestThread {

    private static synchronized void test1() {
        for(int i = 0; i < 3; i++){
            System.out.println(i + "我们是test1");
        }
    }

    private void test2() {
        synchronized(TestThread.class){
            for(int i = 0; i < 3; i++){
                System.out.println(i + "我们是test2");
            }
        }
    }

    public static void main(String[] args) {
        final TestThread st = new TestThread();
        Thread t1 = new Thread(new Runnable() {public void run() {
            TestThread.test1();
        }});
        Thread t2 = new Thread(new Runnable() {public void run() {
            st.test2();
        }});
        t1.start();
        t2.start();
    }
}

很简单，test1是一个静态方法，所以它加的锁是类锁，而test2加了一个类锁，是加载了一个代码块中，因此他们加的是相同的锁。运行程序，结果如下：

在这里插入图片描述

实验四

然后我们再修改TestThread中的代码，如下：

public class TestThread {

    private static synchronized void test1() {
        for(int i = 0; i < 3; i++){
            System.out.println(i + "我们是test1");
        }
    }

    private synchronized void test2() {
        for(int i = 0; i < 3; i++){
            System.out.println(i + "我们是test2");
        }
    }

    public static void main(String[] args) {
        final TestThread st = new TestThread();
        Thread t1 = new Thread(new Runnable() {public void run() {
            TestThread.test1();
        }});
        Thread t2 = new Thread(new Runnable() {public void run() {
            st.test2();
        }});
        t1.start();
        t2.start();
    }
}

代码中很显然了，test1是静态方法，它上的是类锁。而test2是普通方法，它上的对象锁。这是不同的锁。所以t1访问test1时，test2方法是不受干扰的，t2肯定可以同时访问test2.因此打印顺序为任意顺序。如下：

在这里插入图片描述

实验五

public class TestThread {

    private synchronized void test1() {
        for(int i = 0; i < 3; i++){
            System.out.println(i + "我们是test1");
        }
    }

    private void test2() {
        synchronized(TestThread.class){
            for(int i = 0; i < 3; i++){
                System.out.println(i + "我们是test2");
            }
        }
    }

    public static void main(String[] args) {
        final TestThread st = new TestThread();
        Thread t1 = new Thread(new Runnable() {public void run() {
            st.test1();
        }});
        Thread t2 = new Thread(new Runnable() {public void run() {
            st.test2();
        }});
        t1.start();
        t2.start();
    }
}

很明显一个类锁，一个对象锁，访问规则互不干扰。即，t1访问test1方法时，并不影响t2访问test2（但是会禁止t2访问test1，因为t2用的也是st对象，此时t1已给st对象上锁了）。所以打印顺序可能为任意顺序。结果如下：

在这里插入图片描述

总结：

1、synchronized关键字的作用域有二种：
1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；
2）是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。但是对类中static且非synchronized方法不起作用。

2、除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/区块/}，它的作用域是当前对象；

3、synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法；

一.说说synchronized关键字的理解

synchronized关键字解决的是多线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的代码块或方法在任意时刻只能有一个线程执行。

另外，在java早期版本中，synchronized属于重量级锁，效率低下，因为监视锁（monitor）是依赖于底层的操作系统的Mutex Lock完成的，java的线程是映射到操作系统的原生线程之上的。如果要挂起或者唤醒一个线程，都需要操作系统帮忙完成，而操作系统实现线程之间的转换时需要从用户态转换成内核态，这个状态之间的转换需要相对较长的时间，时间成本相对较高，这也是为什么早期的synchronized锁效率低下的原因。庆幸的是，在java6之后java官方在JVM层面对synchronized做了较大的优化，所以现在synchronized锁效率也优化得很不错了。JDK1.6对锁的实现引入了大量的优化，如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术来减少锁操作的开销。

二.面试中面试官经常会说：“单例模式了解吗？来给我手写一下！给我解释一下双重检验锁方式实现单例模式的原理呗！”

双重校验锁实现对象单例（线程安全）

	public class Singleton {
        private volatile static Singleton uniqueInstance;
        
        private Singleton() {   
        }
        
        public static Singleton getUniqueInstance() {
			// 先判断对象是否已经实例过，没有实例过才进入加锁代码
            if (uniqueInstance == null) {
                synchronized(Singleton.class) {
                    if (uniqueInstance == null) {
                        uniqueInstance = new Singleton();
                    }
                }
            }
            return uniqueInstance;
        }
    }

另外，需要注意 uniqueInstance 采用 volatile 关键字修饰也是很有必要。

uniqueInstance 采用 volatile 关键字修饰也是很有必要的， uniqueInstance = new Singleton(); 这段代码其实是分为三步执行：

为 uniqueInstance 分配内存空间
初始化 uniqueInstance
将 uniqueInstance 指向分配的内存地址

但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1->3->2。指令重排在单线程环境下不会出先问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T1 执行了 1 和 3，此时 T2 调用 getUniqueInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。

使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。

三.说说 JDK1.6 之后的synchronized 关键字底层做了哪些优化，可以详细介绍一下这些优化吗？

JDK1.6 对锁的实现引入了大量的优化，如偏向锁、轻量级锁、自旋锁、适应性自旋锁、锁消除、锁粗化等技术来减少锁操作的开销。

锁主要存在四种状态，依次是：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，他们会随着竞争的激烈而逐渐升级。注意锁可以升级不可降级，这种策略是为了提高获得锁和释放锁的效率。

关于这几种优化的详细信息可以查看笔主的这篇文章：https://gitee.com/SnailClimb/JavaGuide/blob/master/docs/java/Multithread/synchronized.md

四.谈谈synchronized和ReentrantLock的区别

1.两者都是可重入锁

两者都是可重入锁。“可重入锁”概念是：自己可以再次获取自己的内部锁。比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。同一个线程每次获取锁，锁的计数器都自增1，所以要等到锁的计数器下降为0时才能释放锁。

2.synchronized 依赖于 JVM 而 ReentrantLock 依赖于 API

synchronized 是依赖于 JVM 实现的，前面我们也讲到了虚拟机团队在 JDK1.6 为 synchronized 关键字进行了很多优化，但是这些优化都是在虚拟机层面实现的，并没有直接暴露给我们。ReentrantLock 是 JDK 层面实现的（也就是 API 层面，需要 lock() 和 unlock() 方法配合 try/finally 语句块来完成），所以我们可以通过查看它的源代码，来看它是如何实现的。

3.ReentrantLock 比 synchronized 增加了一些高级功能

相比synchronized，ReentrantLock增加了一些高级功能。主要来说主要有三点：①等待可中断；②可实现公平锁；③可实现选择性通知（锁可以绑定多个条件）

ReentrantLock提供了一种能够中断等待锁的线程的机制，通过lock.lockInterruptibly()来实现这个机制。也就是说正在等待的线程可以选择放弃等待，改为处理其他事情。
ReentrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。 ReentrantLock默认情况是非公平的，可以通过 ReentrantLock类的ReentrantLock(boolean fair)构造方法来制定是否是公平的。
synchronized关键字与wait()和notify()/notifyAll()方法相结合可以实现等待/通知机制，ReentrantLock类当然也可以实现，但是需要借助于Condition接口与newCondition() 方法。Condition是JDK1.5之后才有的，它具有很好的灵活性，比如可以实现多路通知功能也就是在一个Lock对象中可以创建多个Condition实例（即对象监视器），线程对象可以注册在指定的Condition中，从而可以有选择性的进行线程通知，在调度线程上更加灵活。在使用notify()/notifyAll()方法进行通知时，被通知的线程是由 JVM 选择的，用ReentrantLock类结合Condition实例可以实现“选择性通知” ，这个功能非常重要，而且是Condition接口默认提供的。而synchronized关键字就相当于整个Lock对象中只有一个Condition实例，所有的线程都注册在它一个身上。如果执行notifyAll()方法的话就会通知所有处于等待状态的线程这样会造成很大的效率问题，而Condition实例的signalAll()方法只会唤醒注册在该Condition实例中的所有等待线程。

如果你想使用上述功能，那么选择ReentrantLock是一个不错的选择。

4.性能已不是选择标准

五.volatile关键字

synchronized关键字和volatile关键字的比较：

volatile关键字是线程同步的轻量级实现，所以volatile性能肯定比synchronized关键字要好。但是volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块。synchronized关键字在JavaSE1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升，实际开发中使用 synchronized 关键字的场景还是更多一些。
多线程访问volatile关键字不会发生阻塞，而synchronized关键字可能会发生阻塞
volatile关键字能保证数据的可见性，但不能保证数据的原子性。synchronized关键字两者都能保证。
volatile关键字主要用于解决变量在多个线程之间的可见性，而 synchronized关键字解决的是多个线程之间访问资源的同步性。

超人不会飞、

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
synchronized详解以及线程同步

synchronized详解以及线程同步其实很容易发现，无论是加了锁的方法还是加了锁的代码块，**不管加的是对象锁还是类锁，只要上的是同一把锁，那么它们的访问规则就应该是相同的。**也就是上了同一把锁的东西，要么一起可以被访问，要么一起禁止别人访问。因此，如果想搞清楚访问的规则，我们首先要搞清楚锁的类型。然后判断，只要上的是同一把锁，访问的规则就应该相同。那么java中的锁有那些类型呢。可以...
复制链接

扫一扫