java 中多线程问题？为什么最后输出的答案不是2000 b=1000有哪位大神详细分析一下两个线程之间怎么运行的吗？感激不尽

RATNG 2016-07-29 12:37:30
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);
}
}
...全文
224 6 打赏 收藏 转发到动态 举报
写回复
用AI写文章
6 条回复
切换为时间正序
请发表友善的回复…
发表回复
soapyuki 2016-07-30
  • 打赏
  • 举报
 回复
首先是synchronized修饰的方法，是同步的，这个锁，锁的是调用对象，main方法里面 Thread t1 = new Thread(tt); t1.setName("线程1"); t1.start(); tt.m2(); 在main方法中，JVM启动创建了一个主线程去调用main方法。 t1.start()方法首先是 start():首先启动了线程，然后再由 jvm去调用该线程的run()方法。 所以tt.m2()方法因为是main线程调用的，先启动，然后因为 m1方法和m2方法都是同步的，锁的对象是调用对象，都是同一个调用对象tt ，所以执行完m2方法后再执行m1。。 同样的， t1.start(); tt.m1(); 也是先启动下面的tt.m1()方法，然后再启动t1.start()对应的 run() m1()
soapyuki 2016-07-30
  • 打赏
  • 举报
 回复 

public class TT implements Runnable {
	int b = 100;
        int i = 0;
	public synchronized void m1() throws Exception {
		System.out.println(Thread.currentThread().getName()+"线程进入m1");
		b = 1000;
		Thread.sleep(5000);
		i++;
		System.out.println("m1.b="+ b +",i=" + i+"线程是：" + Thread.currentThread().getName());
		System.out.println("结束m1");
	}

	public synchronized void m2() throws Exception {
		System.out.println(Thread.currentThread().getName()+"线程进入m2");
		Thread.sleep(2500);
		b = 2000;
		System.out.println("m2.b=" + b +",i="+ i+"线程是："+ Thread.currentThread().getName());
	}

	
	public void run() {
		try {
			System.out.println(Thread.currentThread().getName()+"开始执行run方法");
			m1();
		
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			System.out.println(Thread.currentThread().getName()+"执行run方法完毕");
		}
	}

	public static void main(String[] args) throws Exception {
		TT tt = new TT();
		Thread t1 = new Thread(tt);
		t1.setName("线程1");
		t1.start();
	
		tt.m1();
//		main线程进入m1
//		线程1开始执行run方法
//		m1.b=1000,i=1线程是：main
//		结束m1
//		线程1线程进入m1
//		m1.b=1000,i=2线程是：线程1
//		结束m1
//		线程1执行run方法完毕
		
		

//		tt.m2();
//		System.out.println(tt.b);
//		main线程进入m2
//		线程1开始执行run方法
//		m2.b=2000,i=0线程是：main
//		线程1线程进入m1
//		m1.b=1000,i=1线程是：线程1
//		结束m1
//		线程1执行run方法完毕

		
		
	}
}
这个是上面的运行结果，可以看看
RATNG 2016-07-30
  • 打赏
  • 举报
 回复
引用 4 楼 soapyuki 的回复:
首先是synchronized修饰的方法，是同步的，这个锁，锁的是调用对象，main方法里面 Thread t1 = new Thread(tt); t1.setName("线程1"); t1.start(); tt.m2(); 在main方法中，JVM启动创建了一个主线程去调用main方法。 t1.start()方法首先是 start():首先启动了线程，然后再由 jvm去调用该线程的run()方法。 所以tt.m2()方法因为是main线程调用的，先启动，然后因为 m1方法和m2方法都是同步的，锁的对象是调用对象，都是同一个调用对象tt ，所以执行完m2方法后再执行m1。。 同样的， t1.start(); tt.m1(); 也是先启动下面的tt.m1()方法，然后再启动t1.start()对应的 run() m1()
引用 3 楼 soapyuki 的回复:

public class TT implements Runnable {
	int b = 100;
        int i = 0;
	public synchronized void m1() throws Exception {
		System.out.println(Thread.currentThread().getName()+"线程进入m1");
		b = 1000;
		Thread.sleep(5000);
		i++;
		System.out.println("m1.b="+ b +",i=" + i+"线程是：" + Thread.currentThread().getName());
		System.out.println("结束m1");
	}

