不惑JAVA之JAVA基础 - 锁 -synchronized、Lock解析

最新推荐文章于 2023-04-11 19:11:15 发布

HelloGeekCsdn

最新推荐文章于 2023-04-11 19:11:15 发布

阅读量2.4k

点赞数

分类专栏： Java基础不惑JAVA 文章标签： java 多线程线程安全线程

本文链接：https://blog.csdn.net/happy_85/article/details/51332966

版权

Java基础同时被 2 个专栏收录

20 篇文章 0 订阅

订阅专栏

不惑JAVA

13 篇文章 0 订阅

订阅专栏

锁主要解决线程安全问题。而线程安全问题，即多个线程同时访问一个资源时，会导致程序运行结果并不是想看到的结果。

synchronized

先来了解一下互斥锁，顾名思义：能到达到互斥访问目的的锁。

如果对临界资源加上互斥锁，当一个线程在访问该临界资源时，其他线程便只能等待。

　　在Java中，每一个对象都拥有一个锁标记（monitor），也称为监视器，多线程同时访问某个对象时，线程只有获取了该对象的锁才能访问。

　　在Java中，可以使用synchronized关键字来标记一个方法或者代码块，当某个线程调用该对象的synchronized方法或者访问synchronized代码块时，这个线程便获得了该对象的锁，其他线程暂时无法访问这个方法，只有等待这个方法执行完毕或者代码块执行完毕，这个线程才会释放该对象的锁，其他线程才能执行这个方法或者代码块。

Synchronized使用

synchronized使用方式：

同步方法；
同步块。

同步方法我们以StringBuffer源码为例（StringBuffer是现成安全的）：

    public synchronized StringBuffer append(String str) {
        super.append(str);
        return this;
    }

同步块

synchronized(synObject) {
       // 允许访问控制的代码　  
    }

synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject 。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。

synchronized (this) {
            for(int i=0;i<100;i++){
                System.out.println(thread.getName()+"在插入数据"+i);
                arrayList.add(i);
            }
        }

对synchronized (this)的一些理解

当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的除synchronized(this)同步代码块以外的部分。
当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
我理解的是当一个线程获取了object锁，其他线程就不能过去object锁，如果想获取只能阻塞等待，但可以访问此object中其他没有被锁定的方法。而如果是同步方法的话，一个线程执行一个对象的非static synchronized方法，另外一个线程需要执行这个对象所属类的static synchronized方法，此时不会发生互斥现象，因为访问static synchronized方法占用的是类锁，而访问非static synchronized方法占用的是对象锁，所以不存在互斥现象。看个例子就明白了：

同步方法实例代码：

public class Test {

    public static void main(String[] args)  {
        final InsertData insertData = new InsertData();
        new Thread(){
            @Override
            public void run() {
                insertData.insert();
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                insertData.insert1();
            }
        }.start();
    }
}

class InsertData {
    public synchronized void insert(){
        System.out.println("执行insert");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("执行insert完毕");
    }

    public synchronized static void insert1() {
        System.out.println("执行insert1");
        System.out.println("执行insert1完毕");
    }
}

结果是
执行insert
执行insert1
执行insert1完毕
执行insert完毕
两个方法互不影响。但要注意如果是在public synchronized void insert()添加一个static结果就不一样了，及代码

public class Test {

    public static void main(String[] args)  {
        final InsertData insertData = new InsertData();
        new Thread(){
            @Override
            public void run() {
                insertData.insert();
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                insertData.insert1();
            }
        }.start();
    }
}

class InsertData {
// ------------ 这里添加了static修复 ------------
    public synchronized static void insert(){
        System.out.println("执行insert");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("执行insert完毕");
    }

    public synchronized static void insert1() {
        System.out.println("执行insert1");
        System.out.println("执行insert1完毕");
    }
}

记过就是：
执行insert
执行insert完毕
执行insert1
执行insert1完毕
也就是说：

某个对象实例内，synchronized aMethod(){} 可以防止多个线程同时访问这个对象的synchronized方法，这时，不同的对象实例的 synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；
是某个类的范围，synchronized static aStaticMethod{} 防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。

