synchronized

作用于对象实例：对给定对象加锁，进入同步代码前要获得给定对象的锁。

作用于实例方法：相当于对当前实例加锁，进入同步代码前要获得当前实例的锁。

作用于静态方法：相当于对当前类加锁，进入同步代码前要获得当前类的锁。

使用

给实例对象加锁

public class AccountingSync implements Runnable {
    static AccountingSync instance = new AccountingSync();
    static int i = 0;

    @Override
    public void run() {
        for (int k = 0; k < 10000; k++) {
            synchronized (instance) {
                i++;
            }
        }
    }

    @Test
    public void testInteger() throws InterruptedException {
        int count = 10;
        Thread[] ts = new Thread[count];

        for (int k = 0; k < count; k++) {
            ts[k] = new Thread(instance);
        }

        // start
        for (int k = 0; k < count; k++) {
            ts[k].start();
        }

        // join
        for (int k = 0; k < count; k++) {
            ts[k].join();
        }

        System.out.println(i);
    }
}

给类方法加锁

public class AccountingSync2 implements Runnable {
    static AccountingSync2 instance = new AccountingSync2();
    static int i = 0;

    public synchronized void increase() {
        i++;
    }

    @Override
    public void run() {
        for (int k = 0; k < 10000; k++) {
            increase();
        }
    }

    @Test
    public void testInteger() throws InterruptedException {
        int count = 10;
        Thread[] ts = new Thread[count];

        for (int k = 0; k < count; k++) {
            ts[k] = new Thread(instance);
        }

        // start
        for (int k = 0; k < count; k++) {
            ts[k].start();
        }

        // join
        for (int k = 0; k < count; k++) {
            ts[k].join();
        }

        System.out.println(i);
    }
}

给类方法加锁的错误演示

public class AccountingSyncBad implements Runnable {
    static int i = 0;

    public synchronized void increase() {
        i++;
    }

    @Override
    public void run() {
        for (int k = 0; k < 10000; k++) {
            increase();
        }
    }

    @Test
    public void testInteger() throws InterruptedException {
        int count = 10;
        Thread[] ts = new Thread[count];

        for (int k = 0; k < count; k++) {
            ts[k] = new Thread(new AccountingSyncBad());
        }

        // start
        for (int k = 0; k < count; k++) {
            ts[k].start();
        }

        // join
        for (int k = 0; k < count; k++) {
            ts[k].join();
        }

        System.out.println(i);
    }
}

假设把给类实例加锁中的每个实例比作一个门，上面的测试方法中每个门都有锁但是10个门10把锁，每个线程进一个门。还是不能保证临界区资源i同时只一个线程访问

fix

@Test
public void testIntegerFix() throws InterruptedException {
  int count = 10;
  AccountingSyncBad instance = new AccountingSyncBad();
  Thread[] ts = new Thread[count];

  for (int k = 0; k < count; k++) {
    ts[k] = new Thread(instance);
  }

  // start
  for (int k = 0; k < count; k++) {
    ts[k].start();
  }

  // join
  for (int k = 0; k < count; k++) {
    ts[k].join();
  }

  System.out.println(i);
}

给静态类方法加锁

public class AccountingSyncClass implements Runnable {
    static int i = 0;

    public static synchronized void increase() {
        i++;
    }

    @Override
    public void run() {
        for (int k = 0; k < 10000; k++) {
            increase();
        }
    }

    @Test
    public void testInteger() throws InterruptedException {
        int count = 10;
        Thread[] ts = new Thread[count];

        for (int k = 0; k < count; k++) {
            ts[k] = new Thread(new AccountingSyncClass());
        }

        // start
        for (int k = 0; k < count; k++) {
            ts[k].start();
        }

        // join
        for (int k = 0; k < count; k++) {
            ts[k].join();
        }

        System.out.println(i);
    }
    
    @Test
    public void testIntegerFix() throws InterruptedException {
        int count = 10;
        AccountingSyncClass instance = new AccountingSyncClass();
        Thread[] ts = new Thread[count];

        for (int k = 0; k < count; k++) {
            ts[k] = new Thread(instance);
        }

        // start
        for (int k = 0; k < count; k++) {
            ts[k].start();
        }

        // join
        for (int k = 0; k < count; k++) {
            ts[k].join();
        }

        System.out.println(i);
    }
}

上面测试的testInteger方法和testIntegerFix方法都能得到正确的结果，原因是给静态类方法加锁相当于10个门用的同一把锁，保证了同一时间只有一个线程能访问临界区资源i。