	public synchronized void m2() throws Exception {
		System.out.println(Thread.currentThread().getName()+"线程进入m2");
		Thread.sleep(2500);
		b = 2000;
		System.out.println("m2.b=" + b +",i="+ i+"线程是："+ Thread.currentThread().getName());
	}

	
	public void run() {
		try {
			System.out.println(Thread.currentThread().getName()+"开始执行run方法");
			m1();
		
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			System.out.println(Thread.currentThread().getName()+"执行run方法完毕");
		}
	}

	public static void main(String[] args) throws Exception {
		TT tt = new TT();
		Thread t1 = new Thread(tt);
		t1.setName("线程1");
		t1.start();
	
		tt.m1();
//		main线程进入m1
//		线程1开始执行run方法
//		m1.b=1000,i=1线程是：main
//		结束m1
//		线程1线程进入m1
//		m1.b=1000,i=2线程是：线程1
//		结束m1
//		线程1执行run方法完毕
		
		

//		tt.m2();
//		System.out.println(tt.b);
//		main线程进入m2
//		线程1开始执行run方法
//		m2.b=2000,i=0线程是：main
//		线程1线程进入m1
//		m1.b=1000,i=1线程是：线程1
//		结束m1
//		线程1执行run方法完毕

		
		
	}
}
这个是上面的运行结果，可以看看
引用 3 楼 soapyuki 的回复:

public class TT implements Runnable {
	int b = 100;
        int i = 0;
	public synchronized void m1() throws Exception {
		System.out.println(Thread.currentThread().getName()+"线程进入m1");
		b = 1000;
		Thread.sleep(5000);
		i++;
		System.out.println("m1.b="+ b +",i=" + i+"线程是：" + Thread.currentThread().getName());
		System.out.println("结束m1");
	}

	public synchronized void m2() throws Exception {
		System.out.println(Thread.currentThread().getName()+"线程进入m2");
		Thread.sleep(2500);
		b = 2000;
		System.out.println("m2.b=" + b +",i="+ i+"线程是："+ Thread.currentThread().getName());
	}

	
	public void run() {
		try {
			System.out.println(Thread.currentThread().getName()+"开始执行run方法");
			m1();
		
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			System.out.println(Thread.currentThread().getName()+"执行run方法完毕");
		}
	}

	public static void main(String[] args) throws Exception {
		TT tt = new TT();
		Thread t1 = new Thread(tt);
		t1.setName("线程1");
		t1.start();
	
		tt.m1();
//		main线程进入m1
//		线程1开始执行run方法
//		m1.b=1000,i=1线程是：main
//		结束m1
//		线程1线程进入m1
//		m1.b=1000,i=2线程是：线程1
//		结束m1
//		线程1执行run方法完毕
		
		

//		tt.m2();
//		System.out.println(tt.b);
//		main线程进入m2
//		线程1开始执行run方法
//		m2.b=2000,i=0线程是：main
//		线程1线程进入m1
//		m1.b=1000,i=1线程是：线程1
//		结束m1
//		线程1执行run方法完毕

		
		
	}
}
这个是上面的运行结果，可以看看
引用 3 楼 soapyuki 的回复:

public class TT implements Runnable {
	int b = 100;
        int i = 0;
	public synchronized void m1() throws Exception {
		System.out.println(Thread.currentThread().getName()+"线程进入m1");
		b = 1000;
		Thread.sleep(5000);
		i++;
		System.out.println("m1.b="+ b +",i=" + i+"线程是：" + Thread.currentThread().getName());
		System.out.println("结束m1");
	}

	public synchronized void m2() throws Exception {
		System.out.println(Thread.currentThread().getName()+"线程进入m2");
		Thread.sleep(2500);
		b = 2000;
		System.out.println("m2.b=" + b +",i="+ i+"线程是："+ Thread.currentThread().getName());
	}

	
	public void run() {
		try {
			System.out.println(Thread.currentThread().getName()+"开始执行run方法");
			m1();
		
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			System.out.println(Thread.currentThread().getName()+"执行run方法完毕");
		}
	}

	public static void main(String[] args) throws Exception {
		TT tt = new TT();
		Thread t1 = new Thread(tt);
		t1.setName("线程1");
		t1.start();
	
		tt.m1();
//		main线程进入m1
//		线程1开始执行run方法
//		m1.b=1000,i=1线程是：main
//		结束m1
//		线程1线程进入m1
//		m1.b=1000,i=2线程是：线程1
//		结束m1
//		线程1执行run方法完毕
		
		

//		tt.m2();
//		System.out.println(tt.b);
//		main线程进入m2
//		线程1开始执行run方法
//		m2.b=2000,i=0线程是：main
//		线程1线程进入m1
//		m1.b=1000,i=1线程是：线程1
//		结束m1
//		线程1执行run方法完毕

		
		
	}
}
这个是上面的运行结果，可以看看
谢谢
RATNG 2016-07-30
  • 打赏
  • 举报
 回复
