如题，有点难理解哟

1. class A{
   
2. synchronized void method(){
   
3. 
   
4. }
   
5. }

复制代码

method()是同步函数，使用的锁是A.this对象;
同步函数的锁是系统指定的
同步代码快的锁可以由自己指定类似于

1. synchronized(obj){}

复制代码

详细解释在代码里，希望能帮到楼主。

1. public class Demon {
   
2.         //1.静态方法同步函数
   
3.         public static synchronized void method1(){
   
4.                  
   
5.         }
   
6.         //2.非静态方法同步
   
7.    public  synchronized void method2(){
   
8.                  
   
9.                 }
   
10.    
    
11.   //3.这个方法可以等价与静态方法同步函数，即静态方法同步函数省略了锁为Demon.class的静态代码块,因为静态方法是被类本身调用的，而每个类初始化的时候加载了class字节码，所以锁是Demon.class
    
12.     public void method3(){
    
13.             synchronized(Demon.class){
    
14.                     
    
15.             }        
    
16.     }
    
17.    //4这个方法可以等价为非静态方法同步函数，也就是非静态方法底层的实现原理
    
18.    //注意这个时候，静态代码块的锁就是this,因为函数需要被对象调用，那么函数都有一个所属对象引用，所以用this。
    
19.     public void method4(){
    
20.             synchronized(this){
    
21.                     
    
22.             }
    
23.     }
    
24.     //最后重要的一点是，需要同步的一般是多线程的情况，并且涉及到操作共享数据。
    
25. }

复制代码

下面通过卖票的代码给楼主解析吧。。。

class DemoTecket implements Runnable
{
        private int ticket = 100;
        Object obj = new Object();
        boolean flag = true;

        public void run()
        {
                if(flag)
                {
                        while(true)
                        {
                                synchronized(this)//因为run方法调用的show()方法，show方法调用的是this.所以这里是this
                                {
                                        if(ticket>0)
                                        {
                                                try{Thread.sleep(10);}catch(Exception e){}
                                                System.out.println(Thread.currentThread().getName()+"...同步售票："+ticket--);
                                        }
                                }
                        }
                }
                else
                {
                        while(true)
                        {
                                show();
                        }
                }
        }

                public synchronized void show()
                {
                        if(ticket>0)
                        {
                                try{Thread.sleep(10);}catch(Exception e){}
                                System.out.println(Thread.currentThread().getName()+"...函数售票："+ticket--);
                        }
                }
       
       
}
public class 同步函数的锁是this {
       
        public static void main(String[]args)
        {
                DemoTecket dt = new DemoTecket();
               
                Thread t1 = new Thread(dt);
                Thread t2 = new Thread(dt);
                Thread t3 = new Thread(dt);
                Thread t4 = new Thread(dt);
                t1.start();
               
               
                //重点：先让主线程停止10毫秒，当程序执行到t2后，执行一会儿，主线程突然醒了，然后执行主线程
                //原因是，main主函数线程会瞬间将两个线程开启执行，
                //所以当线程执行到t.falg=false时，会直接执行到show方法
                try{Thread.sleep(10);}catch(Exception e){}
                dt.flag=false;
                t2.start();               
        }

}
希望对你有帮助。。。。

学习下 大家加油

同步就是锁机制，一说同步，肯定有锁，可是同步函数没有标识用的哪个锁，所以要讨论这个问题，讨论结果是，用的this，this代表本类对象，也就是说同步函数用本类对象作为锁！