让星星⭐月亮告诉你，Java synchronized(*.class) synchronized 方法 synchronized(this)分析

⭐⭐⭐结论🌙🌙🌙:

1. synchronized(SynchronizedTest.class)锁加在类上,若有多个类的实例对象,则同一时刻只能由一个类的实例对象(拥有t1的线程th1)获取到该类上的锁,其他类的实例对象(拥有t2的线程th2)需要等待
2. synchronized void synchronizedMethod() 锁加在普通方法上,同一时刻多个实例对象访问到该方法时,每个实例对象都可以进行方法的执行
3. synchronized void synchronizedMethod() 锁加在当前实例对象上,多个线程拥有同一个实例对象,同一时刻只能有一个拥有该实例对象的线程获得该方法锁进而执行方法,其他拥有该实例对象的线程需要等待

⭐⭐⭐代码🌙🌙🌙:

package unittest.thread;
public class SynchronizedTest {
   
 //锁住class对象
// public static  void synchronizedStatic(){
   
    public void synchronizedStatic(){
   
     synchronized(SynchronizedTest.class){
   
         for(int i = 0 ; i < 10 ; i ++){
   
             System.out.println(Thread.currentThread().getName() + i + ":synchronizedStatic");
             try {
   Thread.sleep(100);} catch (InterruptedException e) {
    e.printStackTrace();}
         }
     }
 }
 //锁住方法，lock标记打在该实例上
 public synchronized void synchronizedMethod(){
   
     for(int i = 0 ; i < 10 ; i ++){
   
         System.out.println(Thread.currentThread().getName() + i + ":synchronizedMethod");
         try {
   Thread.sleep(100);} catch (InterruptedException e) {
    e.printStackTrace();}
     }
 }
 //不会有影响，正常调用
 public  void synchronizedMethod2WithNosynchronized(){
   System.out.println("synchronizedMethod2WithNosynchronized"); }
 //synchronizedMethod 已经锁住实例，再加锁不成功
 public void synchronizedMethod2(){
   
     synchronized( this ){
   
         for(int i = 0 ; i < 10 ; i ++){
   
             System.out.println(Thread.currentThread().getName() + i + ":synchronizedMethod2");
             try {
   Thread.sleep(100);} catch (InterruptedException e) {
    e.printStackTrace();}
         }
     }
 }
 //synchronizedMethod 已经锁住实例， 再加锁不成功
 public void synchronizedMethod3(){
   synchronized( this ){
     System.out.println("synchronizedMethod3"); } }
 public static void main(String[] args) throws InterruptedException {
   
    final SynchronizedTest t= new SynchronizedTest();
    final SynchronizedTest t1= new SynchronizedTest();
    final SynchronizedTest t2= new SynchronizedTest();
//synchronized(SynchronizedTest.class)锁加在类上,若有多个类的实例对象,则同一时刻只能由一个类的实例对象(拥有t1的线程th1)获取到该类上的锁,其他类的实例对象(拥有t2的线程th2)需要等待
//Thread th1 = new Thread( new Runnable(){ @Override   public void run() {  SynchronizedTest.synchronizedStatic(); } } ,"线程th1-");  th1.start();
//Thread th2 = new Thread( new Runnable(){ @Override   public void run() {  SynchronizedTest.synchronizedStatic(); } } ,"线程th2-");  th2.start();
//Thread th1 = new Thread( new Runnable(){ @Override   public void run() {  t1.synchronizedStatic(); } } ,"线程th1-");  th1.start();
//Thread th2 = new Thread( new Runnable(){ @Override   public void run() {  t2.synchronizedStatic(); } } ,"线程th2-");  th2.start();

//synchronized void synchronizedMethod() 锁加在普通方法上,同一时刻多个实例对象访问到该方法时,每个实例对象都可以进行方法的执行
//Thread th3 = new Thread( new Runnable(){ @Override public void run() {t1.synchronizedMethod();} } ,"线程th3-"); th3.start();
//Thread th4 = new Thread( new Runnable(){ @Override public void run() { t2.synchronizedMethod();} } ,"线程th4-");  th4.start();
//synchronized void synchronizedMethod() 锁加在普通方法上,多个线程拥有同一个实例对象,同一时刻只能有一个拥有该实例对象的线程获得该方法锁进而执行方法,其他拥有该实例对象的线程需要等待
//Thread th3 = new Thread( new Runnable(){ @Override public void run() {t.synchronizedMethod();} } ,"线程th3-"); th3.start();
//Thread th4 = new Thread( new Runnable(){ @Override public void run() { t.synchronizedMethod();} } ,"线程th4-");  th4.start();

  //synchronized void synchronizedMethod() 锁加在当前实例对象上,多个线程拥有同一个实例对象,同一时刻只能有一个拥有该实例对象的线程获得该方法锁进而执行方法,其他拥有该实例对象的线程需要等待
//Thread th5 = new Thread( new Runnable(){ @Override public void run() { t.synchronizedMethod2();} } ,"线程th5-");  th5.start();
//Thread th6 = new Thread( new Runnable(){ @Override public void run() { t.synchronizedMethod2();} } ,"线程th6-");  th6.start(); 
  /*
  t.synchronizedMethod2WithNosynchronized();
  t.synchronizedMethod3();
  */
 }
}

```