用法

  1. 用在 非静态方法 上（执行该方法的时候，对这个对象进行加锁）
  2. 用在 静态方法 上（执行该方法的时候，对整个类进行加锁）
  3. 在 代码块 中对某个对象加锁（在执行该代码块的时候，对该对象进行加锁）
  4. 在 代码块 中对某个类进行加锁（在执行该代码块的时候，对该类进行加锁）

1. 用在非静态方法上

  1. public class TestThread {
  3.     public static void main(String[] args) {
  4.         ExecutorService service = Executors.newCachedThreadPool();
  5.         Thread thread = new Thread(new ThreadTest());
  6.         service.submit(thread);
  7.         service.submit(thread);
  8.         service.shutdown();
  9.     }
  11. }
  13. public class ThreadTest implements Runnable {
  15.     public synchronized void run() {
  16.         System.out.println("Start");
  17.         try {
  18.             Thread.sleep(1000);
  19.         } catch (InterruptedException e) {
  20.             e.printStackTrace();
  21.         }
  22.         System.out.println("End");
  23.     }
  25. }
  27. 输出结果:
  28. Start
  29. End
  30. Start
  31. End

可以看到，synchronized作用于非静态方法上，实际上是对对象加锁，对于同一对象，执行是同步的，而如果两个线程属于不同对象，则会导致这个锁失效：

  1. public class TestThread {
  3.     public static void main(String[] args) {
  4.         ExecutorService service = Executors.newCachedThreadPool();
  5.         Thread thread1 = new Thread(new ThreadTest());
  6.         Thread thread2 = new Thread(new ThreadTest());
  7.         service.submit(thread1);
  8.         service.submit(thread2);
  9.         service.shutdown();
  10.     }
  12. }
  14. public class TestThread {
  16.     public static void main(String[] args) {
  17.         ExecutorService service = Executors.newCachedThreadPool();
  18.         Thread thread1 = new Thread(new ThreadTest());
  19.         Thread thread2 = new Thread(new ThreadTest());
  20.         service.submit(thread1);
  21.         service.submit(thread2);
  22.         service.shutdown();
  23.     }
  25. }
  27. 输出结果:
  28. Start
  29. Start
  30. End
  31. End

对于不同的对象，执行的过程不是同步的，可知synchronized用在非静态方法上，是对这个对象加锁

2. 用在静态方法上

  1. public class TestThread {
  3.     public static void main(String[] args) {
  4.         ExecutorService service = Executors.newCachedThreadPool();
  5.         Thread thread1 = new Thread(new ThreadTest());
  6.         Thread thread2 = new Thread(new ThreadTest());
  7.         service.submit(thread1);
  8.         service.submit(thread2);
  9.         service.shutdown();
  10.     }
  12. }
  14. public class ThreadTest implements Runnable {
  16.     public void run() {
  17.         Test.print();
  18.     }
  20. }
  22. public class Test {
  24.     public synchronized static void print() {
  25.         System.out.println("Start");
  26.         try {
  27.             Thread.sleep(1000);
  28.         } catch (InterruptedException e) {
  29.             e.printStackTrace();
  30.         }
  31.         System.out.println("End");
  32.     }
  34. }
  36. 输出结果:
  37. Start
  38. End
  39. Start
  40. End

静态方法是属于类的属性，存放在方法区中，与实例对象无关，所以 synchronized 用在静态方法上实际上是对整个类加锁，所以就算是不同实例，结果也是同步的，如果是同一类同一对象，也是一样的结果

3. 在代码块中对类进行加锁

  1. public class TestThread {
  3.     public static void main(String[] args) {
  4.         ExecutorService service = Executors.newCachedThreadPool();
  5.         Thread thread = new Thread(new ThreadTest());
  6.         service.submit(thread);
  7.         service.submit(thread);
  8.         service.shutdown();
  9.     }
  11. }
  13. public class ThreadTest implements Runnable {
  15.     public void run() {
  16.         synchronized (ThreadTest.class) {
  17.             System.out.println("Start");
  18.             try {
  19.                 Thread.sleep(1000);
  20.             } catch (InterruptedException e) {
  21.                 e.printStackTrace();
  22.             }
  23.             System.out.println("End");
  24.         }
  26.     }
  28. }
  30. 输出结果:
  31. Start
  32. End
  33. Start
  34. End

对class类进行加锁，跟作用在静态方法上效果是相同的，只针对类，而不是针对具体对象

4. 在代码块中对对象进行加锁

  1. public class TestThread {
  3.     public static void main(String[] args) {
  4.         ExecutorService service = Executors.newCachedThreadPool();
  5.         Thread thread = new Thread(new ThreadTest(new Test()));
  6.         service.submit(thread);
  7.         service.submit(thread);
  8.         service.shutdown();
  9.     }
  11. }
  13. public class ThreadTest implements Runnable {
  15.     private final Test test;
  17.     public ThreadTest(Test test) {
  18.         this.test = test;
  19.     }
  21.     public void run() {
  22.         synchronized (test) {
  23.             test.print();
  24.         }
  25.     }
  27. }
  29. public class Test {
  31.     public void print() {
  32.         System.out.println("Start");
  33.         try {
  34.             Thread.sleep(1000);
  35.         } catch (InterruptedException e) {
  36.             e.printStackTrace();
  37.         }
  38.         System.out.println("End");
  39.     }
  41. }
  43. 输出结果:
  44. Start
  45. End
  46. Start
  47. End

在run方法中，对Test对象进行了加锁，所以对相同对象执行方法是同步的，下面改写成两个不同对象：

  1. public class TestThread {
  3.     public static void main(String[] args) {
  4.         ExecutorService service = Executors.newCachedThreadPool();
  5.         Thread thread1 = new Thread(new ThreadTest(new Test()));
  6.         Thread thread2 = new Thread(new ThreadTest(new Test()));
  7.         service.submit(thread1);
  8.         service.submit(thread2);
  9.         service.shutdown();
  10.     }
  12. }
  14. // 其他代码与上面相同省略
  16. 输出结果:
  17. Start
  18. Start
  19. End
  20. End

可以看到，对不同对象这样加锁就不产生作用了