- 锁普通方法
- 错误测试
- 输出结果
- 现象分析
- 正确测试
- 输出结果
- 现象分析
- 解析
- 结论
- 线程类
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----");
}
}
- 测试类
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是错误的，我们看完正确测试一起分析这个结论为啥错误。
- 线程类
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());
}
}
- 测试类
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方法被锁住了，只能被一个线程同时执行。
- 首先我们分析一下错误测试和正确测试代码上的区别：
- runMethod()方法位置不同，一个在线程类内部，一个在测试类（执行类）内部
- runMethod()方法调用方式不同，一个通过直接自己的内部方法，一个创建测试类实例，通过实例调用其方法。
- 其实区别1和区别2，本质上就是一种区别：方法位置不同。而这种区别在对代码理解不深的人来说，感觉就是没有区别，我刚开始也是这样，自然而然的认为这两种写法应该是一样的。但对于有理解的人来说，一眼就看出来实际的区别所在，那就是static关键字：
private static SynchronizedTest synchronizedTest = new SynchronizedTest();
- 有没有static关键字，就是正确与错误的差别。感兴趣的你可以试一下，把正确测试代码中的static关键字删掉，再运行看看结果，相信你会发现它的结果和错误测试的结果是一样的。
- 如果你还不理解，那往下看看最终结论，希望你能理解。
- synchronized作用于普通方法时，相当于给该对象实例中的该方法加锁。当多个线程同时调用该实例中的加锁方法时，才会出现加锁行为。
详解：注意结论中的关键词对象实例！拓展开来讲，只有多个线程同时调用同一个加锁方法时，才会体现出锁的行为。举个例子，你和朋友网吧五连坐，5个人玩同一个电脑，只能一人玩一会，如果5个人玩5个电脑，那就是互不干扰同时玩。如果你还没明白继续往下读。
再回去思考下错误测试中，为什么会出现错误，我又为什么说得出的结论1也是错误的。
- 问题1：为什么会出现错误？
- 答案1：因为多个线程调用的不是同一个方法。有人可能会问为什么不是同一个方法？方法名明明是一样的！好，那你思考一个问题，你们网吧五连坐，玩的是同一个电脑吗？这里同理，每个线程调用的，都是它这个线程独有的那份runMethod()方法。在错误测试中，多个线程执行的是同一个方法的多个实例罢了。
- 问题2：结论1为什么是错误的？
- 答案2：如果你理解了问题1的答案，那你应该能想明白问题2了。因为在错误测试中，每个线程调用的，都是它这个线程独有的那份runMethod()方法，每一份都是一个独立的个体，就比如你们网吧五连坐，总不可能只出一份钱吧。
- 注意：static关键字很重要，可以看我早起的一篇文章《Java静态变量到底能不能变》，我对static也是随着工作经验的积累才完全理解的。
