4个子线程按顺序执行，发生死锁~~求教

Question

详细代码如下：
class Test1{
public static void main(String[] args)
{
Order o=new Order();
MyT my1=new MyT(o);
my1.setName("1");
MyT my2=new MyT(o);
my2.setName("2");
MyT my3=new MyT(o);
my3.setName("3");
MyT my4=new MyT(o);
my4.setName("4");
my1.start();
my2.start();
my3.start();
my4.start();

}
}class MyT extends Thread{
Order o;
public MyT(Order o)
{
this.o=o;
}
public void run()
{
for(int i=0;i<100;i++)
{
o.talk();
//java.util.Random r=new java.util.Random();
//try{
// Thread.sleep(r.nextInt(2));
//}catch(Exception e){
//}

}
}
}class Order{

int order=1;
int index=0;

public synchronized  void talk()
{


Thread t=Thread.currentThread();
String name=t.getName();
int i=Integer.parseInt(name);
if(i==this.getOrder())
{
System.out.println(Thread.currentThread().getName()+"在执行，第"+this.index+"次");
try{
this.setOrder(i+1);
this.index++;
this.notifyAll();
}catch(Exception ex){
ex.printStackTrace();
}
}
else
{
try{
this.wait();
}catch(Exception e){
e.printStackTrace();
}
}
}

public  int getOrder()
{
return this.order;
}

public  void setOrder(int order)
{
if(order<5)
{
this.order=order;
}else
{
this.order=1;
}
}
}每次执行程序，有时候死锁，有时候执行完毕但没有达到循环次数~~~~
求教

Answer 1

else{
    this.notify();
    this.wait();
}终于找到原因!!
你WAIT()前 应该在加个 notify()释放
不然 考虑下面的情况
mt[1] mt[2] mt[3] WAIT状态
Order=4 mt[4] 执行 然后 再释放 这个时候 Order=1
这个时候假如 是mt[2]这个线程活动了 mt[4]也在活动中 mt[1,3]还处于wait()状态
然后mt[2]线程也wait();接着mt[4]也wait();
呵呵 全部wait(),没有线程来唤醒了其他的了
而且 当mt执行到了最后一个的时候
那么 至少有3个线程永远等待
我重新写的你看看
public class Main{
    public static void main(String[] args){
        Order o=new Order();
        Mt[] ts=new Mt[4];
        for (int i= 0; i <4; i++) {
            ts[i]=new Mt(o);
            ts[i].setName(String.valueOf(i+1));
        }
        for (int i= 0; i<4 ; i++) {
            ts[i].start();
        }
    }
    static class Mt extends Thread{
        private Order o=null;
        public Mt(Order o){
            this.o=o;
        }
        public void run(){
            for (int i= 0; i <100; i++) {
                o.talk();
                try{
                    //this.sleep(100);
                }catch(Exception ex){
                    System.out.println("error:"+ex.getMessage());
                }
            }
        }
    }
    static class Order{
        private int order=1;
        private int index=1;
        private int wait=1;
        public int getOrder(){return this.order;}
        public void setOrder(int order1){
            if(order1<5)this.order=order1;
            else order=1;
        }
        synchronized public void talk(){
            Thread t=Thread.currentThread();
            int i=Integer.parseInt(t.getName());
            try{
                if(i==this.getOrder()){
                    this.setOrder(i+1);
                    System.out.println("thread:"+i+"runing "+index+++" now Order:"+this.getOrder());                    
                    this.notify();
                }else{
                    System.out.println("thread:"+i+"wait "+wait+++" now Order:"+this.getOrder());
                    this.notify();
                    this.wait();
                }
            }catch(Exception ex){
                System.out.println("error:"+ex.getMessage());
            }
            
        }
    }
}我也在看线程 我们一起讨论下把

Answer 2