来看看代码块：

public class Test1 {

    public static void main(String[] args)  {
        final InsertData1 insertData = new InsertData1();
        new Thread(){
            @Override
            public void run() {
                insertData.insert();
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                insertData.insert1();
            }
        }.start();
    }
}

class InsertData1 {
    public void insert(){
        synchronized(this){
            System.out.println("执行insert");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("执行insert完毕");
        }
    }

    public void insert1() {
        synchronized(this){
            System.out.println("执行insert1");
            System.out.println("执行insert1完毕");
        }
    }
}

执行结果：
执行insert
执行insert完毕
执行insert1
执行insert1完毕
这就证实了上面总结的。

synchronized底层

可以大致了解一下synchronized的底层，通过反编译看一下。

public class InsertData {
    private Object object = new Object();

    public void insert(Thread thread){
        synchronized (object) {

        }
    }

    public synchronized void insert1(Thread thread){

    }

    public void insert2(Thread thread){

    }
}

这里写图片描述

从反编译获得的字节码可以看出，synchronized代码块实际上多了monitorenter和monitorexit两条指令。monitorenter指令执行时会让对象的锁计数加1，而monitorexit指令执行时会让对象的锁计数减1，其实这个与操作系统里面的PV操作很像，操作系统里面的PV操作就是用来控制多个线程对临界资源的访问。对于synchronized方法，执行中的线程识别该方法的 method_info 结构是否有 ACC_SYNCHRONIZED 标记设置，然后它自动获取对象的锁，调用方法，最后释放锁。如果有异常发生，线程自动释放锁。

还有两点说明：

对于synchronized方法或者synchronized代码块，当出现异常时，JVM会自动释放当前线程占用的锁，因此不会由于异常导致出现死锁现象；
synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法。

Lock

先来说说synchronized缺陷和lock与它的不同
缺陷：

获取锁的线程执行完了该代码块，然后线程释放对锁的占有；
线程执行发生异常，此时JVM会让线程自动释放锁。

那么如果这个获取锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，其他线程便只能干巴巴地等待，试想一下，这多么影响程序执行效率。

不同：

Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问；
Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象；
除此之外还多了一下如下知识点：
- 等待可中断，在持有锁的线程长时间不释放锁的时候,等待的线程可以选择放弃等待. tryLock(long timeout, TimeUnit unit)；
- 公平锁，按照申请锁的顺序来一次获得锁称为公平锁.synchronized的是非公平锁,ReentrantLock可以通过构造函数实现公平锁. new RenentrantLock(boolean fair)；
- 绑定多个Condition（这个在堵塞队列中用到），通过多次newCondition可以获得多个Condition对象,可以简单的实现比较复杂的线程同步的功能.通过await(),signal()。

ReentrantLock

Lock是一个接口，这里重点介绍ReentrantLock。ReentrantLock，意思是“可重入锁”，ReentrantLock是唯一实现了Lock接口的类，并且ReentrantLock提供了更多的方法。

可重入锁

在学习ReentrantLock之前我们先来了解一下可重入锁。
在JAVA环境下 ReentrantLock 和synchronized 都是可重入锁。

可重入锁，也叫做递归锁，指的是同一线程外层函数获得锁之后，内层递归函数仍然有获取该锁的代码，但不受影响。简单的说：当一个线程请求得到一个对象锁后再次请求此对象锁,可以再次得到该对象锁,就是说在一个synchronized方法/块或ReentrantLock的内部调用本类的其他synchronized方法/块或ReentrantLock时，是永远可以拿到锁。

看代码：

public class ReentrantLockTest implements Runnable {
    ReentrantLock lock = new ReentrantLock();

    public void get() {
        lock.lock();
        System.out.println(Thread.currentThread().getId());
        set();
        lock.unlock();
    }

    public void set() {
        lock.lock();
        System.out.println(Thread.currentThread().getId());
        lock.unlock();
    }

    @Override
    public void run() {
        get();
    }

    public static void main(String[] args) {
        ReentrantLockTest ss = new ReentrantLockTest();
        new Thread(ss).start();
        new Thread(ss).start();
        new Thread(ss).start();
    }
}

