ReentrantLock和Synchronized

ReentrantLock

1.继承关系
public class ReentrantLock implements Lock, java.io.Serializable
1.内部类
1.FairSync(final class FairSync extends Sync)公平

主要方法 1.final void lock 2.protected final boolean tryAcquire(int acquires)(获取锁可以通过返回值判断有没有获取成功)

2.NonfairSync(final class NonfairSync extends Sync)非公平(默认)

主要方法 1.final void lock 2.protected final boolean tryAcquire(int acquires)(获取锁可以通过返回值判断有没有获取成功)

3.Sync(static class Sync extends AbstractQueuedSynchronizer)
AbstractQueuedSynchronizer(数据结构为node双向链表ConditionObject为单向链表 源码解读)
2.构造函数
1.ReentrantLock()型构造函数

public ReentrantLock() {
        // 默认非公平策略
        sync = new NonfairSync();
    }

2.ReentrantLock(boolean)型构造函数

public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

3.属性

	// 序列号
    private static final long serialVersionUID = 7373984872572414699L;    
    // 同步队列
    private final Sync sync;

详细源码链接

Synchronized

1.锁对象

1.1锁对象的整个方法：

public synchronized void test() {
 
        System.out.println("锁对象的整个方法");
 
}

1.2锁对象方法的部分代码：

public  void test1() {
 
        synchronized(this) {
 
            System.out.println("2. 锁对象方法的部分代码");
 
        }
}

1.3锁特定对象：

private Object obj = new Object();
 
public void test4() {
 
     synchronized(obj) {//this等
 
         System.out.println("锁特定对象的代码");
 
     }
 
}

2.锁类
2.1锁类的静态方法：

public static  synchronized  void test2() {
 
        System.out.println("锁类的整个方法");
 
}

2.2锁类的方法的部分：

public static  void test3() {
 
     synchronized(SynchronizedTest.class) {
 
         System.out.println("锁类的方法的部分代码");
 
     }
 
}

Java中的对象锁和类锁：
对象锁是用于对象实例方法，或者一个对象实例上的(this)，
类锁是用于类的静态方法或者一个类的class对象上的。
我们知道，类的对象实例可以有很多个，但是每个类只有一个class对象，所以不同对象实例的对象锁是互不干扰的，但是每个类只有一个类锁
详细链接

总结

Lock和synchronized有以下几点不同

	1 Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现 
　　2 synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁
	3 Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断(ReentrantLock中的lockInterruptibly()方法使得线程可以在被阻塞时响应中断，比如一个线程t1通过lockInterruptibly()方法获取到一个可重入锁，并执行一个长时间的任务，另一个线程通过interrupt()方法就可以立刻打断t1线程的执行，来获取t1持有的那个可重入锁。而通过ReentrantLock的lock()方法或者Synchronized持有锁的线程是不会响应其他线程的interrupt()方法的，直到该方法主动释放锁之后才会响应interrupt()方法)
	4 通过Lock可以知道有没有成功获取锁，而synchronized却无法办到
	5 Lock可以提高多个线程进行读操作的效率
	6 synchronized是非公平锁 Lock可以设置公平非公平

在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。

本文地址：https://blog.csdn.net/mengml_smile/article/details/107491504