synchronized(4)修饰语句块之：synchronized(this)

synchronized(this)

　　此时,线程获得的是对象锁.例如:

 public class Thread8 extends Thread {

     public void sync_fun() {
         synchronized (this) {
             int i = ;
             while (i-- > ) {
                 System.out
                         .println(Thread.currentThread().getName() + " : " + i);
                 try {
                     Thread.sleep();
                 } catch (InterruptedException ie) {
                 }
             }
         }
     }
     public static void main(String args[]) {
         final Thread8 t8 = new Thread8();
         Thread t1 = new Thread(new Runnable() {
             @Override
             public void run() {
                 t8.sync_fun();
             }
         }, "t1");
         Thread t2 = new Thread(new Runnable() {
             @Override
             public void run() {
                 t8.sync_fun();
             }
         }, "t2");
         Thread t3 = new Thread(new Runnable() {
             @Override
             public void run() {
                 t8.sync_fun();
             }
         }, "t3");
         Thread t4 = new Thread(new Runnable() {
             @Override
             public void run() {
                 t8.sync_fun();
             }
         }, "t4");
         Thread t5 = new Thread(new Runnable() {
             @Override
             public void run() {
                 t8.sync_fun();
             }
         }, "t4");
         Thread t6 = new Thread(new Runnable() {
             @Override
             public void run() {
                 t8.sync_fun();
             }
         }, "t4");
         t1.start();
         t2.start();
         t3.start();
         t4.start();
         t5.start();
         t6.start();
     }
 }

结果:

t1 : 4
t1 : 3
t1 : 2
t1 : 1
t1 : 0
t4 : 4
t4 : 3
t4 : 2
t4 : 1
t4 : 0
t4 : 4
t4 : 3
t4 : 2
t4 : 1
t4 : 0
t4 : 4
t4 : 3
t4 : 2
t4 : 1
t4 : 0
t3 : 4
t3 : 3
t3 : 2
t3 : 1
t3 : 0
t2 : 4
t2 : 3
t2 : 2
t2 : 1
t2 : 0

当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。在对象级使用锁通常是一种比较粗糙的方法。为什么要将整个对象都上锁，而不允许其他线程短暂地使用对象中其他同步方法来访问共享资源？如果一个对象拥有多个资源，就不需要只为了让一个线程使用其中一部分资源，就将所有线程都锁在外面。由于每个对象都有锁，可以如下所示使用虚拟对象来上锁：

 class FineGrainLock {

    MyMemberClass x, y;
    Object xlock = new Object(), ylock = new Object();

    public void foo() {
       synchronized(xlock) {
          //access x here
       }

       //do something here - but don't use shared resources

       synchronized(ylock) {
          //access y here
       }
    }

    public void bar() {
       synchronized(this) {
          //access both x and y here
       }
       //do something here - but don't use shared resources
    }
 }