synchronized关键字使用
## 简介 > Java中的`synchronized`关键字是同步锁,在并发编程中比较常见。 >
渲染中...
## 简介
> Java中的`synchronized`关键字是同步锁,在并发编程中比较常见。
>
> 本文以一些测试实例演示,帮助初学者体会`synchronized`的作用。
>
> 如果你对面向对象的编程思想不太理解,本篇文章也会帮助你理解。
<!-- more -->
## 锁普通方法
### 错误测试
- 线程类
```java
import java.util.Random;
public class MyThread implements Runnable {
public MyThread(Integer id) {
this.threadId = id;
}
private final Integer threadId;
public synchronized void runMethod(Integer threadId) throws InterruptedException {
long time = new Random().nextInt(10) * 200L;
time = time == 0 ? 2000L : time;
System.out.println("Thread:" + threadId + "----sleep----" + time);
Thread.sleep(time);
System.out.println("Thread:" + threadId + "----running----");
}
@Override
public void run() {
System.out.println("Thread:" + threadId + "----begin----");
try {
this.runMethod(threadId);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread:" + threadId + "----end----");
}
}
```
- 测试类
```java
public class SynchronizedTest {
public static void main(String[] args) {
for (int i = 0; i < 3; i++) {
Thread myThread = new Thread(new MyThread(i));
myThread.start();
}
}
}
```
#### 输出结果
```
Thread:0----begin----
Thread:2----begin----
Thread:1----begin----
Thread:0----sleep----1200
Thread:2----sleep----1000
Thread:1----sleep----1800
Thread:2----running----
Thread:2----end----
Thread:0----running----
Thread:0----end----
Thread:1----running----
Thread:1----end----
```
#### 现象分析
- **现象1**:多个线程同时调用``runMethod()``方法时,最先所有``begin``一起执行,然后所有``sleep``又一起执行,且都在``running``前边。
- **结论1**:``runMethod()``方法没有被锁上。``sleep``和``running``都在``runMethod()``方法内部,如果被锁了,应该前一个线程``sleep``和``running``都输出完,才能到下一个线程的``sleep``。
> 然而,结论1是错误的,我们看完正确测试一起分析这个结论为啥错误。
### 正确测试
- 线程类
```java
public class MyThread implements Runnable {
public MyThread(Integer id) {
this.threadId = id;
}
private final Integer threadId;
private static SynchronizedTest synchronizedTest = new SynchronizedTest();
@Override
public void run() {
System.out.println("Thread:" + threadId + "----begin----" + System.currentTimeMillis());
try {
synchronizedTest.runMethod(threadId);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread:" + threadId + "----end----" + System.currentTimeMillis());
}
}
```
- 测试类
```java
public class SynchronizedTest {
public static void main(String[] args) {
for (int i = 0; i < 3; i++) {
Thread myThread = new Thread(new MyThread(i));
myThread.start();
}
}
public synchronized void runMethod(Integer threadId) throws InterruptedException {
long time = new Random().nextInt(10) * 200L;
time = time == 0 ? 2000L : time;
System.out.println("Thread:" + threadId + "----sleep----" + time);
Thread.sleep(time);
System.out.println("Thread:" + threadId + "----running----" + System.currentTimeMillis());
}
}
```
#### 输出结果
```
Thread:0----begin----
Thread:2----begin----
Thread:1----begin----
Thread:0----sleep----1800
Thread:0----running----
Thread:0----end----
Thread:1----sleep----1400
Thread:1----running----
Thread:1----end----
Thread:2----sleep----2000
Thread:2----running----
Thread:2----end----
```
#### 现象分析
- **现象2**:三个``begin``最先一起执行,然后各个线程的``sleep``和``running``依次执行。
- **结论2**:``runMethod``方法被锁住了,只能被一个线程同时执行。
### 解析
- 首先我们分析一下错误测试和正确测试代码上的区别:
1. ``runMethod()``方法位置不同,一个在线程类内部,一个在测试类(执行类)内部
2. ``runMethod()``方法调用方式不同,一个通过直接自己的内部方法,一个创建测试类实例,通过实例调用其方法。
- 其实区别1和区别2,本质上就是一种区别:方法位置不同。而这种区别在对代码理解不深的人来说,感觉就是没有区别,我刚开始也是这样,自然而然的认为这两种写法应该是一样的。但对面向对象思想有一定理解的人来说,一眼就看出来实际的区别所在,那就是``static``关键字:
```java
private static SynchronizedTest synchronizedTest = new SynchronizedTest();
```
- 有没有``static``关键字,就是正确与错误的差别。感兴趣的你可以试一下,把正确测试代码中的``static``关键字删掉,再运行看看结果,相信你会发现它的结果和错误测试的结果是一样的。
- 如果你还不理解,那往下看看最终结论,希望你能理解。
#### 结论
- ``synchronized``作用于普通方法时,相当于给该对象实例中的该方法加锁。当多个线程同时调用该实例中的加锁方法时,才会出现加锁行为。
> 详解:注意结论中的关键词``对象实例``!拓展开来讲,只有多个线程同时调用``同一个``加锁方法时,才会体现出``锁``的行为,在错误实例中,看起来调用的是'同一个方法',其实他都不是在同一个对象实例中。
>
> 举个例子,你和朋友网吧五连坐,5个人玩同一个电脑,只能一人玩一会,如果5个人玩5个电脑,那就是互不干扰同时玩。如果你还没明白继续往下读。
>
> 再回去思考下错误测试中,为什么会出现错误,我又为什么说得出的结论1也是错误的。
> - 问题1:为什么会出现错误?
> - 答案1:因为多个线程调用的不是``同一个``方法。有人可能会问为什么不是``同一个``方法?方法名明明是一样的!好,那你思考一个问题,你们网吧五连坐,玩的都是电脑,那么玩的就是同一个电脑吗?这里同理,每个线程调用的,都是它这个线程独有的那份``runMethod()``方法。在错误测试中,多个线程执行的是``同一个``方法的``多个``实例罢了。
>
> - 问题2:``结论1``为什么是错误的?
> - 答案2:如果你理解了``问题1``的答案,那你应该能想明白``问题2``了。因为在错误测试中,每个线程调用的,都是它这个线程独有的那份``runMethod()``方法,每一份都是一个独立的个体,就比如你们网吧五连坐,总不可能只出一份钱吧。
- 注意:``static``关键字很重要,可以看我以前的一篇文章[《Java静态变量到底能不能变》](https://blog.csdn.net/hu18315778112/article/details/79143365),我对``static``也是随着工作经验的积累才完全理解的。
## 锁静态方法
### 测试
- 线程类
```java
import java.util.Random;
public class MyThread implements Runnable {
public MyThread(Integer id) {
this.threadId = id;
}
private final Integer threadId;
public synchronized static void runMethod(Integer threadId) throws InterruptedException {
long time = new Random().nextInt(10) * 200L;
time = time == 0 ? 2000L : time;
System.out.println("Thread:" + threadId + "----sleep----" + time);
Thread.sleep(time);
System.out.println("Thread:" + threadId + "----running----");
}
@Override
public void run() {
System.out.println("Thread:" + threadId + "----begin----" + System.currentTimeMillis());
try {
runMethod(threadId);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread:" + threadId + "----end----" + System.currentTimeMillis());
}
}
```
- 测试类
```java
public class SynchronizedTest {
public static void main(String[] args) {
for (int i = 0; i < 3; i++) {
Thread myThread = new Thread(new MyThread(i));
myThread.start();
}
}
}
```
#### 输出结果
```
Thread:0----begin----
Thread:2----begin----
Thread:1----begin----
Thread:0----sleep----1600
Thread:0----running----
Thread:0----end----
Thread:1----sleep----400
Thread:1----running----
Thread:1----end----
Thread:2----sleep----200
Thread:2----running----
Thread:2----end----
```
### 结论
- 如果锁普通方法里的【错误测试】你看懂了,那么这种方式直接上结论就好了。其实关键就在于``static``关键字.
- 锁``static``修饰的方法,无论哪个实例对象调用该方法,都会被同步锁住,因为本质上他们调用的是同一个方法(内存中只有一份)。
## 锁代码块
- 首先我们知道锁代码块时,需要传入一个实例对象作为加锁对象,那么传入的参数就有好多种情况了,所以咱们只上正确测试。
### 正确测试1
> 锁对象实例,这种方式要给对象示例加``static``,保证多个线程调用的是同一个实例(锁的是同一个实例)。
- 线程类
```java
public class MyThread implements Runnable {
public MyThread(Integer id) {
this.threadId = id;
}
private final Integer threadId;
private static SynchronizedTest synchronizedTest = new SynchronizedTest();
@Override
public void run() {
System.out.println("Thread:" + threadId + "----begin----");
try {
synchronized (synchronizedTest) {
synchronizedTest.runMethod(threadId);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread:" + threadId + "----end----");
}
}
```
- 测试类
```java
import java.util.Random;
public class SynchronizedTest {
public static void main(String[] args) {
for (int i = 0; i < 3; i++) {
Thread myThread = new Thread(new MyThread(i));
myThread.start();
}
}
public void runMethod(Integer threadId) throws InterruptedException {
long time = new Random().nextInt(10) * 200L;
time = time == 0 ? 2000L : time;
System.out.println("Thread:" + threadId + "----sleep----" + time);
Thread.sleep(time);
System.out.println("Thread:" + threadId + "----running----");
}
}
```
### 正确测试2
> 锁类的字节码,这种写法需要理解一下,后边写结论
- 线程类
```java
public class MyThread implements Runnable {
public MyThread(Integer id) {
this.threadId = id;
}
private final Integer threadId;
private SynchronizedTest synchronizedTest = new SynchronizedTest();
@Override
public void run() {
System.out.println("Thread:" + threadId + "----begin----");
try {
synchronized (SynchronizedTest.class) {
synchronizedTest.runMethod(threadId);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread:" + threadId + "----end----");
}
}
```
- 测试类与【正确测试1】中相同,不再冗余
#### 结论(错)
首先在本次测试中,多个线程调用的是``SynchronizedTest``类,这个应该毋容置疑,知道了这点,咱们就可以大胆的下结论:
- 锁类的字节码这种写法,是锁住了所有该类的实例。如:在本次测试中,只要有任意一个线程运行到该加锁的代码,就会锁住``SynchronizedTest``类的所有实例,只有一个实例能运行,其他实例必须等待。
### 正确测试3
> 为了验证【正确测试2】的结论,我进行了测试3,发现也是可以的。
这里就不放代码了,只改一个单词,就是加锁的那个参数:
``synchronized (SynchronizedTest.class)``改为``synchronized (MyThread.class)``
#### 结论(错)
- 锁代码块时,加锁对象可以是调用类,也可以是被调用类,道理是一样的,锁住了传入``class``的所有对象实例。
### 正确测试4
> 经过【正确测试2】和【正确测试3】,不知道你有没有对我的结论产生怀疑,有没有想试一下锁一个不相关的字节码?
这次一样不放代码,只是改动一下加锁参数:
``synchronized (MyThread.class)``改为``synchronized (Boolean.class)``
测试发现,这么写也是可以实现同步锁的,这就推翻了上边结论里的一句话:“锁住了传入``class``的所有对象实例”,因为这次我们传入的是不相关的``class``,他锁不锁实例按理说不会影响到我们的运行,为什么还是锁成功了呢?
#### 结论(个人理解)
- 加锁参数只是一个钥匙,如果你多个线程执行一段代码块,无论这段代码块是不是同一份(内存中只有一个),只要你们持有相同的钥匙,就会实现同步锁。
> 不知道你有没有理解这个结论,以上边的【正确测试4】举例说明:
> - 当传入一个``Boolean.class``时,其实是把``Boolean.class``的字节码对象当做钥匙,而``Boolean.class``在内存中只会有一个字节码对象实例,所以当任意一个线程执行到这个加锁代码块时,就会锁住``Boolean.class``的字节码对象,其他线程必须等待``Boolean.class``的字节码对象释放后,再次竞争,然后再锁住。
> ps:``synchronized (Boolean.class)``中,你可以把``Boolean.class``认为是钥匙,也可以认为是锁,只要你理解的对就好了。
## 感悟
1. 不要急于下结论,多验证多实践,尤其是对于一个新技术。
2. 个人认为:尽量少用``synchronized (Boolean.class)``这种锁字节码的形式,因为我认为,如果多个不同的地方这样加锁,万一传入的是同一个参数,如``Boolean.class``,那么可能这些不同的地方会产生同步锁的效果,当然这只是我的个人猜测,具体效果需要再做测试验证。
3. 然后就是我有个疑问是,``synchronized (Boolean.class)``这种锁字节码的方式是否会消耗更多资源?有知道的大佬可以解答一下。END
评论
登录后查看和发表评论
前往登录