Java多线程下对Synchronized的理解

对于Synchronized学习了多次，但是有时候还是不理解其中的区别，找了很久的材料，才对Synchronized有较深的理解。

1.Synchronized相关概念

    在Java编程中，经常会用到同步，而用的最多也许就是Synchronized这个关键字。首先Synchronized关键字涉及到锁的概念。首先对相关概念进行解释。先借用别人的总结，感觉还不错！！！！

    java的内置锁：每个java对象都可以用做一个实现同步的锁，这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。

    java内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻塞，知道线程B释放这个锁，如果B线程不释放这个锁，那么A线程将永远等待下去。

    java的对象锁和类锁：java的对象锁和类锁在锁的概念上基本上和内置锁是一致的，但是，两个锁实际是有很大的区别的，对象锁是用于对象实例方法，或者一个对象实例上的，类锁是用于类的静态方法或者一个类的class对象上的。我们知道，类的对象实例可以有很多个，但是每个类只有一个class对象，所以不同对象实例的对象锁是互不干扰的，但是每个类只有一个类锁。但是有一点必须注意的是，其实类锁只是一个概念上的东西，并不是真实存在的，它只是用来帮助我们理解锁定实例方法和静态方法的区别的。

2.对象锁

        通过以上相关概念的描述，对Synchronized关键字有了初步的理解，从中可以的出Synchronized的用法：Synchronized修饰方法和Synchronized修饰代码块。为了加深相关概念，通过一段实例加深对相关概念的理解。

public class SynchronizedTest
{
	public void test1() 
    {  
         synchronized(this) 
         {  
              int i = 5;  
              while( i-- > 0) 
              {  
                   System.out.println(Thread.currentThread().getName() + " : " + i);  
                   try 
                   {  
                        Thread.sleep(500);  
                   } 
                   catch (InterruptedException ie) 
                   {  
                   }  
              }  
         }  
    }  
	
	public synchronized void test2() 
    {  
         int i = 5;  
         while( i-- > 0) 
         {  
              System.out.println(Thread.currentThread().getName() + " : " + i);  
              try 
              {  
                   Thread.sleep(500);  
              } 
              catch (InterruptedException ie) 
              {  
              }  
         }  
    }  
	
	public static void main(String[] args)
	{
		final SynchronizedTest myt2 = new SynchronizedTest();
        Thread test1 = new Thread(  new Runnable() {  public void run() {  myt2.test1();  }  }, "test1"  );  
        Thread test2 = new Thread(  new Runnable() {  public void run() { myt2.test2();   }  }, "test2"  );
       
        test1.start();  
        test2.start();  
        
       
	}
}

        上述方法代码中，第一个方法使用了同步代码块的方式进行同步，传入的是对象实例this，表示是当前对象，当然，如果需要同步其他对象，也可以传入其他对象的实例。第二个方法是修饰方法的方式进行同步。其运行结果如下：

因为第一个同步块传入的是this，所以两个同步块代码需要获得的对象锁是同一个对象锁，下面main方法是同时开启两个线程，分别调用test1和test2的方法，那么两个线程都需要获得该对象锁，一个获得之后，另一个线程必须等到哪一个线程结束之后，才能得到线程锁。从结果中我们也可以看出：test2线程结束之后，释放锁，test1线程才开始运行。可能有人会疑问，代码里明明是先开启的test1线程，为什么先执行的是test2线程呢？这是因为java编译器在编译成字节码的时候，会对代码进行一个重排序，也就是说，编译器会根据实际情况对代码进行一个合理的排序，编译前代码写在前面，在编译后的字节码不一定排在前面，所以这种运行结果是正常的， 这里是题外话，最主要是检验synchronized的用法的正确性。

如果我们把test1方法的Synchronized(this)去掉，改在方法上呢？

package SynchronizedTest;


