类锁与对象锁，重入锁

阅读量：6258 次

发布时间：2019-06-22

本文共 4133 字，大约阅读时间需要 13 分钟。

看的该文章的总结：

https://juejin.im/post/5adf14dcf265da0b7b358d58

synchronized一般我们用来修饰三种东西：

修饰普通方法

修饰代码块

修饰静态方法

1.4.1修饰普通方法：

用的锁是Java3y对象(内置锁)

public class Java3y {    // 修饰普通方法，此时用的锁是Java3y对象(内置锁)    public synchronized void test() {        // 关注公众号Java3y        // doSomething    }}

1.4.2修饰代码块：

用的锁是Java3y对象(内置锁)--->this

public class Java3y {        public  void test() {                // 修饰代码块，此时用的锁是Java3y对象(内置锁)--->this        synchronized (this){            // 关注公众号Java3y            // doSomething        }    }}

当然了，我们使用synchronized修饰代码块时未必使用this，还可以使用其他的对象(随便一个对象都有一个内置锁)

所以，我们可以这样干：

public class Java3y {    // 使用object作为锁(任何对象都有对应的锁标记，object也不例外)    private Object object = new Object();    public void test() {        // 修饰代码块，此时用的锁是自己创建的锁Object        synchronized (object){            // 关注公众号Java3y            // doSomething        }    }}

上面那种方式(随便使用一个对象作为锁)在书上称之为-->客户端锁，这是不建议使用的。

书上想要实现的功能是：给ArrayList添加一个putIfAbsent()，这需要是线程安全的。

假定直接添加synchronized是不可行的

使用客户端锁，会将当前的实现与原本的list耦合了：

书上给出的办法是使用组合的方式(也就是装饰器模式)

1.4.3修饰静态方法

获取到的是类锁(类的字节码文件对象)：Java3y.class

public class Java3y {    // 修饰静态方法代码块，静态方法属于类方法，它属于这个类，获取到的锁是属于类的锁(类的字节码文件对象)-->Java3y.class    public static synchronized void test() {        // 关注公众号Java3y        // doSomething    }}

1.4.4类锁与对象锁

synchronized修饰静态方法获取的是类锁(类的字节码文件对象)，synchronized修饰普通方法或代码块获取的是对象锁。

它俩是不冲突的，也就是说：获取了类锁的线程和获取了对象锁的线程是不冲突的！

public class SynchoronizedDemo {    //synchronized修饰非静态方法    public synchronized void function() throws InterruptedException {        for (int i = 0; i <3; i++) {            Thread.sleep(1000);            System.out.println("function running...");        }    }    //synchronized修饰静态方法    public static synchronized void staticFunction()            throws InterruptedException {        for (int i = 0; i < 3; i++) {            Thread.sleep(1000);            System.out.println("Static function running...");        }    }    public static void main(String[] args) {        final SynchoronizedDemo demo = new SynchoronizedDemo();        // 创建线程执行静态方法        Thread t1 = new Thread(() -> {            try {                staticFunction();            } catch (InterruptedException e) {                e.printStackTrace();            }        });        // 创建线程执行实例方法        Thread t2 = new Thread(() -> {            try {                demo.function();            } catch (InterruptedException e) {                e.printStackTrace();            }        });        // 启动        t1.start();        t2.start();    }}

结果证明：类锁和对象锁是不会冲突的！

1.5重入锁

我们来看下面的代码：

public class Widget {    // 锁住了    public synchronized void doSomething() {        ...    }}public class LoggingWidget extends Widget {    // 锁住了    public synchronized void doSomething() {        System.out.println(toString() + ": calling doSomething");        super.doSomething();    }}