【原创】对Java的synchronized关键字的学习

在Java中，每一个线程都有一个内部锁。当我们使用synchronized关键字时，就是利用这个内部锁来实现线程对某个对象的锁定控制。

那么，如果某个对象中有两个方法，方法一和方法二都使用了synchronized关键字。如果线程一执行该对象的方法一，线程二执行该对象的方法二。如果线程1一直不释放该对象的内部锁的话，那么线程二应该无法执行该对象的方法二。下面就用代码来验证一下。

首先，定义一个Task类。

 package corejava.chapter14;

 public class TaskC {

     public synchronized void method1() throws InterruptedException {

         while (true) {
             System.out.println("我是方法1");
             Thread.sleep(10000);
         }

     }

     public synchronized void method2() throws InterruptedException {

         while (true) {
             System.out.println("我是方法2");
             Thread.sleep(10000);
         }

     }

 }

method1每隔10秒就会输出一句“我是方法1”。method2每隔10秒就会输出一句“我是方法2”。两个方法都使用了synchronized关键字。

再定义两个执行类ExecutorC1和Executor2。

 package corejava.chapter14;

 public class ExecutorC1 implements Runnable {

     private TaskC taskC;

     public ExecutorC1(TaskC taskC) {
         this.taskC = taskC;
     }

     @Override
     public void run() {
         try {
             taskC.method1();
         } catch (Exception e) {
             e.printStackTrace();
         }

     }
 }

 package corejava.chapter14;

 public class ExecutorC2 implements Runnable {

     private TaskC taskC;

     public ExecutorC2(TaskC taskC) {
         this.taskC = taskC;
     }

     @Override
     public void run() {
         try {
             taskC.method2();
         } catch (Exception e) {
             e.printStackTrace();
         }

     }

 }

执行类1启动线程后，会执行taskC的method1方法。执行类启动线程后，会执行taskC的method2方法。

最后定义入口类Main

 package corejava.chapter14;

 public class Main {

     public static void main(String[] args) {
         TaskC taskC = new TaskC();
         ExecutorC1 executorC1 = new ExecutorC1(taskC);
         ExecutorC2 executorC2 = new ExecutorC2(taskC);
         Thread thread1 = new Thread(executorC1);
         Thread thread2 = new Thread(executorC2);
         thread1.start();
         thread2.start();
     }

 }

执行对象1和执行对象2都使用同一个taskC去实例化，这样他们之间就会存在竞争。当thread1执行taskC的method1时，会一直持有taskC的内部锁，因此thread2将一直处于阻塞状态。

下面是运行输出结果

可见，确实如我们所料，虽然两个线程要执行的是不同的方法，但因为线程1一直“霸占”着内部锁，所以线程2始终在阻塞状态，得不到执行。

所以，如果我们在对某个类要使用synchronized关键字进行锁定控制时，一定要牢记它使用的是该类的内部锁。它是唯一的。当多个方法都用它来进行控制时，一定要考虑这一点。