synchronized

synchronized：关于java中这个关键词我想用操作系统里边的解释会更容易理解，当一个线程抢占到资源是时另外一个线程在等候，

第一种 ：可以理解为当线程ta抢占到内存中的资源后,一直到ta结束tb也没有抢占到内存中的资源，结果执行的顺序就是一直输出ta,知道ta全部输出，在输出tb;

第二种：也可以用类似于第一种的方法来理解当t1执行之后让线程睡了5秒t1和t2在内存中抢占资源谁抢占到就是谁先执行。

第三种：可以因为都是同步的一但t1抢占到资源之后，t2就不会在抢占到内存中的资源，直到t1执行完毕才会执行t2,可以说就像你走路一样忽然前面出现个障碍物阻碍了你前进，当你把障碍物清除了就可以继续前进。

若有兴趣可以试一下两个方法都不让同步，那就是t1和t2谁先抢占到资源控制台就会先输出谁。

第一种：当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

public class Thread2 implements Runnable {  
    public void run() {  
         synchronized(this) {  
              for (int i = 0; i < 5; i++) {  
           
  System.out.println(Thread.currentThread().getName()+"synchronized loop"+i); 
              }  
         }  
    }  
 
public static void main(String[] args) {  
         Thread2  t1= new Thread2();  
         Thread ta = new Thread(t1, "A");  
         Thread tb = new Thread(t1, "B");  
         ta.start();  
         tb.start();  
    } 

}

第二种：当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

public class Thread1 {  

    public void m4t1() {  

         synchronized(this) {  

              int i = 5;  

              while( i-- > 0) {  

                   System.out.println(Thread.currentThread().getName() + " : " + i);  

                   try {  

                        Thread.sleep(500);  

                   } catch (InterruptedException ie) {  

                   }  

              }  

         }  

    }  

    public void m4t2() {  

         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 Thread1 myt2 = new Thread1();  

         Thread t1 = new Thread(  new Runnable() {  public void run() {  myt2.m4t1();  }  }, "t1"  );  

         Thread t2 = new Thread(  new Runnable() {  public void run() { myt2.m4t2();   }  }, "t2"  );  

         t1.start();  

         t2.start();  

    } 

}

第三种：当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

public class Thread1 {  

public void m4t1() {  

   synchronized(this) {  

        int i = 5;  

        while( i-- > 0) {  

             System.out.println(Thread.currentThread().getName() + " : " + i);  

             try {  

                  Thread.sleep(500);  

             } catch (InterruptedException ie) {  

             }  

        }  

   }  

}  

public void m4t2() {  

   synchronized(this) {  

   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 Thread1 myt2 = new Thread1();  

   Thread t1 = new Thread(  new Runnable() {  public void run() {  myt2.m4t1();  }  }, "t1"  );  

   Thread t2 = new Thread(  new Runnable() {  public void run() { myt2.m4t2();   }  }, "t2"  );  

   t1.start();  

   t2.start();  

} 

}

//前三种对其他对象锁同样适用

public class Thread1 { 

    class Inner { 

         private void m4t1() { 

              int i = 5; 

              while(i-- > 0) { 

                   System.out.println(Thread.currentThread().getName() + " : Inner.m4t1()=" + i); 

                   try { 

                        Thread.sleep(500); 

                   } catch(InterruptedException ie) { 

                   } 

              } 

         } 

         private void m4t2() { 

              int i = 5; 

              while(i-- > 0) { 

                   System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i); 

                   try { 

                        Thread.sleep(500); 

                   } catch(InterruptedException ie) { 

                   } 

              } 

         } 

    } 

    private void m4t1(Inner inner) { 

         synchronized(inner) 

         { //使用对象锁 

         inner.m4t1();

         }

    } 

    private void m4t2(Inner inner) { 

         inner.m4t2(); 

    } 

    public static void main(String[] args) { 

         final Thread1 myt3 = new Thread1(); 

         final Inner inner = myt3.new Inner(); 

         Thread t1 = new Thread( new Runnable() {public void run() { myt3.m4t1(inner);} }, "t1"); 

         Thread t2 = new Thread( new Runnable() {public void run() { myt3.m4t2(inner);} }, "t2"); 

    t1.start(); 

    t2.start(); 

 } 

}