线程同步synchronized在程序里出现多个哪个先运行？

Question

下面三个程序，求解释：
———————————————————————————————————————————————————————
eg1:
package Thread;public class TT implements Runnable {
int b = 100;
public synchronized void m1() throws Exception{
//Thread.sleep(2000);
b = 1111;
Thread.sleep(5000);
System.out.println("b = " + b);
}
public synchronized void m2() throws Exception {
Thread.sleep(2500);
b = 2000;
}
public void run() {
try {
m1();
} catch(Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception {
TT tt = new TT();
Thread t = new Thread(tt);
t.start();
tt.m2();
System.out.println(tt.b);
}
}运行结果是：
1111
b = 1111
，就是不知道tt.m2()为什么会打印出来1111而不是100
—————————————————————————————————————————————————
eg2：package Thread;public class TT implements Runnable {
int b = 100;
public synchronized void m1() throws Exception{
//Thread.sleep(2000);
b = 1111;
Thread.sleep(5000);
System.out.println("b = " + b);
}
public  void m2() throws Exception {
Thread.sleep(2500);
b = 2000;
}
public void run() {
try {
m1();
} catch(Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception {
TT tt = new TT();
Thread t = new Thread(tt);
t.start();
tt.m2();
System.out.println(tt.b);
}
}
运行结果：
2000
b = 2000
—————————————————————————————————————————————————
eg3：package Thread;public class TT implements Runnable {
int b = 100;
public synchronized void m1() throws Exception{
//Thread.sleep(2000);
b = 1111;
Thread.sleep(5000);
System.out.println("b = " + b);
}
public  void m2() throws Exception {
Thread.sleep(2500);
}
public void run() {
try {
m1();
} catch(Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception {
TT tt = new TT();
Thread t = new Thread(tt);
t.start();
tt.m2();
System.out.println(tt.b);
}
}
运行结果：
1111
b = 1111
———————————————————————————————————————————————————————
synchronized在程序里有m1()和m2(),当同时出现的时候，哪个先运行呢？在网上找了很久解释
我的blog原文在：http://blog.sina.com.cn/s/blog_6829be5c0100qov7.html

Answer 1

eg1的
因为m1 和m2 都是有synchronized，所以当一个方法正在执行，那么其他拥有synchronized的都会被等待，所以eg1的，输出1111的话，意思就是main线程先抢到那把锁，至于Thread t = new Thread(tt);这个线程想运行，只好等待m1执行完毕，它再执行，你可以在执行m2之前先睡个0.X秒，结果应该不一样了eg2啥问题？eg3没看懂想问啥最后的问题，这个看CPU的时间分配，还有一条线程的初始化时间，这个你没办法控制，所以才会有synchronized这个来帮助你控制

Answer 2

eg1：
有两个线程，主线程和Thread t
两个线程同时执行，由于m1和m2都是synchronized ，对象锁加在了tt（TT对象）上，所以这两个方法是同步的，但是cpu先执行了m2方法，因为m2方法先分到了时间片，这是tt被锁住，执行m2，b被赋值2000，执行完m2,然后执行m1,，b被赋值1111,m1sleep，但此时主线程个t是异步的，所以主线程分到时间片，主线程打印b=1111，然后m1分到时间片，sleep后打印b = 1111eg2：
有两个线程，主线程和Thread t
但是m2没有synchronized，所以m1,m2异步执行，b先被m1赋值1111，然后m1 sleep5秒，此期间M2 sleep2秒后b被赋值为2000，然后主线程打印2000，m1 sleep后打印b = 2000eg3
只有m1对b赋值，主线程和t是异步的，所以主线程先打印1111，后来m1打印b = 1111

Answer 3

对于eg1:
cpu每次都把时间先给m2么？是不是随机的呢？先执行哪个有规律么？对于eg2，3:为什么有时候m1()和m2()都会被执行，有时候只执行一个？

Answer 4

cpu把时间片分给谁是不确定的，没什么规律，不过主线程先得到的概率大点吧
2和3肯定两个方法都执行了，你在这两个方法里都加上System,out.print试一下就知道了

Answer 5

为什么每次System.out.println(tt.b);都在System.out.println("b = " + b);之前执行呢？即便我不让m1() sleep 也是先执行System.out.println(tt.b);

Answer 6

只是CPU刚好都先跑mina线程而已，这个不用在意

Answer 7

随机的，没有一定的规律。两个方法都在执行，只是到底谁先执行就得看CPU当时的状态了

Answer 8

对于eg1来说，tt.m2();难道相当于tt.m2();tt.m1();两句话？
把主线程改为：
public static void main(String[] args) throws Exception {
TT tt = new TT();
Thread t = new Thread(tt);
t.start();
Thread.sleep(5000);
tt.m2();
System.out.println(tt.b);
}
运行结果：b = 1111
2000这次tt为什么又不执行m1()了？百思不得其解，难道我迷在哪了？
看了下API文档，
API里java.lang中Thread.run这样解释：如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。
Thread 的子类应该重写该方法。也就是说tt是应该执行run方法的，就是会执行m1(),但是这次让线程睡了会儿后，主线程好像没有执行m1()又或者如例子2一样，Thread线程写的是t.m1(),为什么t.会执行m2（）方法？输出一个b=2000  弄不明白

Answer 9

按理说，调用m1()的方法应该只会打印M1()的结果,m2()也是如此，你可以看看这个程序，是按你的改的：public class TT implements Runnable {
int b = 100; public synchronized void m1() throws Exception {
// Thread.sleep(2000);
b = 1111;
//Thread.sleep(5000);
System.out.println("b = " + b);
} public synchronized void m2() throws Exception {
Thread.sleep(2500);
b = 2000;
} public void run() {
try {
//Thread.sleep(5000);
m1();
} catch (Exception e) {
e.printStackTrace();
}
} public static void main(String[] args) throws Exception {
TT tt = new TT();
Thread t = new Thread(tt);
t.start();
Thread.sleep(5000);
tt.m2();
System.out.println(tt.b);
}
}或者这个程序更能让你明白：
public class TT implements Runnable {
int b = 100; public synchronized void m1() throws Exception {
// Thread.sleep(2000);
b = 1111;
//Thread.sleep(5000);
System.out.println("b = " + b);
} public synchronized void m2() throws Exception {
Thread.sleep(2500);
b = 2000;
} public void run() {
try {
Thread.sleep(5000);
m1();
} catch (Exception e) {
e.printStackTrace();
}
} public static void main(String[] args) throws Exception {
TT tt = new TT();
Thread t = new Thread(tt);
t.start();
//Thread.sleep(5000);
tt.m2();
System.out.println(tt.b);
}
}