帮忙分析一下这两个多线程例子的结果。

乔兵

public class TT implements Runnable {
int b = 100;
public synchronized void m1() throws Exception{
b = 1000;
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);
}
}

复制代码

和

public class TT implements Runnable {
int b = 100;
public synchronized void m1() throws Exception{
b = 1000;
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);
}
}

复制代码

请帮忙分析一下这两个程序的执行流程，并说明为什么是那样的结果啊？

王琪 · 王琪

对呀先int b=100  --》t.start();也就是m1()执行-->b=1000-->sleep(5000ms)系统不再处理此线程执行main（）线程-->m2()-->b=200-->sleep(250)当，你x想输出什么？
线程的开辟是程序出现了两个线程（主线程，m1)()），（不像函数必须按顺序执行在m1归为线程时主线程早就执行了m2()）

{
m2执行sleep2500
开启m1线程sleep5000
m2醒了b=200
2000
m1线程醒了b = 2000
请按任意键继续. . .

}

//****************************************
public class TT implements Runnable {
      int b = 100;

      public synchronized void m1() throws Exception{
            b = 1000;
System.out.println("开启m1线程sleep5000");
            Thread.sleep(5000);
            System.out.println("m1线程醒了"+"b = " + b);
      }

      public void m2() throws Exception {
System.out.println("m2执行"+"sleep2500");
            Thread.sleep(2500);
            b = 2000;
System.out.println("m2醒了b=200");
      }

      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.run();
//************************
            tt.m2();
            System.out.println(tt.b);
      }
}

上面是方法（），必须按正规思想运行
结果是
{
开启m1线程sleep5000
m1线程醒了b = 1000
m2执行sleep2500
m2醒了b=200
2000
请按任意键继续. . .

}

EYE_SEE_YOU · EYE_SEE_YOU

主线程和自建线程操作同一资源，具体的就不分析了

刘松703 · 刘松703

两个代码的不同之处在于，第一个
public synchronized void m2() throws Exception {
            Thread.sleep(2500);
            b = 2000;
   }
有 synchronized ，而第二个
public synchronized void m2() throws Exception {
            Thread.sleep(2500);
            b = 2000;
   }

没有 synchronized ，一个关键字的区别导致了这两段代码运行的结果和顺序不同
synchronized的作用是，同步代码块时,一个时间内只能有一个线程得到执行，
这个是重点！
第一段代码的运行结果是
1000
b=1000
因为主函数是一个线程，m1（）又是一个线程，此处的m2（），相当于一个方法，tt.m2（）就是方法调用，是main这个线程的一部分，开始进入main（），主线程在运行，tt.start()表示建立了另一线程，我们知道只有调用run时线程才运行，但此时没有调用run（），只是相当于一个预备动作似的，接下来是调用tt。m2（）；
因为有synchronized关键字的关系，所以在这个时间只能运行这一个线程，此时的b为2000；等到m2（）运行完成后，m1()线程开始运行，此时的b被赋值为1000，故是以上结果。

第二段代码，因为m2（）前没有synchronized关键字，则在tt.start（）后，线程m1（）进入就绪，此时还是主线程，运行tt.m2(),但这里因为没有synchronized关键字，所以在m2（）中，运行到Thread。spleep（2500）时，会暂停主线程，在2。5秒后运行m1（），注意，此时的m2（）并没有运行完，只是到sleep（）方法后突然停止运行m1（），而其后面的 b = 2000;这个语句没有运行到，所以此时的b还为100，进入m1（）后，b又被赋值为1000，接下来又到了m1（）中的Thread.sleep(5000)，此时m1（）这个线程又暂停，5秒后，又跳到m2（）中，运行没有运行完的代码，即运行b=2000；所以此时的b的值为2000；
m2（）运行完后就又回到m1（）中运行其没有运行完的代码，即可输出b=2000；

帐号		自动登录	找回密码
密码			加入黑马

帮忙分析一下这两个多线程例子的结果。

评分

3 个回复

评分

评分