synchronized 使用问题(一) 多个synchronized方法执行

同一个类中有两个方法都使用synchronized修饰时，会出现什么问题呢?

package com.java.thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import com.learn.frame.spring.utils.DebugLogger;

public class LockTest {
	public synchronized void lock() throws InterruptedException{
		DebugLogger.log("加锁");
		TimeUnit.SECONDS.sleep(2);
	}
	
	public synchronized void unlock(){
		DebugLogger.log("解锁");
	}
	
	public static void main(String[] args) {
		LockTest lock = new LockTest();
		ExecutorService exec = Executors.newCachedThreadPool();
		Runnable run = new Runnable(){
			@Override
			public void run() {
				try {
					lock.lock();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
			}
		};
		Runnable run2 = new Runnable(){
			@Override
			public void run() {
				lock.unlock();
				
			}
		};
		exec.execute(run);
		exec.execute(run2);
		exec.shutdown();
		
	}
}

17:49:16.979 [pool-1-thread-1] DEBUG debug - 加锁
17:49:18.979 [pool-1-thread-2] DEBUG debug - 解锁  (过了2秒后才显示)

synchronized 修饰方法的时候 等同于 synchronized(this){ } 代码块， 锁住的是当前实例类,因此线程2会阻塞直到线程1完成任务。

改进： 不同的方法使用不同的对象锁 

        private Object lock = new Object();
	private Object unlock = new Object();
	public  void lock() throws InterruptedException{
		synchronized(lock){
			DebugLogger.log("加锁");
			TimeUnit.SECONDS.sleep(2);
		}
		
	}
	
	public synchronized void unlock(){
		synchronized (unlock) {
			DebugLogger.log("解锁");
		}
	}

小结:非静态方法中synchronized关键字锁住的是当前对象this