多线程 wait用法

不会的调用wait方法等于调用object中的wait(0)
jdk 文档是这样写的在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。
当前线程必须拥有此对象监视器。此方法导致当前线程（称之为 T）将其自身放置在对象的等待集中，然后放弃此对象上的所有同步要求。出于线程调度目的，在发生以下四种情况之一前，线程 T 被禁用，且处于休眠状态：其他某个线程调用此对象的 notify 方法，并且线程 T 碰巧被任选为被唤醒的线程。
其他某个线程调用此对象的 notifyAll 方法。
其他某个线程中断线程 T。
大约已经到达指定的实际时间。但是，如果 timeout 为零，则不考虑实际时间，在获得通知前该线程将一直等待。然后，从对象的等待集中删除线程 T，并重新进行线程调度。然后，该线程以常规方式与其他线程竞争，以获得在该对象上同步的权利；一旦获得对该对象的控制权，该对象上的所有其同步声明都将被恢复到以前的状态，这就是调用 wait 方法时的情况。然后，线程 T 从 wait 方法的调用中返回。所以，从 wait 方法返回时，该对象和线程 T 的同步状态与调用 wait 方法时的情况完全相同。如果 timeout 为零，则不考虑实际时间，在获得通知前该线程将一直等待

synchronized (t)这里不要用t，换一个其他的对象就可以了。从输出结果：MyThread---->15
main---->12可知，这可能是由于t代表的线程结束导致的。

这个还真不知道，但是我知道目前的解释都是错误的，因为package w0141212;public class ThreadTest {
    public static void main(String[] args) throws Exception {
        Thread t = new Thread(new MyThread());
        t.start();
        Thread.sleep(1000);
        for (int i = 0; i < 20; i++) {
            if (i == 12) {
                synchronized (t) {
                    try {
                        t.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            System.out.println("main ----> " + i);
        }
    }
}class MyThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 16; i++) {
            System.out.println("MyThread ----> " + i);
        }
    }
}
你会发现在wait那里卡主了

楼主啊，T根本就不是main线程好吗,T.wait()当然不会阻塞主线程。

我猜测是和main有关系，验证如下：package yzqdayself;public class ThreadTest {
        public static void main(String[] args) throws Exception {
            Thread t = new Thread(new MyThread1());
            t.start();
            Thread t2 = new Thread(new MyThread2());
            t2.start();
        }
    }

    class MyThread1 implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 16; i++) {
                System.out.println("thread1=====" + i);
                try
                {
                    Thread.sleep(1000);
                }
                catch (InterruptedException e)
                {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
    class MyThread2 implements Runnable {
        String s="123";
        @Override
        public void run() {
            for(int i =0;i<20;i++){
                if(i==12){
                    synchronized (s) {
                        try {
                            s.wait();
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
                System.out.println("Thread2======="+i);
            }
        }
    }结果为：thread1=====0
Thread2=======0
Thread2=======1
Thread2=======2
Thread2=======3
Thread2=======4
Thread2=======5
Thread2=======6
Thread2=======7
Thread2=======8
Thread2=======9
Thread2=======10
Thread2=======11
thread1=====1
thread1=====2
thread1=====3
thread1=====4
thread1=====5
thread1=====6
thread1=====7
thread1=====8
thread1=====9
thread1=====10
thread1=====11
thread1=====12
thread1=====13
thread1=====14
thread1=====15之后就永远等待了，如果知道为啥记得@我啊，学习中

啥意思？你的意思是t.wait是t线程阻塞
不会吧应该是那个线程执行到t.wait就会阻塞此线程该线程就会释放锁并t对象的等待集中，

不清楚，关注一下。其实楼主贴的代码，运行多次也会发现wait的情况。

周末没有人上csdn吗
那位大神能帮我解决一下问题
我把synchronized(t) 的换为synchronized(obj) 为什么对象锁为一个线程时就不可以了
代码如下:
public class ThreadTest {
public static void main(String[] args) throws Exception {
Thread t = new Thread(new MyThread());
t.start();
Object obj = new Object();
for (int i = 0; i < 20; i++) {
if (i == 12) {
synchronized (obj) {
System.out.println("before wait");
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
System.out.println("main---->" + i);
}
}
}
class MyThread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("MyThread---->" + i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
执行结果如下
main---->0
main---->1
main---->2
main---->3
main---->4
main---->5
main---->6
main---->7
main---->8
main---->9
main---->10
main---->11
before wait
MyThread---->0
MyThread---->1
MyThread---->2
MyThread---->3
MyThread---->4
MyThread---->5
MyThread---->6
MyThread---->7
MyThread---->8
MyThread---->9主线程处在阻塞状态

对象锁为一个线程时，其他没有对该对象进行同步处理的线程是不受影响的。synchronized同步处理，锁住的是对象，而不是代码，这里main线程锁住的是obj，而副线程并没有obj这个对象，和主线程无关，所有没有影响。

我去真的没有想到有这种情况
当一个thread结束时会先获取当前对于自己线程的锁，最后，通知其他线程（相当于调用notify方法）
你看一下这个
http://zhidao.baidu.com/question/101106514.html?fr=push

我去真的没有想到有这种情况
当一个thread结束时会先获取当前对于自己线程的锁，最后，通知其他线程（相当于调用notify方法）
你看一下这个
http://zhidao.baidu.com/question/101106514.html?fr=push

意思就是说，当锁住的是线程对象时，如果其他线程都结束了，就会自动notifyall，所以被锁住的线程就会被唤醒了的意思么？谢谢，学习了

第一个程序你的锁和MyThread对象一样，你这个程序太小了，在一个时间片内早就全部执行完了因此Main线程打印到11
MyThread线程一下子执行完了事实上当Main执行到11时，进入不了同步代码块，因为这时候锁对象被MyThread线程占据没释放呢当MyThread执行完，Main对象进入wait，而wait马上就再次获得了锁，因此继续执行第二个程序，你换了锁，两个线程锁不一样，彼此没有干涉打印的话可能会出现交叉打印，但并不代表执行的顺序就是那样

你这个说法有问题吧当i==12时你说“进入不了同步代码块，因为这时候锁对象被MyThread线程占据没释放呢”
锁对象怎么会被mythread线程占据呢在对象t中线程根本没有线程去拿锁啊没有类似synchronized(thiis)代码，怎么可会被其占用

Thread结束时会先获取自身的锁，然后调用自身的notifyAll方法。
你可以在t.start()后面加上语句Thread.sleep(1000);这样main线程还没来得及调用wait方法子线程先结束了，如此就不会再走下去啦。

synchronized进行同步处理，可以有同步代码块和同步方法，同步代码块锁住的是你指定的对象，同步方法锁住的是使用该方法的对象。你的线程如果有synchronized进行了处理，执行前就会要获得对象的锁，否则等待其他线程释放锁。如果没有synchronized处理的线程，则程序直接执行，不用获得对象锁，以为该线程没有进行同步处理。所有多线程的并发处理，都要进行同步处理才能获得理想的效果。

t线程结束时会释放自己拥有的锁。此处涉及到操作系统知识，因为wait会调用本地方法wait0。进入操作系统的线程管理。

会不会因为你在等待之前线程已经运行完毕了，我把MyThread类中循环次数改到了160，发现运行完之后，man方法才运行，如果我没猜错，你想实现的功能是，当man循环中i等于12的时候，让MyThread类这个线程等待运行，然后当man运行完毕以后，在运行MyThread，如果是的话逻辑纠错了

调试易

多线程 wait用法

解决方案 »