现在请允许我很严肃的声明:我还是小白,请原谅我的年轻!别笑,很严肃的。
今天在看《JAVA并发编程实战》是看到内置锁是可重入的 :
public
class
Father {
public
synchronizd
void
doSomething() {.....}
}
public
class
Son
extends
Father{
public
synchronizd
void
doSomething () {
super
.doSomething();
}
}
书上说上面的代码如果没有内置锁的重入就会发生死锁。
这下我就纳闷了,明明是两个加了synchronizd 修饰的方法,为什么会造成死锁呢,在本宝宝的世界观里它应该是这么运行的:首先进入了Son自己
的dosomething方法,这时候dosomething被加上了锁,但是从父类那里继承来的dosomething方法还没被加上锁,所以就可以很顺利的调用从父类
继承而来的dosomething方法,调用完毕后结束。
当时给我的感受就是:这个跟重入有个P关系!
事实证明,在接下来的几分钟时间内我一直在证明一个论点:我刚才好萨比......
这几分钟内发生了以下这几件看似兴奋,看似励志实则悲伤,确实无聊的事件:
当我在茫茫网海中搜寻答案是,看到了一句应该是个哥们,说的话:每个对象都关联了一把锁,非static方法的synchronized获取的就是这个对象关联的锁。
oh,no!!! 我的天,感觉这么基础的东西我竟然都不懂,就去装逼看书了(其实一开始心底还质疑了作者)。
这时我心里的OS是这样的:不行,我要证明一下,万一非static方法的synchronized获取的不是这个对象关联的锁呢.......
于是就自己写了下面这段代码:
public class DeadLock implements Runnable {
public DeadLock() {
}
public synchronized void dosomething() {
System.out.println("这是dosomething方法");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public synchronized void otherthing() {
System.out.println("这是otherthing方法");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
public void run() {
int random = (int) ((Math.random()) * 2); // 获取随机数 0 或1
System.out.println(random);
if (random == 1) {
otherthing();
} else {
dosomething();
}
}
}
public DeadLock() {
}
public synchronized void dosomething() {
System.out.println("这是dosomething方法");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public synchronized void otherthing() {
System.out.println("这是otherthing方法");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
public void run() {
int random = (int) ((Math.random()) * 2); // 获取随机数 0 或1
System.out.println(random);
if (random == 1) {
otherthing();
} else {
dosomething();
}
}
}
public class Text {
public static void main(String[] args) {
DeadSonLock d = new DeadSonLock();
for (int i = 0; i < 10; i++) {
Thread t = new Thread(d);
t.start();
}
}
}
public static void main(String[] args) {
DeadSonLock d = new DeadSonLock();
for (int i = 0; i < 10; i++) {
Thread t = new Thread(d);
t.start();
}
}
}
以下是结果:
0
0
1
1
0
0
0
1
这是dosomething方法
0
0
这是dosomething方法
这是dosomething方法
这是otherthing方法
这是dosomething方法
这是dosomething方法
这是dosomething方法
这是otherthing方法
这是otherthing方法
这是dosomething方法
0
1
1
0
0
0
1
这是dosomething方法
0
0
这是dosomething方法
这是dosomething方法
这是otherthing方法
这是dosomething方法
这是dosomething方法
这是dosomething方法
这是otherthing方法
这是otherthing方法
这是dosomething方法
这里一共new了5个线程,每个线程会随机产生一个随机的整数i为0或1,根据i来进入dosomething()或otherthing()
从结果中我们可以看到,第一个线程是进入了dosomething方法,这时哪怕第三个线程是应该调用otherthing方法,但是
却等到dosomething运行并sleep()2秒后才调用成功,所以可以证明:每个对象都关联了一把锁,非static方法的synchronized获取的就是这个对象关联的锁,同时也证明了我刚才萨比了.....