线程死锁问题 - ITeye问答

0 0

线程死锁问题5

以下程序为了学习而写
两个线程依次按序打印从1到100，一个只打印奇数，另一个只打印偶数。但是经常发生死锁，请问为什么
public class Test16 implements Runnable{

private int turn;
private int num;
private int sum;
static Integer counter=0;
public Test16(int turn,int num,int sum){
this.turn=turn;
this.num=num;
this.sum=sum;
}
public synchronized void run() {
while(counter<sum){
while(turn!=counter%num){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}

counter++;
System.out.print(counter+" ");
notifyAll();

}

}

public static void main(String[] args){
new Thread(new Test16(0,2,100)).start();
new Thread(new Test16(1,2,100)).start();
}

}

2014年5月27日 11:26

hufangxian
37
0 0 17

5个答案按时间排序按投票排序

0 0

采纳的答案

问题在public synchronized void run() { 相当于 synchronized(this),而 main中
new Thread(new Test16(0,2,100)).start();
new Thread(new Test16(1,2,100)).start();
这样是2个不同的test16对象，因而是2个不同的锁，2个锁都在等待自己的资源（2个线程都停止了），所以不可能被唤醒。其实楼主想锁定的是共享的counter，counter的是static的，属于类对象，所以要在类上加锁才行。
代码修改如下：

public void run() {
		synchronized (Test16.class) {
			while (counter < sum) {
				while (turn != counter % num) {
					try {
						Test16.class.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}

				counter++;
				System.out.println(counter + "   turn : " + turn);
				Test16.class.notifyAll();

			}
		}

	}

2014年5月27日 13:00

guazi
454
0 0 14

3条评论

0 0

首先回答lz的问题，为什么会死锁。代码稍微改一下：

while (counter < sum) {
            while (turn != counter % num) {
                try {
                    System.out.println(Thread.currentThread().getName() + " is waiting, " +
                    		"count=" + counter + ", turn=" + turn);
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            counter++;
            System.out.print(counter + " ");
            notifyAll();

        }

增加了一条打印语句。
一个可能的输出：

1 Thread-0 is waiting, count=1, turn=0
2 Thread-1 is waiting, count=2, turn=1

看到没，虽然counter改变了，但由于线程1和线程2不是在同一把锁上进行同步，因此counter的改变并没有触发notifyAll

至于如何修改，前面的答案都回答了

2014年5月27日 14:23

bylijinnan
42
0 1 9

添加评论

0 0

可以先看看notifyAll和wait的javadoc：“This method should only be called by a thread that is the owner of this object's monitor”，你这个程序的问题就是你把线程实例本身当做锁，但多个线程是不同的实例，就不是同一把锁了，所以程序比较混乱，可以通过简单添加一把锁可以解决：

public class Test16 implements Runnable {

    private int    turn;
    private int    num;
    private int    sum;
    static Integer counter = 0;
    static Object  lock    = new Object();

    public Test16(int turn, int num, int sum){
        this.turn = turn;
        this.num = num;
        this.sum = sum;
    }

    public void run() {
        synchronized (lock) {
            while (counter < sum) {
                while (turn != counter % num) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                counter++;
                if (counter <= sum) {
                    System.out.print(counter + " ");
                }
                lock.notifyAll();
            }
        }
    }

    public static void main(String[] args) {
        new Thread(new Test16(0, 3, 100), "A").start();
        new Thread(new Test16(1, 3, 100), "B").start();
        new Thread(new Test16(2, 3, 100), "C").start();
    }

}

2014年5月27日 13:31

iamiwell
30
0 0 1

1条评论

0 0

楼主，根本原因是你这里用了两个不同的对象，是不会实现互斥效果的

引用

new Thread(new Test16(0,2,100)).start();
new Thread(new Test16(1,2,100)).start();

这里两个Test16的对象，每个对象都可以进入你synchronized 的run方法。
这了互斥可以用类似生产者消费者李模式这种概念，或者直接使用阻塞队列，开始时队列只存放一个1，两个线程轮流每次在队列里取，取到消费后，将加1的结果再放入队列，此时notifyAll,另一个线程就可以取到数据。当前线程就会阻塞，以此可以实现你要的效果。

2014年5月27日 13:03

chainhou
192
0 0 15

添加评论

0 0

while(turn!=counter%num){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}

turn不等于的时候，然后就wait,
线程调用了wait，就会进入休眠状态并且释放锁，直到其他线程调用相同对象的notify或者notifyAll，这个线程才会（notify的话只是有可能会）重新进入执行队列。当这个线程开始执行的时候它会再次接管锁并执行wait后面的内容（接管锁这个动作会等待锁被其他线程释放）。

2014年5月27日 11:57

黄菲菲
179
0 1 14