关于同步的几个问题

一、方步同步与同步块，如果方法与同步块的逻辑一样，效率是否一样？

      public  synchronized void  sum(long j){
    	  System.out.println(j);
    	   long sum=0;
    	   for(long i=0;i<100000000;i++){
    		   sum=sum+i;
    	   }
    	   System.out.println(j+"===="+sum);
      }
      public void  sum2(long j){
    	  synchronized(this){
    	   System.out.println(j);
    	   long sum=0;
       	   for(long i=0;i<100000000;i++){
       		 sum=sum+i;
       	   }
       	   System.out.println(j+"===="+sum);
    	  }
      }

         使用的都是同一对象锁，效率不一样，测试发现方法同步要快，也就是同步块处理锁机制跟复杂些，同步块的优势在于精确控制锁的作用域，如能缩小锁范围，同步块具有优势，而且同步块扩展性更好，可以用锁分解，锁分段（ConcurrentHashMap实现机制）。

二、同步锁机制对每次new一个对象实例有效吗？

          同步锁只对同一个对象锁有效，对不同的对象是不同的对象锁。

三、对象上不同方法上的同步，是否是同一锁？

          是的，是同一对象锁，正因为是同一对象锁，也就保证对象属性的更新，修改，查询是原子操作，是串行的。

四、静态类的父类同步方法，静态子类间调用父类同步方法，是否是不同锁？

          不是，都是使用的父类对象锁，也就是说静态类虽然不一样，但是如果都是调用父类方法，还是会存在竞争锁，导致线程等待。

          如果是调用静态子类本身的同步方法，则使用的是各自静态子类的对象锁，不存在互相竞争锁。

父类：

public abstract class AbstractTest4 {
	public static  synchronized void  sum(String j){
  	  System.out.println(j);
  	   long sum=0;
  	   for(long i=0;i<1000000000;i++){
  		   sum=sum+i;
  	   }
  	   System.out.println(j+"===="+sum);
    }
    public static void  sum2(Class j){
  	  synchronized(j){
  	   System.out.println(j);
  	   long sum=0;
     	   for(long i=0;i<1000000000;i++){
     		 sum=sum+i;
     	   }
     	   System.out.println(j+"===="+sum);
  	  }
    }
    public  static void main(String[] args) throws InterruptedException{
  	  ExecutorService service1 = Executors.newFixedThreadPool(2*3);
  	  for(int j=0;j<100;j++){
      	  service1.execute(new Runnable(){
				@Override
				public void run() {
					//Test5.sum2(Test5.class);
					Test5.sum3(Thread.currentThread().getId());
					//Test5.sum("test5");
				}
      	  });
  	  }
  	  
  	  ExecutorService service2 = Executors.newFixedThreadPool(2*3);
  	  for(int j=0;j<100;j++){
      	  service2.execute(new Runnable(){
				@Override
				public void run() {
					//Test6.sum2(Test6.class);
					Test6.sum3(Thread.currentThread().getId());
					//Test6.sum("test6");
				}
      	  });
  	  }
    }
}

子类：

public  class Test5  extends AbstractTest4{
	public static  synchronized void  sum3(long j){
	  	  System.out.println(j);
	  	   long sum=0;
	  	   for(long i=0;i<1000000000;i++){
	  		   sum=sum+i;
	  	   }
	  	   System.out.println(j+"test5===="+sum);
	    }
}

public  class Test6  extends AbstractTest4{
	public static  synchronized void  sum3(long j){
	  	  System.out.println(j);
	  	   long sum=0;
	  	   for(long i=0;i<1000000000;i++){
	  		   sum=sum+i;
	  	   }
	  	   System.out.println(j+"test6===="+sum);
	    }
}