public class SynchronizedTest
{
	public synchronized void test1() 
    {  
         /*synchronized(this) */
         {  
              int i = 5;  
              while( i-- > 0) 
              {  
                   System.out.println(Thread.currentThread().getName() + " : " + i);  
                   try 
                   {  
                        Thread.sleep(500);  
                   } 
                   catch (InterruptedException ie) 
                   {  
                   }  
              }  
         }  
    }  
	
	public synchronized void test2() 
    {  
         int i = 5;  
         while( i-- > 0) 
         {  
              System.out.println(Thread.currentThread().getName() + " : " + i);  
              try 
              {  
                   Thread.sleep(500);  
              } 
              catch (InterruptedException ie) 
              {  
              }  
         }  
    }  
	
	public static void main(String[] args)
	{
		final SynchronizedTest myt2 = new SynchronizedTest();
        Thread test1 = new Thread(  new Runnable() {  public void run() {  myt2.test1();  }  }, "test1"  );  
        Thread test2 = new Thread(  new Runnable() {  public void run() { myt2.test2();   }  }, "test2"  );
       
        test1.start();  
        test2.start();  
        
       
	}
}

运行结果如下，你会发现和上图运行的结果是一样的。从而进一步说明了对象锁的概念。

当我们把test2方法中的Synchronized去掉将会如何呢？

    上面是执行结果，我们可以看到，结果输出是交替着进行输出的，这是因为，某个线程得到了对象锁，但是另一个线程还是可以访问没有进行同步的方法或者代码。进行了同步的方法（加锁方法）和没有进行同步的方法（普通方法）是互不影响的，一个线程进入了同步方法，得到了对象锁，其他线程还是可以访问那些没有同步的方法（普通方法）。这里涉及到内置锁的一个概念（此概念出自java并发编程实战第二章）：对象的内置锁和对象的状态之间是没有内在的关联的，虽然大多数类都将内置锁用做一种有效的加锁机制，但对象的域并不一定通过内置锁来保护。当获取到与对象关联的内置锁时，并不能阻止其他线程访问该对象，当某个线程获得对象的锁之后，只能阻止其他线程获得同一个锁。之所以每个对象都有一个内置锁，是为了免去显式地创建锁对象。

当创建多个对象时，结果又将如何呢？

package SynchronizedTest;


public class SynchronizedTest
{
	public void test1() 
    {  
         synchronized(this) 
         {  
              int i = 5;  
              while( i-- > 0) 
              {  
                   System.out.println(Thread.currentThread().getName() + " : " + i);  
                   try 
                   {  
                        Thread.sleep(500);  
                   } 
                   catch (InterruptedException ie) 
                   {  
                   }  
              }  
         }  
    }  
	
	public synchronized void test2() 
    {  
         int i = 5;  
         while( i-- > 0) 
         {  
              System.out.println(Thread.currentThread().getName() + " : " + i);  
              try 
              {  
                   Thread.sleep(500);  
              } 
              catch (InterruptedException ie) 
              {  
              }  
         }  
    }  
	
	public static void main(String[] args)
	{
		final SynchronizedTest myt2 = new SynchronizedTest();
		final SynchronizedTest myt3 = new SynchronizedTest();
		final SynchronizedTest myt4 = new SynchronizedTest();
        Thread test1 = new Thread(  new Runnable() {  public void run() {  myt2.test1();  }  }, "test1"  );  
        Thread test2 = new Thread(  new Runnable() {  public void run() { myt2.test2();   }  }, "test2"  );
        
        Thread test3 = new Thread(  new Runnable() {  public void run() {  myt3.test1();  }  }, "test3"  );  
        Thread test4 = new Thread(  new Runnable() {  public void run() { myt3.test2();   }  }, "test4"  );
        
        Thread test5 = new Thread(  new Runnable() {  public void run() { myt4.test1();  }  }, "test5"  );  
        Thread test6 = new Thread(  new Runnable() {  public void run() { myt4.test2();   }  }, "test6"  );
        test1.start();  
        test2.start();  
        
        test3.start();  
        test4.start(); 
        
        test5.start();  
        test6.start(); 
	}
}

