Synchronized 个人理解

 

1.synchronized方法相当于synchronized（this）

     Synchronized 方法是锁的当前对象，同一个对象的2个synchronized方法被2个线程调用会发生阻塞；

2.static synchronized方法相当于synchronized（this.class）

　　static synchronized方法是锁当前对象的Class,被所有此类的实例共享，多个线程调用此类的static synchronized方法会发生阻塞

 

package com.lly.base.syn;
/**
 * synchronized阻塞测试
 * 1.synchronized方法相当于synchronized（this）
 *         Synchronized 方法是锁的当前对象，同一个对象的2个synchronized方法被2个线程调用会发生阻塞；
 * 2.static synchronized方法相当于synchronized（this.class）　
 *         static synchronized方法是锁当前对象的Class,被所有此类的实例共享，多个线程调用此类的static synchronized方法会发生阻塞
 * 
 * @author liuly
 *
 */
public class SynchronizedTest {

    public static void main(String[] args) {
        Syn1 n1 = new Syn1();
        Syn1 n2 = new Syn1();
//        
//        /******两个线程会阻塞 （对象锁）**/    
//        new Thread(()->{
//            System.out.println("线程1 启动");
//            n1.add1();
//            
//        }).start();
//        
//        new Thread(()->{
//            System.out.println("线程2 启动");
//            n1.add1();
//            
//        }).start();
//        
//        /******两个线程会阻塞 （对象锁）  add1 add2 锁定同一个对象n1**/    
//        new Thread(()->{
//            System.out.println("线程1 启动");
//            n1.add1();
//            
//        }).start();
//        
//        new Thread(()->{
//            System.out.println("线程2 启动");
//            n1.add2();
//            
//        }).start();
//        
//        /******两个线程不会阻塞（static add3是类锁，而add2 是对象锁 ） **/    
//        new Thread(()->{
//            System.out.println("线程1 启动");
//            n1.add2();
//            
//        }).start();
//        
//        new Thread(()->{
//            System.out.println("线程2启动");
//            n2.add3();
//            
//        }).start();
//        /******两个线程不会阻塞（static add3是类锁,虽然不是一个对象，但都是锁定同一个Syn1.class ） **/    
//        new Thread(()->{
//            System.out.println("线程1 启动");
//            n1.add3();
//            
//            }).start();
//        
//        new Thread(()->{
//            System.out.println("线程2 启动");
//            n2.add3();
//            
//        }).start();
        
    }
}


class Syn1{
    /*
     * 非静态方法一：add1 
     * 同一个对象的add1方法会与add2阻塞
     */
    public  synchronized void add1(){
        System.out.println("add1 begin");
        try {
            Thread.sleep(4000);
            System.out.println("add1 end");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    /*
     * 非静态方法一：add2 
     * 
     */
    public synchronized void  add2(){
        System.out.println("add2  begin");
        
        try {
            Thread.sleep(1000);
            System.out.println("add2 end");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    /*
     * 静态方法一：add3 
     * 所有的调用add3方法的线程都会阻塞
     * 
     * 注：add3不会与add1（or add2）阻塞
     */
    public static synchronized void  add3(){
        System.out.println("add3  begin");
        
        try {
            Thread.sleep(1000);
            System.out.println("add3 end");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}