【原创】对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关键字进行锁定控制时，一定要牢记它使用的是该类的内部锁。它是唯一的。当多个方法都用它来进行控制时，一定要考虑这一点。