其运行结果如下：

        实例中有三个不同的对象，六种线程。test1线程和test2线程共享对象myt2；test3线程和test4线程共享对象myt3；test5线程和test6线程共享对象myt4；从结果中得出不同对象实例myt2、myt3、myt4的线程交替进行输出，说明不同对象实例的对象锁是互不干扰。同时你也会发现，先运行myt2的test1线程、myt3的test3线程、myt4的test5线程，然后运行myt2的test2线程、myt3的test4线程、myt4的test6线程.当某一个对象的对象锁被占有之后，这个对象的另一个线程就会等当前运行线程结束，释放对象锁之后才会运行。

3.类锁的修饰方法或者代码块

为详细了解类锁，先看一段代码及其运行结果：

package SynchronizedTest;


public class SynchronizedTest
{
	public void test1() 
    {  
         synchronized(SynchronizedTest.class) 
         {  
              int i = 5;  
              while( i-- > 0) 
              {  
                   System.out.println(Thread.currentThread().getName() + " : " + i);  
                   try 
                   {  
                        Thread.sleep(500);  
                   } 
                   catch (InterruptedException ie) 
                   {  
                   }  
              }  
         }  
    }  
	
	public static synchronized void test2() 
    {  
         int i = 5;  
         while( i-- > 0) 
         {  
              System.out.println(Thread.currentThread().getName() + " : " + i);  
              try 
              {  
                   Thread.sleep(500);  
              } 
              catch (InterruptedException ie) 
              {  
              }  
         }  
    }  
	
	public static void main(String[] args)
	{
		final SynchronizedTest myt2 = new SynchronizedTest();
		/*final SynchronizedTest myt3 = new SynchronizedTest();
		final SynchronizedTest myt4 = new SynchronizedTest();*/
        Thread test1 = new Thread(  new Runnable() {  public void run() {  myt2.test1();  }  }, "test1"  );  
        Thread test2 = new Thread(  new Runnable() {  public void run() { myt2.test2();   }  }, "test2"  );
        
        /*Thread test3 = new Thread(  new Runnable() {  public void run() {  myt3.test1();  }  }, "test3"  );  
        Thread test4 = new Thread(  new Runnable() {  public void run() { myt3.test2();   }  }, "test4"  );
        
        Thread test5 = new Thread(  new Runnable() {  public void run() { myt4.test1();  }  }, "test5"  );  
        Thread test6 = new Thread(  new Runnable() {  public void run() { myt4.test2();   }  }, "test6"  );*/
        test1.start();  
        test2.start();  
        
       /* test3.start();  
        test4.start(); 
        
        test5.start();  
        test6.start(); */
	}
}其

其运行结果如下：

                                     

你会发现他的运行结果和对象锁是一样的，这分辨不出其中的差别。

当出现不同对象实例又当如何呢？

final SynchronizedTest myt2 = new SynchronizedTest();
		final SynchronizedTest myt3 = new SynchronizedTest();
		final SynchronizedTest myt4 = new SynchronizedTest();
        Thread test1 = new Thread(  new Runnable() {  public void run() {  myt2.test1();  }  }, "test1"  );  
        Thread test2 = new Thread(  new Runnable() {  public void run() { myt2.test2();   }  }, "test2"  );
        
        Thread test3 = new Thread(  new Runnable() {  public void run() {  myt3.test1();  }  }, "test3"  );  
        Thread test4 = new Thread(  new Runnable() {  public void run() { myt3.test2();   }  }, "test4"  );
        
        Thread test5 = new Thread(  new Runnable() {  public void run() { myt4.test1();  }  }, "test5"  );  
        Thread test6 = new Thread(  new Runnable() {  public void run() { myt4.test2();   }  }, "test6"  );
        test1.start();  
        test2.start();  
        
        test3.start();  
        test4.start(); 
        
        test5.start();  
        test6.start(); 

