Java 线程 sleep wait 深入解析 Thread

最新推荐文章于 2024-10-27 15:49:02 发布

学习编程知识

最新推荐文章于 2024-10-27 15:49:02 发布

阅读量1.2k

点赞数 1

分类专栏： java 文章标签： java 线程对象 wait sleep

本文链接：https://blog.csdn.net/never_cxb/article/details/50385957

版权

java 专栏收录该内容

90 篇文章 0 订阅

订阅专栏

wait 和 sleep 区别

sleep 是 Thread 的方法，wait 是 Object 的方法
sleep 不会释放锁，wait 会释放锁
sleep 是休眠，wait 是挂起
wait 唤醒需要用 notify 或者 notifyAll
而 sleep 则是休眠一段时间自己就恢复
wait方法需要在synchronize块或者synchronize方法里调用，然而 sleep 不需要
如果需要线程停顿，使用 sleep；使用 wait 进行线程间的通信（ implement inter-thread communication use wait method）

wait的一半用法

private Object monitor = new Object();

public void methodA(){
    //需要获取 synchronize on the lock object
     synchronized (monitor) {
         //wait会释放当前的锁，把该线程加到the “wait list” associated with the lock object
         monitor.wait();
     }
}

需求

两个线程，一个线程输出偶数，一个线程输出奇数，要求两个线程交替，得到1，2，3，4，5，6，7… 的效果
下面的代码注意是一个是

obj1.wait();
obj1.notify();

另一个是

obj1.notify();
obj1.wait();

这样就是A线程 wait，然后B线程唤醒notify A，B 自己 wait，然后A notify唤醒 B。
这样两个线程交替唤醒。

package a;

public class EvenOddThreadTest {

    /**
     * @param args
     */
    static Object obj1 = new Object();
    static Object obj3 = new EvenOddThreadTest();

    public static void main(String[] args) throws InterruptedException {
        new Thread() {
            @Override
            public void run() {

                for (int i = 1; i < 21; i += 2) {
                    synchronized (obj1) {
                        try {
                            obj1.wait();
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        obj1.notify();
                        System.out.println(i + Thread.currentThread().getName());
                    }
                }
            }
        }.start();
        new Thread() {
            @Override
            public void run() {
                for (int i = 2; i < 21; i += 2) {
                    synchronized (obj1) {
                        obj1.notify();
                        try {
                            obj1.wait();
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        System.out.println(i + Thread.currentThread().getName());

                    }
                }
            }

        }.start();
    }
}

输出

1Thread-0
2Thread-1
3Thread-0
4Thread-1
5Thread-0
6Thread-1
7Thread-0
8Thread-1
9Thread-0
10Thread-1
11Thread-0
12Thread-1
13Thread-0
14Thread-1
15Thread-0
16Thread-1
17Thread-0
18Thread-1
19Thread-0
20Thread-1