创建两个线程，第一个线程启动调用wait()方法进入阻塞状态，等待另一个线程来唤醒；第二个线程启动后睡眠一段时间，苏醒后调用notifyall()方法唤醒处于阻塞状态的另一个线程。

### 回答1：
题目描述：创建两个线程，第一个线程启动调用wait()方法进入阻塞状态，等待另一个线程来唤醒；第二个线程启动后睡眠一段时间，苏醒后调用notifyAll()方法唤醒处于阻塞状态的另一个线程。

答案：这道题目考察了Java多线程的wait()和notifyAll()方法，第一个线程调用wait()进入阻塞状态，等待第二个线程的唤醒；第二个线程睡眠一段时间后，调用notifyAll()方法唤醒处于阻塞状态的另一个线程。注意，在调用wait()和notifyAll()方法时，必须先获得锁，否则会抛出IllegalMonitorStateException异常。

### 回答2：
在Java中，一个线程可以调用wait()方法进入阻塞状态，并等待其他线程唤醒它。同时，一个线程也可以调用notify()或notifyAll()方法来唤醒处于阻塞状态的其他线程。

为了演示这个过程，我们可以创建两个线程：线程A和线程B。线程A首先启动，并调用wait()方法进入阻塞状态；同时，线程B启动后睡眠一段时间，然后调用notifyAll()方法唤醒处于阻塞状态的线程A。

具体的代码实现如下：

public class WaitNotifyDemo {
    public static void main(String args[]) {
        Object lock = new Object();
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    try {
                        System.out.println("Thread A start");
                        lock.wait();
                        System.out.println("Thread A is notified");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    try {
                        System.out.println("Thread B start");
                        Thread.sleep(3000);
                        lock.notifyAll();
                        System.out.println("Thread B notifies all");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        threadA.start();
        threadB.start();
    }
}

在上面的代码中，我们创建了一个对象lock作为两个线程之间的锁。线程A启动后，进入锁的同步块，调用wait()方法，进入阻塞状态，等待线程B调用notifyAll()方法来唤醒它。线程B启动后，也进入锁的同步块，调用sleep()方法睡眠3秒钟，然后调用notifyAll()方法，将锁的状态改变并通知等待在锁上的线程，将它们唤醒。

当线程B唤醒线程A后，线程A继续执行。线程A输出一条消息，说明它被唤醒了。线程B也输出一条消息，说明它已经唤醒了线程A。

通过这个例子，我们可以看到，wait()和notifyAll()方法是Java中线程之间进行协作的重要手段之一。当多个线程需要相互合作来完成某个任务时，我们可以使用这些方法来保证线程之间的正确协作。

### 回答3：
在Java中，创建多线程是常见的操作，通过多线程可以让程序同时执行多个任务，提高程序的效率。创建两个线程，其中一个线程调用wait()方法进入阻塞状态，等待另一个线程的唤醒，另一个线程则调用notifyAll()方法唤醒处于阻塞状态的另一个线程。

首先，需要创建一个类来实现多线程操作，并实现Runnable接口。在run()方法中，使用synchronized同步块来保证方法的同步性，保证两个线程可以正确执行。

创建两个线程，一个线程调用wait()方法进入阻塞状态：

class ThreadOne implements Runnable{
    public synchronized void run(){
        try{
            System.out.println("线程1进入等待状态！");
            wait(); //线程1进入等待状态
        }catch(Exception e){  
            e.printStackTrace();  
        }  
        
    }  
}

class ThreadTwo implements Runnable{
    public synchronized void run(){
        try{
            System.out.println("线程2开始睡眠，等待5秒钟后唤醒线程1！");
            Thread.sleep(5000); //线程2睡眠5秒钟
            notifyAll(); //唤醒处于阻塞状态的线程1
        }catch(Exception e){  
            e.printStackTrace();  
        }  
        
    }  
}

public class TestThreads {  
    public static void main(String[] args){  
        ThreadOne thread1 = new ThreadOne();  
        ThreadTwo thread2 = new ThreadTwo();  
          
        //创建线程并启动  
        Thread t1 = new Thread(thread1);  
        Thread t2 = new Thread(thread2);  
        t1.start();  
        t2.start();  
    }  
}

执行以上代码，会先输出“线程1进入等待状态！”，然后线程1进入阻塞状态等待被唤醒，线程2开始睡眠，过5秒钟后线程2调用notifyAll()方法唤醒线程1，线程1继续执行。

在Java中，synchronized是Java提供的同步关键字。当有两个或两个以上的线程需要访问某一资源时，为了避免造成混乱，需要对资源进行同步。同步块中的代码段一次只能被一个线程执行，其他线程必须等待该线程执行完毕之后才能继续执行，从而避免了线程之间的竞争。使用wait()和notifyAll()方法可以进一步保证线程的同步性和正确性，使程序能够按照预期顺序执行。

以上就是创建两个线程，其中一个线程调用wait()方法进入阻塞状态，等待另一个线程的唤醒，另一个线程则调用notifyAll()方法唤醒处于阻塞状态的另一个线程的方法。