java菜鸟问-线程锁的问题!

Question

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() {
System.out.println(b);
}

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();
Thread.sleep(1000);
tt.m2();      //1000
System.out.println(tt.b);
}
}问题1:   tt.m2(); 调用的是输出b, b明明是100,怎么变成1000了啊>?
这是什么原因造成的?>  怎么跟线程走了同一个执行路径呢?2.线程会改变一个类中的属性值吗?>(如class TT {int b=100})  3. 锁的概念很模糊!只知道叫互斥锁,不知道什么意思, 请说下具体运用!4.互斥锁的目的是保存共享数据的完整性!~ 以上例子哪里属于共享数据( 是m1();吗:?)5.听过这么一句话" 加大锁的   粒度   , 就不容易产生死锁." 这个粒度指什么?6. 可否能将上面例子改成一个死锁阐述一下!

Answer 1

m1方法里的变量b...其实是对全局变量b的赋值....所以输出的是1000
 如果在m1方法里 这样定义  int b=1000；   那么输出的就是100了... 

Answer 2

更正：
把Thread.sleep(1000); 注释掉... 
就出来你想要的结果了... 

Answer 3

你用了synchronized进程同步信息，

Answer 4

public class TestDeadLock implements Runnable {
public int flag = 0;
Object o1 = new Object(), o2 = new Object();
public void run() {
System.out.println("flag = "+flag);
if(flag==0) {
synchronized(o1){
System.out.println("dsfasdf");
}
synchronized(o2){
System.out.println("o2=="+flag);
}
if(flag==1) {
synchronized(o2) {}
synchronized(o1) {
System.out.println("o1==="+flag);
}
}
}
}

public static void main(String[] args) {
TestDeadLock t1 = new TestDeadLock();
TestDeadLock t2 = new TestDeadLock();
t1.flag = 1;
t2.flag = 0;
Thread k1 = new Thread(t1);
Thread k2 = new Thread(t2);
k1.start();
k2.start();
}
}
//为什么这个不能成为死锁?>  能说下具体原因吗?>我知道中间  加上点 Thraed.sleep() 就能出现死锁!~ 可是为什么呀?
为什么这样就不行啊?.. 还能直接执行完!~
说说这其中的原因!~

Answer 5

public class TestDeadLock implements Runnable {
public int flag = 1;
static Object o1 = new Object(), o2 = new Object();
public void run() {
System.out.println("flag = "+flag);
if(flag == 1) {
synchronized(o1){
try{
Thread.sleep(10);
}catch(Exception e){}
synchronized(o2){
System.out.println("o2==");
}
}
}
if(flag == 0) {
synchronized(o2) {
synchronized(o1) {
System.out.println("o1===");
}
}
}
}
public static void main(String[] args) {
TestDeadLock t1 = new TestDeadLock();
TestDeadLock t2 = new TestDeadLock();
t1.flag = 1;
t2.flag = 0;
Thread k1 = new Thread(t1);
Thread k2 = new Thread(t2);
k1.start();
k2.start();
}
}//我就是想问 为什么要 sleep()一下, 总之要打断一下!
才能出现死锁!~而不打断为什么就不会出现呢???????????

Answer 6

sleep()之后只是能让你容易识别加了线程之后的效果,不加也可以,但你无法用肉眼看到程序运行的先后顺序.
死锁产生的原因是占用共享资源的线程正在请求其他共享资源，而该资源正在被其他线程占用，且占用该资源的线程还在请求其他共享资源，从而形成了线程永远无法得到继续执行所需要的资源，进而导致线程无法继续运行。加锁就是所谓的同步,比如一个对象给了一个线程之后,防止别的线程也来调用他,就要给这个对象加一把锁.当第一个线程放开或死亡之后,加的锁也打开,资源开放.就象银行系统,如果我有10000用卡在ATM机上取9000,而同时我朋友用我这张卡对应的存折在银行取了100,这样如果没用同步问题解决的话,我的帐户就有10900,而我们还一共取了10000 ``这在编写程序的时候是一定要注意的
再给你个出现互锁的例子  如A线程有a资源, B线程有b资源 ,A要得到b资源时候才放开a资源,B要得到a资源后才放开b资源,最后谁也不会得到产生互锁.
所以就要用到同步,他有3种写法.这里就不一一例举了.

Answer 7

我知道你所说明的意思!~  就象我写的那断程序, 如果不在A线程或B线程中间打断一下的话!~   就永远不会出现死锁!
再给你个出现互锁的例子  如A线程有a资源, B线程有b资源 ,A要得到b资源时候才放开a资源,B要得到a资源后才放开b资源,最后谁也不会得到产生互锁. 
//可是 如果中间没有打断, 他们都可以执行完, 而且不管谁放谁!~

Answer 8

我知道你所说明的意思!~  就象我写的那断程序, 如果不在A线程或B线程中间打断一下的话!~   就永远不会出现死锁!
再给你个出现互锁的例子  如A线程有a资源, B线程有b资源 ,A要得到b资源时候才放开a资源,B要得到a资源后才放开b资源,最后谁也不会得到产生互锁. 
//可是 如果中间没有打断, 他们都可以执行完, 而且不管谁放谁!~

Answer 9

我知道你所说明的意思!~  就象我写的那断程序, 如果不在A线程或B线程中间打断一下的话!~   就永远不会出现死锁!
再给你个出现互锁的例子  如A线程有a资源, B线程有b资源 ,A要得到b资源时候才放开a资源,B要得到a资源后才放开b资源,最后谁也不会得到产生互锁. 
//可是 如果中间没有打断, 他们都可以执行完, 而且不管谁放谁!~