Synchronized 加锁 This 和Class 的区别！-6ren

Synchronized 加锁 This 和Class 的区别！

转载作者：qq735679552 更新时间：2022-09-29 22:32:09

25

4

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Synchronized 加锁 This 和Class 的区别！由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

Synchronized 加锁 This 和Class 的区别！

synchronized 是 Java 语言中处理并发问题的一种常用手段，它也被我们亲切的称之为“Java 内置锁”，由此可见其地位之高。然而 synchronized 却有着多种用法，当它修饰不同对象时，其意义也是不同的，下面我们一起来看.

synchronized 用法。

synchronized 可以用来修饰普通方法、静态方法和代码块.

① 修饰普通方法。

/**
* synchronized 修饰普通方法
*/
public synchronized void method() {
// .......
}

当 synchronized 修饰普通方法时，被修饰的方法被称为同步方法，其作用范围是整个方法，作用的对象是调用这个方法的对象.

② 修饰静态方法。

/**
* synchronized 修饰静态方法
*/
public static synchronized void staticMethod() {
// .......
}

当 synchronized 修饰静态的方法时，其作用的范围是整个方法，作用对象是调用这个类的所有对象.

③ 修饰代码块。

为了减少锁的粒度，我们可以选择在一个方法中的某个部分使用 synchronized 来修饰(一段代码块)，从而实现对一个方法中的部分代码进行加锁，实现代码如下:

public void classMethod() throws InterruptedException {
// 前置代码...
// 加锁代码
synchronized (SynchronizedExample.class) {
// ......
}
// 后置代码...
}

以上代码在执行时，被修饰的代码块称为同步语句块，其作用范围是大括号“{}”括起来的代码块，作用的对象是调用这个代码块的对象.

但以上代码，除了可以加锁 class 之外，还可以加锁 this，具体示例如下:

public void classMethod() throws InterruptedException {
// 前置处理代码...
synchronized (this) {
// ......
}
// 后置处理代码...
}

那问题来了，使用 synchronized 加锁 this 和 class 的区别是什么?不都是加锁同一个类吗？

答案还真不是，加锁 this 和 class 区别还是很大的。下面我们通过以下 4 个示例，来看二者之间的区别.

1.加锁 class 共享一个类实例。

首先，我们创建 5 个线程，调用同一个对象下 synchronized 加锁的 class 代码，具体示例如下:

