java线程同步：synchronized关键字，Lock接口以及可重入锁ReentrantLock

最新推荐文章于 2020-10-07 18:43:22 发布

tjk922215

最新推荐文章于 2020-10-07 18:43:22 发布

阅读量328

点赞数

分类专栏： java 文章标签： java 线程多线程锁

本文链接：https://blog.csdn.net/qq_24835809/article/details/77049908

版权

java 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

多线程环境下，必须考虑线程同步的问题，这是因为多个线程同时访问变量或者资源时会有线程争用，比如A线程读取了一个变量，B线程也读取了这个变量，然后他们同时对这个变量做了修改，写回到内存中，由于是同时做修改，就会导致修改的状态不一致.

用一个实际的例子来说明线程同步的必要性:

package cn.outofmemory.locks;

public class LockDemo implements Runnable {
    private int counter = 0;

    public void run() {
        int loopTimes = 10000;
        while (loopTimes > 0) {
          counter ++;               
            loopTimes --;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        LockDemo demo = new LockDemo();

        Thread[] threads = new Thread[]{
                new Thread(demo), new Thread(demo),new Thread(demo), new Thread(demo),new Thread(demo)
        };


        for (Thread t : threads) {
            t.start();
        }

        for (Thread t : threads) {
            t.join();
        }

        System.out.println("demo's counter is " + demo.counter);
    }
}

这段代码中的LockDemo类实现了Runnable接口，在run方法中对其私有变量counter递加了10000次。在main方法中我们首先初始化了一个LockDemo对象，然后初始化了5个线程，这5个线程公用一个LockDemo的实例。
然后我们一次启动这5个线程，然后通过join等待所有线程结束，最后输出demo实例的counter值来。
运行程序，我这儿得到这样一个输出结果：

demo’s counter is 44041

本来5个线程每个线程递加10000次，应该得到的结果是50000，而实际的结果是44041.
如果你也运行此程序有可能会得到不一样的结果。这取决于这5个线程造成了多少次的冲突。从我的输出结果看，这段程序的5个线程造成了大约6000次的内存争用冲突。
在实际应用中，这是不可用的。

改进程序，避免冲突

我们可以分析一下，这5个线程的冲突出现在什么地方，他们公用了demo对象，同时对demo对象的成员变量counter做递加，也就是说冲突出现在对counter递加这一步上。
我们在这一步操作上加上synchronzied关键字，让5个线程执行到对counter++这步代码时单独运行，应该就可以解决问题了。

修改后的run方法代码：

    public void run() {
        int loopTimes = 10000;
        while (loopTimes > 0) {
            synchronized (this) {
                counter ++;             
            }
            loopTimes --;
        }
    }

我们再次运行程序会得到如下确定的输出结果：

demo’s counter is 50000

这次得到的结果是符合我们的预期的，我们通过synchronized关键字解决了问题。

我们看下使用可重入锁ReentrantLock解决线程同步的方法：

    private final Lock lock = new ReentrantLock();

    public void run() {
        int loopTimes = 10000;
        while (loopTimes > 0) {
            try {
                lock.lock();
                counter ++;             
            } finally {
                lock.unlock();
            }
            loopTimes --;
        }
    }

我们在LockDemo中添加了一个final的成员变量lock，它是一个ReentrantLock的实例。在run方法中，在counter++这行代码两边加上了try .. finally ..语句，
当线程执行到try块之后，首先通过lock.lock()获得锁，获得锁之后再执行counter++，最后在finally语句块中通过lock的unlock方法释放锁。
我们可以运行修改后的代码，输出如下：

demo’s counter is 50000

输出结果符合逻辑预期。