结果是：
11
11
12
12
13
13
（可以每次执行的结构不太一样）但可以看到同一个线程id被连续输出两次。

ReentrantLock的正确使用

public class Test {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    public static void main(String[] args)  {
        final Test test = new Test();

        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();

        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();
    }  

    public void insert(Thread thread) {
        Lock lock = new ReentrantLock();    //注意这个地方
        lock.lock();
        try {
            System.out.println(thread.getName()+"得到了锁");
            for(int i=0;i<5;i++) {
                arrayList.add(i);
            }
        } catch (Exception e) {
            // TODO: handle exception
        }finally {
            System.out.println(thread.getName()+"释放了锁");
            lock.unlock();
        }
    }
}

结果：
Thread-0得到了锁
Thread-1得到了锁
Thread-0释放了锁
Thread-1释放了锁
为什么会是这样呢？原因在于，在insert方法中的lock变量是局部变量，每个线程执行该方法时都会保存一个副本，那么理所当然每个线程执行到lock.lock()处获取的是不同的锁，所以就不会发生冲突。

正确是使用方式是，只需要将lock声明为类的属性即可：

public class Test {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    private Lock lock = new ReentrantLock();    //注意这个地方
    public static void main(String[] args)  {
        final Test test = new Test();

        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();

        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();
    }  

    public void insert(Thread thread) {
        lock.lock();
        try {
            System.out.println(thread.getName()+"得到了锁");
            for(int i=0;i<5;i++) {
                arrayList.add(i);
            }
        } catch (Exception e) {
            // TODO: handle exception
        }finally {
            System.out.println(thread.getName()+"释放了锁");
            lock.unlock();
        }
    }
}

ReentrantLock可重入锁的使用场景

场景1：如果发现该操作已经在执行中则不再执行（有状态执行）

private ReentrantLock lock = new ReentrantLock();
    if (lock.tryLock()) {  //如果已经被lock，则立即返回false不会等待，达到忽略操作的效果 
         try {

            //操作

         } finally {
             lock.unlock();
         }

     }

场景2：如果发现该操作已经在执行，等待一个一个执行（同步执行，类似synchronized）

private ReentrantLock lock = new ReentrantLock(); //参数默认false，不公平锁
// private ReentrantLock lock = new ReentrantLock(true); //公平锁
    try {
        lock.lock(); //如果被其它资源锁定，会在此等待锁释放，达到暂停的效果

       //操作

    } finally {
        lock.unlock();
    }

不公平锁与公平锁的区别：

公平情况下，操作会排一个队按顺序执行，来保证执行顺序。（会消耗更多的时间来排队）
不公平情况下，是无序状态允许插队，jvm会自动计算如何处理更快速来调度插队。（如果不关心顺序，这个速度会更快）

场景3：如果发现该操作已经在执行，则尝试等待一段时间，等待超时则不执行（尝试等待执行）

try {
     if (lock.tryLock(5, TimeUnit.SECONDS)) {  //如果已经被lock，尝试等待5s，看是否可以获得锁，如果5s后仍然无法获得锁则返回false继续执行
        try {
            //操作
        } finally {
            lock.unlock();
        }
      }
  } catch (InterruptedException e) {
      e.printStackTrace(); //当前线程被中断时(interrupt)，会抛InterruptedException                 
  }

场景4：如果发现该操作已经在执行，等待执行。这时可中断正在进行的操作立刻释放锁继续下一操作。
这种情况主要用于取消某些操作对资源的占用。如：（取消正在同步运行的操作，来防止不正常操作长时间占用造成的阻塞）,该操作的开销也很大,一般不建议用。

try {
    lock.lockInterruptibly();
    //操作

} catch (InterruptedException e) {
    e.printStackTrace();
} finally {
    lock.unlock();
}

下期会介绍volatile 和 ThreadPool

参考：
Java并发编程：synchronized
Synchronized关键字总结
 Java并发编程：Lock
Java锁的种类以及辨析（四）：可重入锁

HelloGeekCsdn

关注

0
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录