Synchronized关键字锁的到底是什么（新手入门）

之前一直觉得synchronized就是使代码块具有原子性。听了马士兵老师的一个课，说其实锁的是对象，不是很理解。

我的问题是：在下面这个程序里，synchronized到底锁的是整个方法，还是T这个类？

class T{
	private int Tcount=10;

	public synchronized void m1() {
		while(Tcount>4) {
		System.out.print(Thread.currentThread());
		System.out.println(Tcount);
		Tcount--;
		}
	}	
}

我通过实验来说明这个问题：

1.我在课程里看他举的例子

在T里定义两个方法m1,m2，m1加锁。

class T{
	private int Tcount=10;

	public synchronized void m1() {
		while(Tcount>4) {
		System.out.print(Thread.currentThread());
		System.out.println(Tcount);
		Tcount--;
		}
	}	
	
	public void m2() {
		while(Tcount>0) {
		System.out.print(Thread.currentThread());
		System.out.println(Tcount);
		Tcount--;
		}
	}
}

调用：定义两个线程分别调用m1和m2

public static void main(String args[]) {
		//MyRunnable mr=new MyRunnable();
		T t=new T();
		Thread thread=new Thread(t::m1,"m1");
		Thread thread2=new Thread(t::m2,"m2");
		thread.start();
		thread2.start();
	}

结果：

m1和m2是交叉执行的。这很正常，毕竟第二个线程又没调用m1（）对吧。（这个实验很容易误导，让人以为锁的就是m1这个方法。）

2、接下来是重点

如果让m2也加上锁。线程调用不变。

class T{
	private int Tcount=10;

	public synchronized void m1() {
		while(Tcount>4) {
		System.out.print(Thread.currentThread());
		System.out.println(Tcount);
		Tcount--;
		}
	}	
	
	public synchronized void m2() {
		while(Tcount>0) {
		System.out.print(Thread.currentThread());
		System.out.println(Tcount);
		Tcount--;
		}
	}
}

如果synchronized锁的是方法，那就应该是T这个类有两个锁，第一把锁m1，第二把锁m2.这样执行结果应该是thread和thread2各不影响。
如果synchronized锁的是类，那就是说如果thread调用了m1（），锁了T这个类，那此时m2（）也就不能用了。这样对应的结果就应该是thread执行完，释放了T的锁，thread2才会执行。
进行实验：

	public static void main(String args[]) {
		//MyRunnable mr=new MyRunnable();
		T t=new T();
		Thread thread=new Thread(t::m1,"m1");
		Thread thread2=new Thread(t::m2,"m2");
		thread.start();
		thread2.start();
	}

输出结果：

可以看到，thread和thread2是分开的。

所以Synchronized锁的是T这个类！

但是回到第一个实验，既然m1前加了Synchronized，按这个说法，那T不就被锁了，为什么m2还能被调用？
以下是我的理解：
这是因为m2（）这个方法调用的时候根本不需要管它锁没锁。
被Synchronized修饰的方法调用前需要去看看这个类有没有被锁，而没被Synchronized修饰的方法不需要去检查。也就是正确理解一下锁这个类是什么意思。
我的理解，锁这个类其实就是锁的所有被Synchronized关键字修饰的内容。
其实说类也是不准确的，应该说是对象。 每个线程都有自己的堆，是在堆上new出来的那个对象实体上加的锁。
这个也很好做实验：

public static void main(String args[]) {
		//MyRunnable mr=new MyRunnable();
		T t1=new T();
		Thread thread=new Thread(t1::m1,"m1");
		T t2=new T();
		Thread thread2=new Thread(t2::m2,"m2");
		thread.start();
		thread2.start();
	}

得到的结果也是交叉执行的。

——————————————————————————————
此外，我们知道以下两种写法是等价的。这也说明锁的是this类。

public synchronized void m1() {
		while(Tcount>4) {
		System.out.print(Thread.currentThread());
		System.out.println(Tcount);
		Tcount--;
		}
	}	
public void m1() {
		Synchronized(this){
			while(Tcount>4) {
				System.out.print(Thread.currentThread());
				System.out.println(Tcount);
				Tcount--;
			}
		}
		
	}