Thread中的同步锁__synchronized

最新推荐文章于 2021-11-29 21:14:01 发布

luo_boke

最新推荐文章于 2021-11-29 21:14:01 发布

阅读量464

点赞数 1

分类专栏：线程专栏文章标签： Thread 同步锁 synchronized lock 死锁

本文链接：https://blog.csdn.net/luo_boke/article/details/99822040

版权

线程专栏专栏收录该内容

9 篇文章 0 订阅

订阅专栏

同步锁常用于在多线程安全处理中。说道线程安全就需要提及多个专业概念。同步锁分为两种sychronized和Lock。介绍同步锁时需要介绍介个概念。

同步：在高并发的情况下，为了防止数据出错，一个线程对于共享资源执行操作的时候，另外的线程要执行操作此共享资源需要等待前一个线程释放此共享资源，才能操作。

同步监视器：共享资源。

同步函数：synchronized修饰的方法，同步监视器为当前this对象。

同步代码块：synchronized修饰的代码块，同步监视器可以自定义。

同步锁Lock：另一种更加强大的线程安全机制：通过显示的定义同步锁对象来实现同步，同步锁对象由Lock对象充当。

两者同步机制的区别：Lock是显示的使用Lock对象作为同步监视器，同步方法隐式的使用当前对象作为同步监视器。

Lock开启后必须关闭：lock()//加锁 unlock()//释放锁

sychronized:

同步关键字，被该关键字修饰的代码块具有原子性，即使发生线程抢占该代码块的情况，首次进入的线程会给该代码块加锁，其他线程进入阻塞状态。

sychronized主要有两种方式，[synchronized 方法]和[synchronized 块]，其实就是他们的作用域不一样。如下：

class MyTest {
    public int count = 0;
    //print1 方法   -synchronized块(对象级，这里是对象不是地址引用)
    public int print1() {
        synchronized (this) {
            count++;
        }
        return count;
    }

    //print2 方法  -synchronized块(类级别)
    public int print2() {
        synchronized (com.xuanyuan.makefun.codingstudy.Test.class) {
            count++;
        }
        return count;
    }

    //print3 方法  -synchronized 方法
    public synchronized int print3() {
        count++;
        return count;
    }

    //普通方法
    public int commonPrint() {
        return count;
    }
}

采用了synchronized机制的类都有自己的类锁（只有一个），该类的任何对象实例都有独立的对象锁。任何类。当在一个线程中通过某对象的实例调用了它的synchronized方法或者synchronized代码块时，这个实例（对象）或者类就会被加锁，直至synchronized方法返回或者代码块中代码执行完才会释放锁，期间无法调用该类或者实例的属性或方法（根据锁的对象不一样，限制范围不一样）。加锁期间，线程持有hold对应实例或者类的锁。

注意,synchronized方法或synchronized代码块有如下特点：

1. 如某个类或实例中，线程想要调用synchronized方法或者synchronized代码块必须要获得类或者实例的锁。

2. 多个线程并发访问synchronized时，任何时刻只有一个线程能够持有锁，只有synchronized修饰的方法或者代码块执行完毕才会释放锁，其他线程此时会被阻塞。

3. 多线程并发中，访问synchronized方法或者synchronized(this)块时，其他线程可以访问非synchronized代码块或者synchronized方法，不可以访问其他synchronized修饰的方法或者代码块

4. 多线程并发访问synchronized(A.class)锁定是A.class这个类，此时其他线程不能访问A.class中的任何方法和代码块，不论是否经synchronized 关键字修饰或者是否是静态方法及变量。

5. 在含有静态方法和静态变量的代码块，类锁的严格约束在多线程场景下非常实用，应用也较多。

在众多写法中这两个方法常常是等价，如下代码：

public synchronized void m () {
}
// 这两个方法事实上是等价的
public  void m1 () {
   synchronized (this){
    }
}

注意：synchronized 方法相对于synchronized 代码块最明显的是其作用域更大一些，事实上作用域更大一些在多线程情况下会降低效率，因为如果一个方法代码量过大，不涉及共享资源读写的代码可通过多线程快速Ready,只等锁释放后进行同步代码的执行。所以在多线程开发中尽量缩小需要同步锁机制保障的代码的范围。

在同步锁的使用中，“类锁”虽然可以最大限度的避免并发场景下的冲突，但是，其过于严格：多线程场景下，当某一线程获得类锁(注意：不再是对象锁)，其它线程将被阻塞，将无法调用或访问该类的所有方法和域，包括静态方法和静态变量。一个类，不可能所有属性和方法都涉及并发问题，因此，类锁过于严格的限制会极大的影响性能。下面说说互斥锁mutex。

class TestSynchronized   {
    //定义一个静态对象
    private static Object mutex = new Object();
    public void Test() {
        synchronized (mutex) {
            //涉及并发问题的代码块
        }
    }
}

由于mutex为静态类型，对于TestForSynchronized类的所有对象，当需要访问TestMethod的同步块时都必须获得mutex对象的锁，然而，mutex属于类，有且仅有一个锁，从而可以保证任意一个时刻只有一个线程可以访问这个同步块。