055-15.线程

Question

package t055;
public class Computation extends Thread{
private int num;
private boolean isComplete;
private int result;

public Computation(int nu) {
num=nu;
} @Override
public synchronized void run() {
// TODO Auto-generated method stub
result=num*2;
isComplete=true;
notify();
}

public synchronized int getResult(){
while (!isComplete){
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

return result;
}

public static void main(String[] args) {
Computation [] computations=new Computation[4];
for (int i = 0; i < computations.length; i++) {
computations[i]=new Computation(i);
computations[i].start();
}

for (Computation c :computations){
System.out.print(c.getResult()+",");
}
}
}A.    The code will deadlock. 
B.  The code may run with no output. 
C.  An exception is thrown at runtime. 
D.  The code may run with output "0 6". 
E.  The code may run with output "2 0 6 4". 
F.  The code may run with output "0 2 4 6". Answer: F 我觉得E也有可能出现，大家说呢

Answer 1

我觉得还是F
for (Computation c :computations){
            System.out.print(c.getResult()+",");
        }
结果是按顺序打印的，前一个数值未打出来时，后面的语言暂时不会执行

Answer 2

cpu反应没那么迟钝吧，虽然那个synchronized在这个程序里没什么用

Answer 3

把程序稍做改动，让每个sleep一会儿，居然什么都不输出，停在那儿了。public class Computation extends Thread{
    private int num;
    private boolean isComplete;
    private int result;    public Computation(int nu) {
        num=nu;
    }    @Override
    public synchronized void run() {
        // TODO Auto-generated method stub
        result=num*2;
        isComplete=true;
        try {
            Thread.sleep(num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        notify();
    }    public synchronized int getResult(){
        while (!isComplete){
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }        return result;
    }    public static void main(String[] args) {
        Computation [] computations=new Computation[4];
//        for (int i = 0; i < computations.length; i++) {
//            computations[i]=new Computation(1000-i);
//            computations[i].start();
//        }        computations[0]=new Computation(400);
        computations[1]=new Computation(300);
        computations[2]=new Computation(200);
        computations[3]=new Computation(100);        for (Computation c :computations){
            System.out.print(c.getResult()+",");
        }
    }
}

Answer 4

执行for (Computation c :computations){
            System.out.print(c.getResult()+",");
        }
的条件是线程执行完run方法，原因是对象的单一锁机制
另外这里是四个对象，所以每个对象之间不存在同步问题
所以现在流程是4个互不干扰的线程（这样说其实是错的，因为程序里涉及通知等待机制，但是这里不会带来同步问题），但只有第一个线程结束后，才会打印第一个c.getResult()(因为之前这个for each一直在阻塞)，一次类推打印0246

Answer 5

线程都没有start(),不执行run方法可不是一直阻塞吗

Answer 6

ls的话没看懂啊，什么是对象的单一锁，头一次听说也google不到。

Answer 7

5楼正解！
这里的多线程容易被锁啊什么的误导!
这里其实就是做了一个异步处理的作用，所以在打印时，都不用关心哪个线程先执行，哪个后执行，只需要看主线程就可以了！主线程是顺序打印的各个执行结果，所以就是F，
换句话说
在for (Computation c :computations){
            System.out.print(c.getResult()+",");
        }
中c=computations[0]时，c.getResult（）如果没有结果的话，循环不会往下执行，主线程是被拥塞的

Answer 8

所有的对象都自动含有单一的锁（也叫做监视器），挡在对象上调用任意synchronized的时候，此对象都会加锁，这是该对象上其他的synchronized方法只有等到前一个方法执行结束后并释放锁后才能被调用

Answer 9

都是因为 theoffspring 在深入学习多线程 大家也就跟着学学 
哈哈 很猛的 theoffspring 例子都写到了 055.179  有点恐怖

Answer 10

现在发现自己懂Java的东西太少了 从暑假学Java以来  这种用法第一次看
是遍历数组吗        for (Computation c :computations){
            System.out.print(c.getResult()+",");
        }

Answer 11

其实这道题并不是很难，当时想错了，每个线程虽然执行顺序并不保证，但遍历时时候却是按顺序去遍历的，因此可以严格保证顺序是0246.我只是在做scjp的题。