synchronized 使用场景

package test;

public class ThreadJoinTest {

    private static class Count extends Thread{
        private ThreadJoinTest simplOper;
        
        Object obj = new Object();
        
        public Count(ThreadJoinTest simplOper){
            this.simplOper = simplOper;
        }
         
        @Override
        public  void run() { 
                for (int i = 0; i < 10000; i++) {
                     simplOper.add3();    
                } 
        }
    }
    
    long count =0;
            

//场景一，直接在当前对象，也就是在ThreadJoinTest上加锁
    public  void add1(){
        synchronized(this){
        count++;
        }
    }
    

//场景二，在方法上加锁
    public synchronized void add2(){ 
        count++; 
    }
    

//场景三，创建一个OBJECT对象，对这个对象进行加锁
    Object obj = new Object();
    public  void add3(){ 
        synchronized (obj) {
            count++; 
        }
    }

    /**
     * 这种方式的锁是错误的，因为Integer的++ 在JDK内部会自动重新new一个新的Integer对象，从而改变了内存地址
     */
    public  void add4(){ 
        synchronized(this.count){
        count++; 
        }
    }

    public static void main(String[] args) {
        ThreadJoinTest tjt =new ThreadJoinTest();
        Count c1= new Count(tjt);
        Count c2= new Count(tjt);
        
        c1.start();
        c2.start();
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(tjt.count);
    } 
}