把分给我吧，看我修改的代码，你运行后就知道问题了
哈哈哈，有点搞笑
package test.thread;class Test1 {
  public static void main(String[] args) {
    Order o = new Order();
    MyT my1 = new MyT(o);
    my1.setName("1");
    MyT my2 = new MyT(o);
    my2.setName("2");
    MyT my3 = new MyT(o);
    my3.setName("3");
    MyT my4 = new MyT(o);
    my4.setName("4");
    my1.start();
    my2.start();
    my3.start();
    my4.start();  }
}class MyT extends Thread {
  Order o;  public MyT(Order o) {
    this.o = o;
  }  public void run() {
    for (int i = 0; i < 100; i++) {
      o.talk();
    }
    System.out.println(Thread.currentThread().getName() + " FINISHED");
  }
}class Order {  int order = 1;  int index = 0;  public synchronized void talk() {
    Thread t = Thread.currentThread();
    String name = t.getName();
    int i = Integer.parseInt(name);
    System.out.println(name + "=" + i + "/" + this.getOrder());
    if (i == this.getOrder()) {
      System.out.println(Thread.currentThread().getName() + "在执行，第" + this.index + "次");
      try {
        this.setOrder(i + 1);
        this.index++;
        this.notifyAll();
      } catch (Exception ex) {
        ex.printStackTrace();
      }
    } else {
      try {
        this.wait();
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
  }  public int getOrder() {
    return this.order;
  }  public void setOrder(int order) {
    if (order < 5) {
      this.order = order;
    } else {
      this.order = 1;
    }
  }
}问题在于，某个线程竟然完成了，你的那个判断就 永远没有机会执行啦！哈哈哈！

Answer 3

to KK3K2005 
你的思路应该是对的~~但是还是可能会发生死锁，例如：
1线程将要运行，但2线程抢到了，他判断一下，就会休眠，
接下来3，4线程同样的判断，休眠~~然后程序就什么都不执行了~~~这线程真是搞死人啦~~~~~

Answer 4

wait()前notiy(）释放就没事情了
因为你是４个线程枪一个方法
所以只要枪到方法的线成　在退出时notiy()就可以了
不管当前活动线程是那个 只要他WAIT前进行了释放那总有一个线程序在活动着你的代码最大的问题是
当某个线程全部执行完毕的时候 
这样也就是说当order值等于完毕线程的值的时候
剩余的3个线程全没有办法继续下去了

Answer 5

我的问题终于解决了~~~
把同步方法中的if改为while就是了，这样能”套住“某个线程，不使它过早的结束掉
而让后面的线程等待这个已经结束的线程~~~~~详细代码如下：
public class Main{
    public static void main(String[] args){
        Order o=new Order();
        Mt[] ts=new Mt[4];
        for (int i= 0; i <4; i++) {
            ts[i]=new Mt(o);
            ts[i].setName(String.valueOf(i+1));
        }
        for (int i= 0; i<4 ; i++) {
            ts[i].start();
        }
    }
    
    static class Mt extends Thread{
        private Order o=null;
        public Mt(Order o){
            this.o=o;
        }
        public void run(){
            for (int i= 0; i <200; i++) {
try{
                    this.sleep(100);
                }catch(Exception ex){
                    System.out.println("error:"+ex.getMessage());
                }                o.talk();
                try{
                    //this.sleep(100);
                }catch(Exception ex){
                    System.out.println("error:"+ex.getMessage());
                }
            }
        }
    }
    
    static class Order{
        private int order=1;
        private int index=1;
        private int wait=1;
        public int getOrder(){return this.order;}
        public void setOrder(int or){
            if(or<5)
this.order=or;
            else 
this.order=1;
        }
        public synchronized void talk(){            Thread t=Thread.currentThread();
            int i=Integer.parseInt(t.getName());
            try{
                while(i!=this.getOrder()){
//this.notifyAll();
                    System.out.println("线程:"+i+"等待第 "+wait+++"次，现在要执行的线程是:"+this.getOrder());
                    this.wait();
//return;
                }
   this.setOrder(i+1);
   System.out.println("线程:"+i+"*****************************正在运行第 "+index+++"次，下个等执行的线城是:"+this.getOrder());                
                   this.notifyAll(); 
            }catch(Exception ex){
                System.out.println("error:"+ex.getMessage());
            }
            
        }
    }
}

Answer 6

谢谢，KK3K2005 ，老紫竹
结贴