import java.util.Date;
import java.util.concurrent.TimeUnit;
public class SynchronizedExample {
public static void main(String[] args) {
// 创建当前类实例
final SynchronizedExample example = new SynchronizedExample();
// 创建 5 个线程执行任务
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
// 调用 synchronized 修饰的 class 方法
example.classMethod();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
/**
* synchronized 修饰的 class 方法
* @throws InterruptedException
*/
public void classMethod() throws InterruptedException {
synchronized (SynchronizedExample.class) {
System.out.println(String.format("当前执行线程:%s,执行时间:%s",
Thread.currentThread().getName(), new Date()));
TimeUnit.SECONDS.sleep(1);
}
}
}

以上程序的执行结果如下:

Synchronized 加锁 This 和Class 的区别！

从上述结果可以看出，这 5 个线程共享的是同一把锁.

2.加锁 class 创建多个实例。

接下来，我们创建 5 个线程，调用不同对象下 synchronized 加锁的 class 代码，具体示例如下:

import java.util.Date;
import java.util.concurrent.TimeUnit;
public class SynchronizedExample {
public static void main(String[] args) {
// 创建 5 个线程执行任务
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
// 创建类实例
SynchronizedExample example = new SynchronizedExample();
// 调用 synchronized 修饰的 class 方法
example.classMethod();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
/**
* synchronized 修饰的 class 方法
* @throws InterruptedException
*/
public void classMethod() throws InterruptedException {
synchronized (SynchronizedExample.class) {
System.out.println(String.format("当前执行线程:%s,执行时间:%s",
Thread.currentThread().getName(), new Date()));
TimeUnit.SECONDS.sleep(1);
}
}
}

以上程序的执行结果如下:

Synchronized 加锁 This 和Class 的区别！

从上述结果可以看出，虽然是不同的对象，但它们使用的仍然是同一把锁.

3.加锁 this 共享一个类实例。

接下来，我们创建 5 个线程，调用 synchronized 加锁 this 的示例。首先我们这 5 个线程调用同一个对象的加锁方法，示例代码如下:

import java.util.Date;
import java.util.concurrent.TimeUnit;
public class SynchronizedExample {
public static void main(String[] args) {
// 创建当前类实例
final SynchronizedExample example = new SynchronizedExample();
// 创建 5 个线程执行任务
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
// 调用 synchronized 修饰的 this 方法
example.thisMethod();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
/**
* synchronized 修饰的 this 方法
* @throws InterruptedException
*/
public void thisMethod() throws InterruptedException {
synchronized (this) {
System.out.println(String.format("当前执行线程:%s,执行时间:%s",
Thread.currentThread().getName(), new Date()));
TimeUnit.SECONDS.sleep(1);
}
}
}

以上程序的执行结果如下:

Synchronized 加锁 This 和Class 的区别！

从上述结果可以看出，以上线程使用的都是同一把锁.

4.加锁 this 创建多个类实例。

最后一个示例最为特殊，我们使用 synchronized 加锁 this，让这 5 个线程调用各自创建对象的方法，具体示例如下:

import java.util.Date;
import java.util.concurrent.TimeUnit;
public class SynchronizedExample {
public static void main(String[] args) {
// 创建 5 个线程执行任务
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
// 创建（多个）类实例
SynchronizedExample example = new SynchronizedExample();
// 调用 synchronized 修饰的 this 方法
example.thisMethod();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
/**
* synchronized 修饰的 this 方法
* @throws InterruptedException
*/
public void thisMethod() throws InterruptedException {
synchronized (this) {
System.out.println(String.format("当前执行线程:%s,执行时间:%s",
Thread.currentThread().getName(), new Date()));
TimeUnit.SECONDS.sleep(1);
}
}
}

以上程序的执行结果如下:

Synchronized 加锁 This 和Class 的区别！

从上述结果可以看出，当使用 synchronized 加锁 this 时，如果线程调用的不是同一个对象，那么这些线程之间使用的锁都是自己独立的锁，这个结果就和 synchronized 加锁 class 的结果完全不同了.

总结。

通过以上 4 个示例我们可以得出结论，当使用 synchronized 加锁 class 时，无论共享一个对象还是创建多个对象，它们用的都是同一把锁，而使用 synchronized 加锁 this 时，只有同一个对象会使用同一把锁，不同对象之间的锁是不同的.

原文链接：https://mp.weixin.qq.com/s/7DTk5CV5FSOsa5fSN_V26w 。

最后此篇关于Synchronized 加锁 This 和Class 的区别！的文章就讲到这里了,如果你想了解更多关于Synchronized 加锁 This 和Class 的区别！的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！。

25

4

0

文章推荐： php file_get_contents取文件中数组元素的方法

文章推荐： C#编程自学之开篇介绍

文章推荐： PHP中Laravel 关联查询返回错误id的解决方法

文章推荐： C#实现基于加减按钮形式控制系统音量及静音的方法

c# - 只释放给后进线程的线程同步(加锁)
确保只有“后入”线程可以访问互斥锁/锁定区域而中间线程不获取锁的正确方法是什么？示例序列: A acquires lock B waits C waits B fails to acquire lo
Synchronized 加锁 This 和Class 的区别！
synchronized 是 Java 语言中处理并发问题的一种常用手段，它也被我们亲切的称之为“Java 内置锁”，由此可见其地位之高。然而 synchronized 却有着多种用法，当它修饰
python互斥锁、加锁、同步机制、异步通信知识总结
某个线程要共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进入写入操作，

首页

博学

6Ren·AI

商城

Synchronized 加锁 This 和Class 的区别！