其运行结果如下：

                                   

        从结果可以分析得出，类锁是一个类独一无二的，不管这一个类有多少个实例，他的类锁只有一个。当一个类中有很多个线程，对类锁而言，他只能一个线程运行结束之后，释放类锁之后，另一个线程才能运行。

synchronized同时修饰静态和非静态方法时结果又当如何呢？

package SynchronizedTest;


public class SynchronizedTest
{
	public synchronized void test1() 
    {  
         /*synchronized(SynchronizedTest.class)*/ 
         {  
              int i = 5;  
              while( i-- > 0) 
              {  
                   System.out.println(Thread.currentThread().getName() + " : " + i);  
                   try 
                   {  
                        Thread.sleep(500);  
                   } 
                   catch (InterruptedException ie) 
                   {  
                   }  
              }  
         }  
    }  
	
	public static synchronized void test2() 
    {  
         int i = 5;  
         while( i-- > 0) 
         {  
              System.out.println(Thread.currentThread().getName() + " : " + i);  
              try 
              {  
                   Thread.sleep(500);  
              } 
              catch (InterruptedException ie) 
              {  
              }  
         }  
    }  
	
	public static void main(String[] args)
	{
		final SynchronizedTest myt2 = new SynchronizedTest();
		/*final SynchronizedTest myt3 = new SynchronizedTest();
		final SynchronizedTest myt4 = new SynchronizedTest();*/
        Thread test1 = new Thread(  new Runnable() {  public void run() {  myt2.test1();  }  }, "test1"  );  
        Thread test2 = new Thread(  new Runnable() {  public void run() { myt2.test2();   }  }, "test2"  );
        
        /*Thread test3 = new Thread(  new Runnable() {  public void run() {  myt3.test1();  }  }, "test3"  );  
        Thread test4 = new Thread(  new Runnable() {  public void run() { myt3.test2();   }  }, "test4"  );
        
        Thread test5 = new Thread(  new Runnable() {  public void run() { myt4.test1();  }  }, "test5"  );  
        Thread test6 = new Thread(  new Runnable() {  public void run() { myt4.test2();   }  }, "test6"  );*/
        test1.start();  
        test2.start();  
        
       /* test3.start();  
        test4.start(); 
        
        test5.start();  
        test6.start(); */
	}
}

运行结果如下：

                                 

上面代码synchronized同时修饰静态方法和实例方法，但是运行结果是交替进行的，这证明了类锁和对象锁是两个不一样的锁，控制着不同的区域，它们是互不干扰的。同样，线程获得对象锁的同时，也可以获得该类锁，即同时获得两个锁，这是允许的。

当出现多个实例之后，又当如何呢？

package SynchronizedTest;


public class SynchronizedTest
{
	public synchronized void test1() 
    {  
         /*synchronized(SynchronizedTest.class)*/ 
         {  
              int i = 5;  
              while( i-- > 0) 
              {  
                   System.out.println(Thread.currentThread().getName() + " : " + i+" 对象锁被占用--");  
                   try 
                   {  
                        Thread.sleep(500);  
                   } 
                   catch (InterruptedException ie) 
                   {  
                   }  
              }  
         }  
    }  
	
	public static synchronized void test2() 
    {  
         int i = 5;  
         while( i-- > 0) 
         {  
              System.out.println(Thread.currentThread().getName() + " : " + i+" 类锁占用+++");  
              try 
              {  
                   Thread.sleep(500);  
              } 
              catch (InterruptedException ie) 
              {  
              }  
         }  
    }  
	
