sleep()、wait()、join()、yield()
yield
在Java中,yield()
是一个Thread类的方法,它用于暂停当前线程并允许其他线程运行。它是一种线程调度的建议,告诉调度器可以切换到其他就绪状态的线程。调用yield()
方法后,线程会从运行状态转换为就绪状态,让其他线程有机会执行。
下面是一个简单的Java代码示例,展示了yield()
方法的用法:
public class YieldExample implements Runnable {
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + ": " + i);
// 调用 yield() 方法
Thread.yield();
}
}
public static void main(String[] args) {
// 创建两个线程
Thread thread1 = new Thread(new YieldExample(), "Thread 1");
Thread thread2 = new Thread(new YieldExample(), "Thread 2");
// 启动线程
thread1.start();
thread2.start();
}
}
在上面的示例中,我们创建了两个线程并启动它们。每个线程都会打印从0到4的数字。在每次循环中,我们调用了yield()
方法,这样两个线程就可以交替执行,让出CPU时间给其他线程。
请注意,yield()
方法的调用并不能保证当前线程一定会让出CPU时间,它只是一个建议。实际执行结果取决于操作系统和线程调度器的具体实现。
join
在Java中,join()
是Thread类的一个方法,用于等待调用该方法的线程执行完毕。当一个线程调用另一个线程的 join()
方法时,调用线程将被阻塞,直到被调用的线程执行完毕。
join()
方法有以下两种常见的用法:
- 使用
join()
方法等待单个线程完成:
Thread thread = new Thread(new MyRunnable());
thread.start();
// 在主线程中调用 join() 方法等待 thread 线程执行完毕
try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread 执行完毕");
在上面的示例中,我们创建了一个新线程并启动它。在主线程中,我们调用了join()
方法等待新线程执行完毕。主线程会被阻塞,直到新线程执行完毕后才会继续执行。
- 使用
join()
方法等待多个线程完成:
Thread thread1 = new Thread(new MyRunnable());
Thread thread2 = new Thread(new MyRunnable());
thread1.start();
thread2.start();
// 在主线程中分别调用 join() 方法等待 thread1 和 thread2 线程执行完毕
try {
thread1.join();
thread2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread1 和 thread2 执行完毕");
在上面的示例中,我们创建了两个新线程,并启动它们。然后在主线程中分别调用两个线程的 join()
方法,以等待它们执行完毕。主线程会被阻塞,直到两个线程都执行完毕后才会继续执行。
需要注意的是,join()
方法可能会抛出 InterruptedException
,因此在使用时需要处理异常。这是由于线程在等待期间可能被中断,导致 join()
方法提前返回。
使用 join()
方法可以实现线程之间的协作和同步,确保某个线程在其他线程执行完毕后再继续执行。
sleep
在Java中,sleep()
是Thread类的一个静态方法,用于暂停当前线程的执行一段指定的时间。它是一种线程睡眠的机制。
sleep()
方法有以下两种常见的用法:
- 使用
sleep()
方法暂停当前线程的执行:
try {
// 暂停当前线程执行 500 毫秒(0.5 秒)
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程睡眠后继续执行");
在上面的示例中,我们使用 sleep()
方法暂停当前线程的执行。在这个例子中,当前线程将会睡眠500毫秒(0.5秒),然后继续执行后续的代码。
需要注意的是,sleep()
方法可能会抛出 InterruptedException
,因此在使用时需要处理异常。这是由于线程在睡眠期间可能被中断,导致 sleep()
方法提前返回。
- 使用
sleep()
方法实现定时任务:
class MyTask implements Runnable {
public void run() {
try {
// 定时任务,每隔 1 秒执行一次
while (true) {
System.out.println("执行定时任务");
Thread.sleep(1000);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
// 创建一个新线程执行定时任务
Thread thread = new Thread(new MyTask());
thread.start();
在上面的示例中,我们创建了一个新线程来执行定时任务。在定时任务的循环中,我们使用 sleep()
方法使线程睡眠1秒,然后再执行下一次循环。这样就可以实现定时任务的效果。
需要注意的是,sleep()
方法会暂停当前线程的执行,但不会释放锁。如果在同步代码块或同步方法中调用 sleep()
方法,其他线程仍然无法获取到该锁。因此,在使用 sleep()
方法时要注意对锁的使用,避免可能的线程竞争和死锁问题。
总结:
sleep()
方法用于暂停当前线程的执行一段指定的时间。它可以用于实现线程的延时执行、定时任务等场景。然而,需要注意处理可能抛出的 InterruptedException
异常,并避免在同步代码块或同步方法中使用 sleep()
方法导致的线程竞争和死锁问题。
wait
在Java中,wait()
是Object类的一个方法,用于使当前线程进入等待状态,直到其他线程调用相同对象上的 notify()
或 notifyAll()
方法来唤醒等待线程。
wait()
方法有以下常见的用法:
- 在同步代码块中使用
wait()
方法:
synchronized (sharedObject) {
try {
// 当前线程进入等待状态,释放对象的锁
sharedObject.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
// 当线程被唤醒后,继续执行
System.out.println("线程被唤醒");
}
在上面的示例中,我们在一个同步代码块中调用了 wait()
方法。当线程执行到 wait()
方法时,它会释放对象的锁并进入等待状态,直到其他线程调用相同对象上的 notify()
或 notifyAll()
方法来唤醒等待线程。
需要注意的是,在调用 wait()
方法前必须获得对象的锁,因此通常在同步代码块或同步方法中使用 wait()
方法。
- 使用
wait()
方法实现线程间的协作:
class MyTask implements Runnable {
private final Object lock;
public MyTask(Object lock) {
this.lock = lock;
}
public void run() {
synchronized (lock) {
try {
System.out.println("线程开始执行任务");
// 执行任务的一部分
// 等待其他线程完成特定条件
lock.wait();
// 线程被唤醒后继续执行任务的剩余部分
System.out.println("线程继续执行任务");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
// 创建一个共享的锁对象
Object lock = new Object();
// 创建一个新线程执行任务
Thread thread = new Thread(new MyTask(lock));
thread.start();
// 在适当的时机唤醒等待的线程
synchronized (lock) {
lock.notify();
}
在上面的示例中,我们创建了一个共享的锁对象,并在一个新线程的任务中使用 wait()
方法进行等待。主线程在适当的时机调用 notify()
方法来唤醒等待的线程。
需要注意的是,wait()
方法必须在同步块中使用,并且在调用 wait()
方法前必须获得对象的锁,否则会抛出 IllegalMonitorStateException
异常。
总结:
wait()
方法用于使当前线程进入等待状态,直到其他线程调用相同对象上的 notify()
或 notifyAll()
方法来唤醒等待线程。它常用于线程间的协作和同步。需要在同步块中使用 wait()
方法,并在调用 wait()
方法前获得对象的锁。同时,需要注意处理可能抛出的 InterruptedException
异常和使用适当的唤醒机制。