Java的Thread测试[包括sleep,wait的使用比较]

最新推荐文章于 2025-04-27 14:42:29 发布
原创 最新推荐文章于 2025-04-27 14:42:29 发布 · 189 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Java #Thread #sleep #wait

本文通过实例演示了Java中线程同步的两种方法：wait和notify。对比了这两种方法的区别，详细介绍了如何使用它们来控制多个线程间的交互，包括线程等待与唤醒的过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

package javaBese;

public class ThreadTest {

/*
* 共同点： 他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。

   不同点： Thread.sleep(long)可以不在synchronized的块下调用，而且使用Thread.sleep()不会丢失当前线程对任何对象的同步锁(monitor);
                object.wait(long)必须在synchronized的块下来使用，调用了之后失去对object的monitor, 这样做的好处是它不影响其它的线程对object进行操作。
   */

public void thread()
{
   System.out.println("I am here!");
  
   Thread thread = new Thread();
   Thread thread2 = new Thread();
   try {
   
    thread2.sleep(1000);
    System.out.println("sleep 1秒后,I am come back!");
   
    thread2.start();
    System.out.println("thread is start");
   
    thread2.stop();
    System.out.println("thread is stop");
   
    synchronized (thread)//如果使用wait,就必须synchronized来同步对象
    {
     System.out.println("");
     for (int i = 0; i < 5; i++) {
      thread.notify();//必须要放在synchronized方法的里面
      System.out.println("First,notify thread");
      thread.wait(1000);
      System.out.println("wait 1秒后,I am come back!");
     }
    }
   } catch (Exception e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
}

public static void main(String[] args) {
   ThreadTest threadTest = new ThreadTest();
   threadTest.thread();
}

}

/*
* 复杂应用
程序会启动20个线程，20个线程都使用同一个sync的object（名字为SYNC）。 线程启动代码如下：

Java代码
final TC[] ts = new TC[20];  
        for (int i = 0; i < ts.length; i++) {  
            TC target = new TC("TC " + i, SYNC1);  
            Thread thread = new Thread(target);  
            ts[i] = target;  
            thread.start();  
}

final TC[] ts = new TC[20];
        for (int i = 0; i < ts.length; i++) {
            TC target = new TC("TC " + i, SYNC1);
            Thread thread = new Thread(target);
            ts[i] = target;
            thread.start();
}
------------------------------------------------------------
接下来马上启动另外一个线程用于做notify操作。

Java代码
// 一个用于停止的Thread  
        new Thread(new Runnable() {  
            public void run() {  
                synchronized (SYNC1) {  
                    int i = 10;  
                    while (i > 0) {  
                        System.out.println("Now will notify the thread " + i);  
                        ts[i].notifySelf();  
                        try {  
                            SYNC1.wait(10000);  
                        } catch (InterruptedException e) {  
                            e.printStackTrace();  
                        }  
                        i--;  
                    }  
                }  
            }  
}).start();

// 一个用于停止的Thread
        new Thread(new Runnable() {
            public void run() {
                synchronized (SYNC1) {
                    int i = 10;
                    while (i > 0) {
                        System.out.println("Now will notify the thread " + i);
                        ts[i].notifySelf();
                        try {
                            SYNC1.wait(10000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        i--;
                    }
                }
            }
}).start();

------------------------------------------------------------

Java代码
启动的ＴＣ线程代码如下：  

class TC implements Runnable {  

    private final String name;  

    private final Object sync;  

    private boolean isRunning = false;  

    public TC(String name, Object sync) {  
        this.name = name;  
        this.sync = sync;  
    }  

    public void run() {  
        synchronized (sync) {  
            while (true) {  
                // 每个线程默认都加入线程池排队。这样有助于打乱线程在主线程中启动的顺序，方便后面的观测。  
                if (!isRunning) {  
                    try {  
                        sync.wait(1000);  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    }  
                    isRunning = true;  
                }  
                System.out.println(name + " Running .......");  
                try {  
                    sync.wait();  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }// Wait 1 second  
            }  
        }  
    }  

    public void notifySelf() {  
        synchronized (sync) {  
            System.out.println("Coming to notify the thread " + name);  
            sync.notify();  
        }  

    }  

}

启动的ＴＣ线程代码如下：

class TC implements Runnable {

    private final String name;

    private final Object sync;

    private boolean isRunning = false;

    public TC(String name, Object sync) {
        this.name = name;
        this.sync = sync;
    }

    public void run() {
        synchronized (sync) {
            while (true) {
                // 每个线程默认都加入线程池排队。这样有助于打乱线程在主线程中启动的顺序，方便后面的观测。
                if (!isRunning) {
                    try {
                        sync.wait(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    isRunning = true;
                }
                System.out.println(name + " Running .......");
                try {
                    sync.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }// Wait 1 second
            }
        }
    }

    public void notifySelf() {
        synchronized (sync) {
            System.out.println("Coming to notify the thread " + name);
            sync.notify();
        }

    }

}


---------------------------分割线---------------------------------

输出日志如下（//部分是我加的注释，不是实际输出）：

Now will notify the thread 10 //首先试着notify第10个TC
Coming to notify the thread TC 10 // 也确实调用了SYNC的notify操作，但是因为当前还没有任何线程在wait，所以这个notify信号就被丢弃掉了。这个notify过去就过去了。不会影响后面的任何操作了。
TC 1 Running .......
TC 5 Running .......
TC 0 Running .......
TC 2 Running .......
TC 4 Running .......
TC 6 Running .......
TC 8 Running .......
TC 10 Running .......
TC 12 Running .......
TC 14 Running .......
TC 7 Running .......
TC 9 Running .......
TC 11 Running .......
TC 13 Running .......
TC 15 Running .......
TC 17 Running .......
TC 3 Running .......
TC 18 Running .......
TC 16 Running .......
TC 19 Running ....... //启动20线程，这20个线程启动的顺序已经被打乱了。不会从头到尾1-20的启动，而是如log显示1,5,0,2,4,6,8,10,12,14.........
//每个线程启动后会被wait(). wait的顺序是1,5,0,2,4,6,8,10,12,14.........
Now will notify the thread 9
Coming to notify the thread TC 9
TC 1 Running .......
Now will notify the thread 8
Coming to notify the thread TC 8
TC 5 Running .......
Now will notify the thread 7
Coming to notify the thread TC 7
TC 0 Running .......
Now will notify the thread 6
Coming to notify the thread TC 6
TC 2 Running .......
Now will notify the thread 5
Coming to notify the thread TC 5
TC 4 Running .......
Now will notify the thread 4
Coming to notify the thread TC 4
TC 6 Running .......
Now will notify the thread 3
Coming to notify the thread TC 3
TC 8 Running .......
Now will notify the thread 2
Coming to notify the thread TC 2
TC 10 Running .......
Now will notify the thread 1
Coming to notify the thread TC 1
TC 12 Running .......
//总共10个notify操作，但是因为启动的时候一个notify因为没有任何wait的线程给丢弃了，所以，这里只有9个notify起到了作用。他们是按照进入pool的顺序排队给notify。
//一个notify操作仅仅激活一个wait队列中的第一个线程。一对一操作。

-------------------------------分割线------------------------------
使用notifyAll代替notify。

日志输出：

Now will notify the thread 10
Coming to notify the thread TC 10 //第一个notifyAll的操作还是被丢弃了
TC 0 Running .......
TC 1 Running .......
TC 3 Running .......
TC 5 Running .......
TC 7 Running .......
TC 9 Running .......
TC 11 Running .......
TC 13 Running .......
TC 15 Running .......
TC 17 Running .......
TC 19 Running .......
TC 2 Running .......
TC 4 Running .......
TC 6 Running .......
TC 8 Running .......
TC 10 Running .......
TC 12 Running .......
TC 14 Running .......
TC 16 Running .......
TC 18 Running .......
Now will notify the thread 9
Coming to notify the thread TC 9 //一个notifyAll的操作notify所以正在wait的线程。
TC 0 Running .......
TC 1 Running .......
TC 3 Running .......
TC 5 Running .......
TC 7 Running .......
TC 9 Running .......
TC 11 Running .......
TC 2 Running .......
TC 13 Running .......
TC 15 Running .......
TC 4 Running .......
TC 17 Running .......
TC 19 Running .......
TC 6 Running .......
TC 8 Running .......
TC 10 Running .......
TC 12 Running .......
TC 14 Running .......
TC 16 Running .......
TC 18 Running .......

* */

 

 

 

转自：http://hi.baidu.com/billgon/blog/item/503fb458997888cc9c820490.html

《知识点007：Java使用Thread的sleep(),wait()区别详解》
大大大钢琴
07-28 893
1. sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。在调用sleep()方法的过程中，线程不会释放对象锁。2. 调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备。
JAVA --- sleep 和 wait 的区别？
xycxycooo的博客
08-01 441
sleep方法：用于简单的定时任务，不会释放锁，时间到了自动唤醒。wait方法：用于线程间的同步和通信，会释放锁，需要其他线程调用notify或notifyAll来唤醒。
JAVA Test_Thread
07-29
Test_Thread
java 通过 Runnable 的接口 实现了 多线程
景山编程-顺道编程
03-22 331
package com.js; import java.awt.Container; import java.net.URL; import javax.swing.*; public class Java_4_Thread_Runnable extends JFrame {// 继承了 swing 类 private JLabel jl = new JLabel();// 声明 JLabe
Thread测试
weixin_34026484的博客
11-20 133
2019独角兽企业重金招聘Python工程师标准>>> ...
Java--测试Thread中的常用方法
yixin_oh的博客
06-20 347
Thread常用方法 注意一下这个方法sleep（millitime） 直接调用sleep方法会报错，因为本身抛了一个异常，我们需要处理。此处不能通过throws抛异常，因为必须在run（）方法下throws，但是run是重写的thread类的run（）方法，原方法并没有throws。 所以此方法只能try-catch 而不能使用throws ...
测试 Thread 状态
weixin_43719015的博客
05-11 279
@Slf4j(topic = "c.TestState") public class TestState { public static void main(String[] args) throws IOException { Thread t1 = new Thread("t1") { @Override public void run() { log.debug("running..."); .
详解Java中wait和sleep的区别
08-26
"详解Java中wait和sleep的区别" Java中wait和sleep的区别是Java多线程编程中一个重要的概念。这两个方法都可以用来暂停当前线程的执行，但是它们之间有着根本的区别。 首先，wait（）是一个用于线程同步的实例方法...
Java线程中sleep和wait的区别详细介绍
09-05
Java线程中的`sleep()`和`wait()`方法都是在多线程环境中用于控制线程执行的重要工具，但它们之间存在着显著的区别。理解这些差异对于编写高效、正确的并发代码至关重要。 首先，Java的多线程机制基于抢占式模型，...
Java sleep() 与 wait() 的深度对比
最新发布
记录学习的过程
04-27 1024
sleep()和wait()都是 Java 中用于线程控制的重要方法，但它们在行为特性和使用场景上有本质区别。
Java如何通过Thread创建多线程测试程序（不包括线程池）
天然玩家的博客
04-22 3617
- Java通过Thread创建线程可分为4类： （1）继承Thread，重写run方法； （2）在Thread中写方法，构建Runnable类型，通过`::`或者`()->`构建； （3）实现Runnable接口，重写run方法； （4）实现Callable接口，重写call方法。 - 前三类无法获取方法返回值，第四类可以获取方法返回值。 - 启动线程使用start方法，该方法执行时有两个线程工作，即调用start的当前线程和调用run方法的其他线程（new Thread创建的线程）。
Thread中的方法测试（run，yield，sleep，start，join等）
qq_57780419的博客
08-19 331
Thread中的方法测试
thread切换测试
oradbm的博客
06-14 589
1.     切换threadALTERDATABASEADDLOGFILETHREAD2GROUP4  'D:\APP\ADMINISTRATOR\ORADATA\ORCL\REDO04.LOG'SIZE100M;ALTERDATABASEADDLOGFILETHREAD2GROUP5  'D:\APP\ADMINISTRATOR\ORADATA\ORCL\REDO05.LOG'SIZE100M...
对于多线程的几个状态的自我理解
JavaParis的博客
10-18 187
多线程状态 新建状态 我们在刚刚new一个线程的时候，就会进入我们线程的新建状态 就绪状态 我们在调用线程的start方法之后，线程就会进入就绪的状态 阻塞状态 我们在调用线程的一些方法之后，线程会暂停，进入阻塞状态，下面列举一些主要让线程阻塞的方法 sleep:线程休眠，可以指定线程的休眠时间，就是让线程停止多少秒 wait:线程等待，字面意思，也就是让线程等待一段时间，知道线程执行了notify方法之后，线程才会重新进入可执行状态 yield:线程让步，让优先级更高的线程先执行，这里注意，调用yiel
测试 Thread 中的常用方法
LeungKiChen
08-19 136
测试 Thread 中的常用方法 package Java; /** * 测试 Thread 中的常用方法 * 1. start() 启动当前线程 ， 调用当前线程的 run() 方法 * 2. run() 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中 * 3. currentThread() 静态方法，返回执行当前代码的线程 * 4. getName() 获取当前线程的名字 * 5. setName() 设置当前线程的的名字 * 6. yield() .
Thread专题(11/14) - 测试并发程序
编程是一门实践技术
04-06 293
很多顺序程序的测试方法在并发程序中也适用，但需要更广泛的覆盖度和更长的运行时间。并发类的测试主要分为：安全性与活跃度的测试。活跃度测试包括： 吞吐量：在一个并发任务集中，已完成任务所占的比例。 响应性：从请求到完成一些动作之间的等待时间。 可伸缩性：增加更多的硬件或软件资源后，吞吐量是否会提高。
java wait 例子_【多线程】java多线程 测试例子 详解wait() sleep() notify() start() join()方法 等...
weixin_31444279的博客
03-07 174
java实现多线程，有两种方法：1》实现多线程，继承Thread，资源不能共享2》实现多线程 实现Runnable接口，可以实现资源共享*wait()方法 在哪个线程中调用 则当前线程处于等待状态【在main方法中调用A.wait()，则是main线程等待，而不是A线程等待】* join()方法 作用类似与wait()方法 理解：如上处调用join()方法* 【注意：在A线程中调用B.joi...
Thread.Sleep 是程序设计不佳的标志。
君子居易
07-13 1297
这是有缺陷的逻辑，因为应用程序仍然不能与Thread.Sleep 一起工作。这实际上只是解决了特定计算机上的问题。最初的问题可能是时间/同步问题，通过使用 Thread.Sleep 隐藏它来忽略它只会延迟问题并使其以随机、难以重现的方式发生。...
java 多线程模拟高访问量测试
special dream的博客
12-06 9965
本文模拟10个用户，持续访问Controller方法（适用SpringMVC框架项目，其他框架可借鉴）。 YourJunit为一个线程类，模拟每间隔随机秒数，有一个用户进行访问，到十个用户为止。也可修改for循环，模拟N个用户。 YourThreadTest为一个线程类，私有变量为Controller对象，通过while循环，间隔随机秒数调用Controller的方法，使不断地进行
Java线程状态探究：sleep()与wait()的差异性分析
在标题“ThreadStateProject”中提到的项目，看起来是一个测试项目，旨在深入探索和比较sleep()和wait()两种方法的区别，并演示了如何使用join()方法确保线程间的正确执行顺序。在实际应用中，合理地使用这些方法有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值