	public static void main(String[] args)
	{
		final SynchronizedTest myt2 = new SynchronizedTest();
		final SynchronizedTest myt3 = new SynchronizedTest();
		final SynchronizedTest myt4 = new SynchronizedTest();
        Thread test1 = new Thread(  new Runnable() {  public void run() {  myt2.test1();  }  }, "test1"  );  
        Thread test2 = new Thread(  new Runnable() {  public void run() { myt2.test2();   }  }, "test2"  );
        
        Thread test3 = new Thread(  new Runnable() {  public void run() {  myt3.test1();  }  }, "test3"  );  
        Thread test4 = new Thread(  new Runnable() {  public void run() { myt3.test2();   }  }, "test4"  );
        
        Thread test5 = new Thread(  new Runnable() {  public void run() { myt4.test1();  }  }, "test5"  );  
        Thread test6 = new Thread(  new Runnable() {  public void run() { myt4.test2();   }  }, "test6"  );
        test1.start();  
        test2.start();  
        
        test3.start();  
        test4.start(); 
        
        test5.start();  
        test6.start(); 
	}
}

运行结果如下：

                                 

通过这个结果，可以得出分析：1.这证明了类锁和对象锁是两个不一样的锁，控制着不同的区域，它们是互不干扰的。同样，线程获得对象锁的同时，也可以获得该类锁，即同时获得两个锁，这是允许的。

2.一个对象的线程，如果他的一个线程运行的是类锁，那么就不能运行对象锁，myt2下的线程test1、myt3下的线程test3、myt4下的线程test5运行的是对象锁。则其他运行的是类锁。

4.问题发现：

到这里，对synchronized的用法已经有了一定的了解。这时有一个疑问，既然有了synchronized修饰方法的同步方式，为什么还需要synchronized修饰同步代码块的方式呢？而这个问题也是synchronized的缺陷所在

 synchronized的缺陷：当某个线程进入同步方法获得对象锁，那么其他线程访问这里对象的同步方法时，必须等待或者阻塞，这对高并发的系统是致命的，这很容易导致系统的崩溃。如果某个线程在同步方法里面发生了死循环，那么它就永远不会释放这个对象锁，那么其他线程就要永远的等待。这是一个致命的问题。
 
当然同步方法和同步代码块都会有这样的缺陷，只要用了synchronized关键字就会有这样的风险和缺陷。既然避免不了这种缺陷，那么就应该将风险降到最低。这也是同步代码块在某种情况下要优于同步方法的方面。例如在某个类的方法里面：这个类里面声明了一个对象实例，SynObject so=new SynObject()；在某个方法里面调用了这个实例的方法so.testsy();但是调用这个方法需要进行同步，不能同时有多个线程同时执行调用这个方法。

这时如果直接用synchronized修饰调用了so.testsy();代码的方法，那么当某个线程进入了这个方法之后，这个对象其他同步方法都不能给其他线程访问了。假如这个方法需要执行的时间很长，那么其他线程会一直阻塞，影响到系统的性能。

如果这时用synchronized来修饰代码块：synchronized（so）{so.testsy();}，那么这个方法加锁的对象是so这个对象，跟执行这行代码的对象没有关系，当一个线程执行这个方法时，这对其他同步方法时没有影响的，因为他们持有的锁都完全不一样。

不过这里还有一种特例，就是上面演示的第一个例子，对象锁synchronized同时修饰方法和代码块，这时也可以体现到同步代码块的优越性，如果test1方法同步代码块后面有非常多没有同步的代码，而且有一个100000的循环，这导致test1方法会执行时间非常长，那么如果直接用synchronized修饰方法，那么在方法没执行完之前，其他线程是不可以访问test2方法的，但是如果用了同步代码块，那么当退出代码块时就已经释放了对象锁，当线程还在执行test1的那个100000的循环时，其他线程就已经可以访问test2方法了。这就让阻塞的机会或者线程更少。让系统的性能更优越。

一个类的对象锁和另一个类的对象锁是没有关联的，当一个线程获得A类的对象锁时，它同时也可以获得B类的对象锁。