前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >并发设计⚡谈谈锁与资源

并发设计⚡谈谈锁与资源

原创
作者头像
写bug的高哈哈
发布2024-05-24 14:24:33
400
发布2024-05-24 14:24:33

在写并发程序的时候,「锁」和「资源」是两个不同的东西,如果没有弄清楚,有时会出现锁不住,或是锁错资源的情况。

以生活化的例子来说,锁和资源它们俩就像是钥匙跟抽屉的对应关系。

有时候一个钥匙可以对应多个抽屉,有时候一个钥匙只能开一个抽屉,或者是多个钥匙开很多层才可以开一个抽屉。 虽然概念上看似很简单,但在实际的架构中或是程序语法里面不一定很容易地看出来。 身为工程师,当然是写Code 表达最清晰,接下来我用几段简单的 Java 代码来呈现这个概念

找找看锁在哪里?

举个例子:下面的 Java 代码定义了 TV 这个类,同时有 watchMovieplayVideoGame 两个方法。并且在 watchMovieplayVideoGame 加上 synchronized 修饰字, 目的是为了让一台 TV 不能同时执行 watchMovie 以及 playVideoGame

这段代码,你看得出来那个部分是「资源」而哪个部分表示「锁」吗?(想想钥匙和抽屉的例子,哪里是抽屉?哪里是钥匙?)

代码语言:java
复制
public class TV {
    public  `synchronized ` void  watchMovie () throws InterruptedException {
        System.out.printin("watch movie"); //资源A
        Thread.sleep(5000);
    }

    public  `synchronized ` void  playVideoGame () throws InterruptedException {
        System.out.println("play video game"); //资源B
        Thread.sleep(5000);
    }
}

在我用注释的地方写著资源 A 和资源 B,分别表示 watch movie 以及 play video game 这两件事。 watch movie 以及 play video game 这两件事就是「资源」的部分。为了避免资源 A 和资源 B 被同时执行,我们需要一把锁,那么「锁」的位置又在哪呢? 我们将上述的代码转换成下面的格式会更好理解:

代码语言:java
复制
public class TV {
    public void watchMovie () throws InterruptedException {
         `synchronized ` ( `this `) { //锁
            System.out.println("watch movie"); //资源A
            Thread.sleep(5000);
        }
    }

    public void  playVideoGame () throws InterruptedException {
         `synchronized ` ( `this `) { //锁
            System.out.println("play video game"); //资源B
            Thread.sleep(5000);
        }
    }
}

我们将 synchronized 从方法上移除,改为在方法内建立一个 synchronized 的区块,这两种写法意义上是一样的。而 synchronized 括号内的 this ,就表示进入这个区块前,要先取得的「锁」。其中,Java 的 this 是TV 类实例化后的值,也就是说资源 A 和资源 B 被同一把锁 (就是 this) 给锁住,以这种方式避免资源 A 和资源 B 被同时执行。锁的位置跟资源的位置,在上图中我用蓝色注释清楚地标示了出来。

我们还可以改写一下程序,更明显地把「锁」呈现出来,下图我用一个变数 lock 当作锁,来锁住资源 A 和资源 B:

代码语言:java
复制
public class TV {
    // 只有一把锁
    private final Object  `lock ` = new Object();

    public void watchMovie () throws InterruptedException {
         `synchronized ` ( `lock `) { //锁
            System.out.println("watch movie"); //资源 A
            Thread.sleep(5000);
        }
    }

    public void playVideoGame () throws InterruptedException {
         `synchronized ` ( `lock `) { //锁
            System.out.println("play video game"); //资源 B
            Thread.sleep(5000);
        }
    }
}

接下来我们来看执行的情况 (如下图),当两个执行绪 t1 和 t2 同时执行的时候,因为 new TV( ) 时在类内部只会产生一个 lock 实例,所以只有一把锁,可以避免 t1 跟 t2 两个执行绪同时获得锁,达成同一时间只有一个资源被获取成功的效果。

代码语言:java
复制
        //tv 内部只有一个  `lock ` 实例
        final TV tv = new TV();
        Thread t1 = new Thread(() -> {
            try {
                tv.watchMovie ();//获取资源 A
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        Thread t2 = new Thread(() -> {
            try {
                tv.playVideoGame ();//获取资源 B
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        t1.start();
        t2.start();

锁和资源误用的情况

在明白了锁跟资源之间的独立关系后,还需要仔细的考虑锁和资源的对应问题:

假设刚才的程序,我们一不小心写成 new TV( ) 两次 (如下图),产生了 tv1 和 tv2 ,这时候 tv1 内部有自己的 lock 实例,而 tv2 内部也有自己的 lock 实例,各自的锁用来锁自己的资源。两个 TV 实例可以各自执行 watch movie 以及 play video game,让 watch movie 以及 play video game 事件同时发生,但这并不一定是你想要的结果。

代码语言:java
复制
        final TV tv1 = new TV();
        final TV tv2 = new TV();
        Thread t1 = new Thread(() -> {
            try {
                tv1.watchMovie ();//tv1 有自己的 1ock 实例
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        Thread t2 = new Thread(() -> {
            try {
                tv2. playVideoGame ();//tv2 有自己的 1ock 实例
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        t1.start();
        t2.start();

总结

从上面的例子我们可以很清楚地知道:

在并发的程序里面,锁是锁,资源是资源,在系统设计时需要把两者分开思考。

像我们刚才举的例子,要在程序中找出隐晦的锁与资源对应关系 (例如: synchronized语法),如果不小心弄出了两把锁 (new TV()两次产生两个 lock),可能会出现不希望发生的情况。

这个锁与资源的观念是具体而微的,在微观上,一小段 Java 程序是这样呈现,在宏观上更复杂的系统架构,或甚至是分散式的环境下,也可以套用同样的道理。锁会有更多不同的属性 (共享锁、排他锁等等) 也会有不同的策略(悲观锁、乐观锁等等),需要考虑锁之间兼容的问题,而对资源的操作也会更复杂,之后我会再分享更多的例子。但总体来说,概念是不变的,在并发程序中,我们应该细心地去分辨当下的锁在哪里以及资源在哪里,并且小心翼翼的 设计锁和资源的对应

原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。

如有侵权,请联系 cloudcommunity@tencent.com 删除。

原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。

如有侵权,请联系 cloudcommunity@tencent.com 删除。

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 找找看锁在哪里?
  • 锁和资源误用的情况
  • 总结
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档