线程1开始执行run方法 线程1线程进入m1 m1.b=1000,i=1线程是：线程1 结束m1 线程1执行run方法完毕
引用 4 楼 soapyuki 的回复:
首先是synchronized修饰的方法，是同步的，这个锁，锁的是调用对象，main方法里面 Thread t1 = new Thread(tt); t1.setName("线程1"); t1.start(); tt.m2(); 在main方法中，JVM启动创建了一个主线程去调用main方法。 t1.start()方法首先是 start():首先启动了线程，然后再由 jvm去调用该线程的run()方法。 所以tt.m2()方法因为是main线程调用的，先启动，然后因为 m1方法和m2方法都是同步的，锁的对象是调用对象，都是同一个调用对象tt ，所以执行完m2方法后再执行m1。。 同样的， t1.start(); tt.m1(); 也是先启动下面的tt.m1()方法，然后再启动t1.start()对应的 run() m1()
我仔细看了好久。终于明白两个进程怎么运行的了。O(∩_∩)O谢谢
RATNG 2016-07-29
  • 打赏
  • 举报
 回复
一开始不应该执行m1方法吗
anakin_feng 2016-07-29
  • 打赏
  • 举报
 回复
因为两个方法是同一个锁，所以m1()，m2()方法不能同时调用。 这个结果是因为，先进入了m2方法，所以m1一直等待，当m2执行完成，马上执行了m1， 至于m1和System.out.println(tt.b);执行顺序，感觉会先执行m1，这个我不确定
JAVA多线程之两个线程同时写一个文件
1.多线程    线程是程序执行流的最小单元。是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现出间断性。线程也有就绪、阻塞和运行三种基本状态。就绪状态是指线程具备
java多线程 文件夹_java多线程读同一个文件
java多线程同时读取一个文件，这个方法可行吗？不可行。 多线程能够提高效率是因为现在的cpu普遍是多核cpu, 多条线程可以在多个内核中同时执行来提高计算效率。但是计算机磁盘的磁头只有一个，即使多条线程去读也并不能提高读取效率，反而因为多线程的上下文切换问题会耗时更久。“java”中多线程按行读取txt且每个线程读的内容不能你把原来程序中直接读的地方，改成调用上面的函数，由该函数统一读行。这样，...
Java 多线程操作
以前一听到多线程操作就感到好腻害好腻害的，如果你现在也是这种情况或许这篇文章能够帮助到你。 1、什么是多线程？先了解两个概念 进程：正在运行的程序，是系统进行资源分配和调用的独立单位，有自己的内存空间和系统资源。 线程：是进程中的单个顺序控制流，是一条执行路径，线程是应用程序中执行的基本单元。某位大神的总结：进程就相当于工厂，线程就是工厂里的流水线，线程不能独立存在，必须存在于进程中。多进程：
java多线程批量读取文件(一)
新公司入职一个多月了，至今没有事情可以做，十来个新同事都一样抓狂，所以大家都自己学习一些新东西，我最近在看zookeeper，感觉蛮不错的，和微服务的zuul以及eureka功能类似，只是代码复杂了一些。而今天，我所要说的是java多线程读取文件的两个例子； 例子1：java多线程批量读取文件 package face.thread.ReadFile; /**  * 多线程读、写文件
java 类加载 线程安全_深入理解JVM-类加载和多线程
内存模型参考大神地址：Java内存模型即Java Memory Model，简称JMM。如果我们要想深入了解Java并发编程，就要先理解好Java内存模型。Java内存模型定义了多线程之间共享变量的可见性以及如何在需要的时候对共享变量进行同步。原始的Java内存模型效率并不是很理想，因此Java1.5版本对其进行了重构，现在的Java8仍沿用了Java1.5的版本。Java内存模型JMM决定一个线...
Java SE

62,625

社区成员

307,257

社区内容

发帖
与我相关
我的任务
社区描述
Java 2 Standard Edition
社区管理员
  • Java SE
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
暂无公告

试试用AI创作助手写篇文章吧

+ 用AI写文章