ReentrantLock与synchronized的区别

ReentrantLock和synchronized都是Java中用来实现同步的手段，它们的功能都是实现线程的互斥访问，但是它们之间还是有一些不同点的。

1. 锁的获取方式不同

synchronized锁的获取是隐式的，即在进入同步代码块或方法时自动获取锁，退出时自动释放锁；

ReentrantLock锁的获取是显式的，需要手动去调用lock()方法获取锁，unlock()方法释放锁。

2. 锁的公平性不同

synchronized是非公平锁，不能保证等待时间最长的线程最先获取锁；

ReentrantLock可以是公平锁，可以保证等待时间最长的线程最先获取锁。

3. 锁的灵活性不同

ReentrantLock提供了很多synchronized不具备的功能，例如可以设置超时时间，可以判断锁是否被其他线程持有，可以使用Condition类实现线程等待/通知机制等。

综上所述：

ReentrantLock 和 Synchronized的区别

	ReentrantLock	Synchronized
锁实现机制	AQS	监视器Monitor
获取锁	可以通过tryLock()尝试获取锁，更灵活	线程抢占模型
释放锁	必须显示通过unlock()释放锁	自动释放
锁类型	支持公平锁和非公平锁	非公平锁
可重入性	可重入	可重入

synchronized 关键字的用法

1修饰实例方法：synchronized修饰实例方法, 则用到的锁，默认为this当前方法调用对象；
2修饰静态方法：synchronized修饰静态方法, 则其所用的锁，默认为Class对象；
3修饰代码块：synchronized修饰代码块, 则其所用的锁，是某个指定Java对象； 

修饰实例方法：

public class Foo {
    // 实例方法
    public synchronized void doSth1() {
        // 获取this锁，才能执行该方法
    }
    
    // 实例方法
    public void doSth2() {
        synchronized(this) {
           // 获取this锁，才能执行该代码块
        }
    }
}

 

public static void main(String[] args) {
    // 实例化一个对象
    Foo fa = new Foo();
	
    // 创建不同的线程1
    Thread thread01 = new Thread() {
        public void run() {
            // 使用相同的对象访问synchronized方法
            fa.doSth1();
        }
    };
	
    // 创建不同的线程2
    Thread thread02 = new Thread() {
        public void run() {
            // 使用相同的对象访问synchronized方法
            fa.doSth1();
        }
    };
    
    // 启动线程
    thread01.start();
    thread02.start();
}

synchronized修饰静态方法 ：

使用当前对象的Class对象充当锁，完成对当前方法的锁定，只有获取Class锁的线程才能访问当前方法；
●不同线程，持有的对象，可以不同，但必须相同class类型；
当使用synchronized 修饰静态方法时, 以下两种写法作用和意义相同：

public class Foo {
    // 静态方法
    public synchronized static void doSth1() {
        // 获取当前对象的Class对象锁，才能执行该方法
    }
    
    // 实例方法
    public static void doSth2() {
        synchronized(this.getClass()) {
        	// 获取当前对象的Class对象锁，才能执行该代码块
        }
    }

public static void main(String[] args) {
    // 创建不同的对象(相同类型)
    Foo fa = new Foo();
    Foo fb = new Foo();

    // 创建不同线程1
    Thread thread01 = new Thread() {
        public void run() {
            // 使用不同的对象访问synchronized方法
            fa.doSth2();
        }
    };

    // 创建不同线程2
    Thread thread02 = new Thread() {
        public void run() {
            // 使用不同的对象访问synchronized方法
            fb.doSth2();
        }
    };

    // 启动线程
    thread01.start();
    thread02.start();
}

synchronized修饰代码块 ：

synchronized(自定义对象) {
   //临界区
}

synchronized 关键字的补充

        当一个线程访问对象的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该对象中的非synchronized(this)同步代码块。
        在没有加锁的情况下, 所有的线程都可以自由地访问对象中的代码, 而synchronized关键字只是限制了线程对于已经加锁的同步代码块的访问，并不会对其他代码做限制。所以，同步代码块应该越短小越好。
        父类中synchronized修饰的方法，如果子类没有重写，则该方法仍然是线程安全性；如果子类重写，并且没有使用synchronized修饰，则该方法不是线程安全的；
        在定义接口方法时，不能使用synchronized关键字；
        构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步；
        离开synchronized代码块后，该线程所持有的锁，会自动释放； 

使用ReentrantLock重构代码：

public class Counter {
    private final Lock lock = new ReentrantLock();
    private int count;

    public void add(int n) {
        lock.lock();
        try {
            count += n;
        } finally {
            lock.unlock();
        }
    }
}

        使用ReentrantLock比直接使用synchronized更安全，用于替代synchronized进行线程同步。在使用synchronized时，可以通过wait()和notify()实现线程等待和唤醒。使用ReentrantLock可以通过Condition实现线程的等待和唤醒。

	// 使用LinkedList作为存储结构
	private Queue<String> queue = new LinkedList<>();
	
	// 使用ReentrantLock可重入锁同步线程
	private final ReentrantLock lock = new ReentrantLock(true);
	
	// 创建锁的Condition条件状态对象
	private final Condition condition = lock.newCondition();

	// 添加元素至队尾
	public void put(String s) {
		// 加锁
		final ReentrantLock lock = this.lock;
		lock.lock();
		try {
			this.queue.offer(s);
			condition.signalAll(); // 唤醒condition等待队列中的所有线程
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			// 解锁
			lock.unlock();
		}
		
	}

	// 获取队首元素
	public String take() throws InterruptedException {
		final ReentrantLock lock = this.lock;
		lock.lock();
		try {
			while (queue.isEmpty()) {
				condition.await(); // 当前线程等待，并放入condition的等待队列中
			}
			return queue.poll();
		} finally {
			lock.unlock();
		}
	}
}

        使用Condition时，引用的Condition对象必须从Lock实例的newCondition()返回，这样才能获得一个绑定了Lock实例的Condition实例。
        Condition提供的await()、signal()、signalAll()和synchronized锁对象的wait()、notify()、notifyAll()行为是一样的：
        ●await()会释放当前锁，进入等待状态；
        ●signal()会唤醒某个等待线程；
        ●signalAll()会唤醒所有等待线程；
        ●唤醒线程从await()返回后需要重新获得锁。
        此外，和tryLock()类似，await()可以在等待指定时间后，如果还没有被其他线程通过signal()或signalAll()唤醒，自动结束等待：