java中的wait()和notify()使用实例

+ " sleep zzz...] ");
try {
synchronizeVariable.wait();
} catch (InterruptedException error) {
public static void main(String args[]) {
Thread[] threads = new Thread[2];
for (int count = 0; count < threads.length; count++) {
再往下看之前呢,首先最好复习一下Think in Java的14.3.1中第3部分内容：等待和通知,也就是wait()和notify了.
按照Think in Java中的解释:"wait()允许我们将线程置入“睡眠”状态，同时又“积极”地等待条件发生改变.而且只有在一个notify()或notifyAll()发生变化的时候，线程才会被唤醒，并检查条件是否有变."
}
public static void main(String[] args) {
DemoThread demoThread1 = new DemoThread();
}
public void run(){
TestThread t = (TestThread) Thread.currentThread();
如何利用wait() notify() notifyAll()?
在synchronized代码被执行期间，线程可以调用对象的wait()方法，释放对象锁标志，进入等待状态，并且可以调用notify()或者
notifyAll()方法通知正在等待的其他线程。notify()通知等待队列中的第一个线程，notifyAll()通知的是等待队列中的所有线程。
b.start();
System.out.println("b is start....");
synchronized(b)//括号里的b是什么意思,起什么作用?
{
try
{
System.out.println("Waiting for b to complete...");
try{
if (!t.getName().equalsIgnoreCase("1")) {
synchronized(this) {
wait();
}
}
while(true){
System.out.println("@time in thread"+ t.getName()+ "="+ t.increaseTime());
}
System.out.println("[thread_" + threadNo + " wakup!] ");
}
}
}
for (int count = 1; count <= 5; count++) {
System.out.println("[thread_" + threadNo + " print:]"
+ count + " ");
}
/**
* 在有同步的情况下，能打印出这样顺序的数字： 1 1 2 2 3 3 4 4 5 5
*/
private void countWithSync() {
synchronized (synchronizeVariable) {
}
}
}
一个理解wait()与notify()的例子
下面是我原来在CSDN论坛上看到的一个贴子，涉及到同步,wait(),notify()等概念的理解，我试着根据原来的一些回复和Think in Java上的相关概念将wait()和notify()这两个方法剖析了一下，欢迎指教.
package jdeveloper.study;
import ng.Runnable;
import ng.Thread;
public class DemoThread implements Runnable{
public DemoThread() {
public ThreadCounter(int threadNo) {
this.threadNo = threadNo;
}
public void run() {
countWithSync();
问题如下：
//分析这段程序，并解释一下，着重讲讲synchronized、wait(),notify 谢谢！
class ThreadA
{
public static void main(String[] args)
{
ThreadB b=new ThreadB();
java中的wait()和notify()使用实例
本例子实现了两个线程，每个线程输出1到100的数字。
第一个线程输出1-10，停止，通知第二个线程 输出1-10 第二个线程停止 通知第一个线程 输出11-20 ...
实现的要点是在Java中，每个对象都有个对象锁标志(Object lock flag)与之想关联，当一个线程A调用对象的一段synchronized代码时，
}
}
class ThreadB extends Thread
{
int total;
public void run()
{
synchronized(this)
{
System.out.println("ThreadB is running..");
threads[count] = new ThreadCounter(count);
threads[count].start();
}
}
private static class ThreadCounter extends Thread {
我们来解释一下这句话.
"wait()允许我们将线程置入“睡眠”状态",也就是说,wait也是让当前线程阻塞的,这一点和sleep或者suspend是相同的.那和sleep,suspend有什么区别呢?
return ++time;
}
}
Java的线路同步示例（synchronized、wait和notify）
从网上找到的代码（随便改的）。比较清晰地展示了wait和notify的运行机制。
package com.wubuku.mytest;
public class ThreadingExample {
/**
* 在没有同步的情况下，这个方法会打印出不定顺序的数字
*/
public static void count() {
for (int count = 1; count <= 5; count++)
它首先要获取与这个对象关联的对象锁标志，然后执行相应的代码，执行结束后，把这个对象锁标志返回给对象；因此，在线程A执行
synchronized代码期间，如果另一个线程B也要执行同一对象的一段synchronized代码时（不一定与线程A执行的相同），它将
要等到线程A执行完后，才能继续....
for (int i=0;i<100;i++ )
{
total +=i;
System.out.println("total is "+total);
}
notify();
}
}
}
要分析这个程序,首先要理解notify()和wait(),为什么在前几天纪录线程的时候没有纪录这两个方法呢,因为这两个方法本来就不属于 Thread类,而是属于最底层的object基础类的,也就是说不光是Thread，每个对象都有notify和wait的功能，为什么？因为他们是用来操纵锁的,而每个对象都有锁,锁是每个对象的基础,既然锁是基础的,那么操纵锁的方法当然也是最基础了.
private int time = 0 ;
public TestThread(Runnable r,String name){
super(r,name);
}
public int getTime(){
return time;
}
public int increaseTime (){
synchronizeVariable.notifyAll();
if (count < 5) {
System.out.println("[thread_" + threadNo
System.out.print(count + " ");
}
public static Object synchronizeVariable = "locking variable";
private int threadNo;
if(t.getTime()%10 == 0) {
synchronized(this) {
System.out.println("****************************************");