public class study02 {
public static void main(String[] args) {
study02 study =new study02();
Runnable runnable =new Runnable() {
@Override
public void run() {
study.test();
}
};
new Thread(runnable).start();
new Thread(runnable).start();
}
private Objecto =new Object();
public void test(){
synchronized (o){
System.out.println(Thread.currentThread().getName() +" 锁定o这个对象，当代码块获得这把锁的时候才能执行该代码块");
try {
Thread.sleep(1000);
}catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() +" test执行完毕");
}
}
public synchronized void test2(){
System.out.println("锁定的是this");
}
public synchronized static void test3(){
System.out.println("static方法是没有this对象的，synchronized相当于synchronized(Study02.class)");
}
}
synchronized不应该理解成锁定了某段代码或者某个方法，而是锁加在了一个对象上，当代码执行时，获得了该把锁才能运行。
在静态方法上加synvhronized是没有this的，相当于synvhronized(T.class)
synchronized是可重入锁
public class study03 {
public static void main(String[] args) {
study03 study =new study03();
new Thread(()->{
study.m1();
}).start();
}
public synchronized void m1(){
System.out.println(Thread.currentThread().getName()+" m1 start +++++++++++++++");
m2();
System.out.println(Thread.currentThread().getName()+" m1 end +++++++++++");
}
public synchronized void m2(){
System.out.println(Thread.currentThread().getName()+" m2 start");
try {
Thread.sleep(1000);
}catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" m2 end");
}
}
m1和m2都属于study对象，并且都加上了synchronized，程序会判断m1和m2是否在同一线程中，如果是，synchronized可重入。
为什么synchronized是可重入锁，模拟一个父子类概念，如果父类方法加上了synchronized，子类在重写父类方法的时候，调用super方法必需的可重入，否则会出问题（调用父类是同一把锁）。
可重入锁就是你拿到这把锁之后不停的加锁，加好几道锁，但锁定的是同一个对象，去掉就减一，就是这么个概念。
异常锁
当线程出现异常时，线程会自动释放锁，其他线程可获得该锁。
synchronized底层实现
synchronized锁升级概念：
1.偏向锁：第一个去访问某把锁的线程，比如sync(Object)，来了之后先在Object上面markword记录这个线程（如果只有一个线程访问的时候实际上是没有给这个Object加锁的，在内部实现的时候，只是记录了这个线程的ID）
2.自旋锁：偏向锁如果有线程争用的话，会升级为自旋锁，它不会直接去cpu的就绪队列中去，而是用while的循环等着占用cpu，while多次之后仍获取不到锁才会再一次升级
3.重量级锁：自旋锁自旋10次后，升级为重量级锁，去操作系统那里申请资源
线程执行时间短，线程数少，用自旋锁等待；执行时间长，线程数多，用系统锁。
