首页 / JAVA / Java 中Thread的sleep、join方法解析

Java 中Thread的sleep、join方法解析

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java 中Thread的sleep、join方法解析，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含10728字，纯文字阅读大概需要16分钟。

内容图文

1.Thread中sleep方法作用是使当前线程等待，其他线程开始执行，如果有线程锁，sleep不会让出锁

没有加锁代码如下：

            public
            class
             SynchronizedSleepMethod {
    
            public
            static
            void
             main(String[] args) {
        MoneyMethod moneyMethod = new MoneyMethod();
        for (int i = 0; i < 10; i++) {
            Thread t = new Thread(new MyThread4(moneyMethod), "t1" + i);
            t.start();
        }
        for (int i = 0; i < 10; i++) {
            Thread t = new Thread(new MyThread5(moneyMethod), "t2" + i);
            t.start();
        }
    }

}

class MyThread4 implements Runnable {
    MoneyMethod moneyMethod;

    /**
     * 
     */public MyThread4(MoneyMethod moneyMethod) {
        // TODO Auto-generated constructor stubthis.moneyMethod = moneyMethod;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Runnable#run()
     */
    @Override
    publicvoid run() {
        try {
            Thread.sleep(1000);
            moneyMethod.addMoney();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block            e.printStackTrace();
        }
    }

}

class MyThread5 implements Runnable {
    MoneyMethod moneyMethod;

    /**
     * 
     */public MyThread5(MoneyMethod moneyMethod) {
        // TODO Auto-generated constructor stubthis.moneyMethod = moneyMethod;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Runnable#run()
     */
    @Override
    publicvoid run() {
        try {
            Thread.sleep(1000);
            moneyMethod.subMoney();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block            e.printStackTrace();
        }
//        System.out.println(moneyMethod.money);
        // TODO Auto-generated method stub
    }

}

class MoneyMethod {
    int money = 200;

    publicvoid addMoney() throws InterruptedException {
        System.out.println(Thread.currentThread().getName() + ":::run:::" + money);
        money++;
    }

    publicvoid subMoney() throws InterruptedException {

        System.out.println(Thread.currentThread().getName() + ":::run:::" + money);
        money--;
    }

}

结果如下：

t10:::run:::202
t12:::run:::202
t11:::run:::202
t13:::run:::203
t15:::run:::205
t14:::run:::204
t17:::run:::207
t19:::run:::209
t18:::run:::209
t16:::run:::207
t21:::run:::207
t24:::run:::205
t22:::run:::206
t20:::run:::206
t29:::run:::203
t28:::run:::203
t26:::run:::202
t27:::run:::201
t23:::run:::200
t25:::run:::199

加锁代码如下：

            public
            class
             SynchronizedSleepMethod {
    
            public
            static
            void
             main(String[] args) {
        MoneyMethod moneyMethod = new MoneyMethod();
        for (int i = 0; i < 10; i++) {
            Thread t = new Thread(new MyThread4(moneyMethod), "t1" + i);
            t.start();
        }
        for (int i = 0; i < 10; i++) {
            Thread t = new Thread(new MyThread5(moneyMethod), "t2" + i);
            t.start();
        }
    }

}

class MyThread4 implements Runnable {
    MoneyMethod moneyMethod;

    /**
     * 
     */public MyThread4(MoneyMethod moneyMethod) {
        // TODO Auto-generated constructor stubthis.moneyMethod = moneyMethod;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Runnable#run()
     */
    @Override
    publicvoid run() {
        try {
            Thread.sleep(1000);
            moneyMethod.addMoney();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block            e.printStackTrace();
        }
    }

}

class MyThread5 implements Runnable {
    MoneyMethod moneyMethod;

    /**
     * 
     */public MyThread5(MoneyMethod moneyMethod) {
        // TODO Auto-generated constructor stubthis.moneyMethod = moneyMethod;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Runnable#run()
     */
    @Override
    publicvoid run() {
        try {
            Thread.sleep(1000);
            moneyMethod.subMoney();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block            e.printStackTrace();
        }
//        System.out.println(moneyMethod.money);
        // TODO Auto-generated method stub
    }

}

class MoneyMethod {
    int money = 200;

    publicsynchronizedvoid addMoney() throws InterruptedException {
        money++;
        System.out.println(Thread.currentThread().getName() + ":::run:::" + money);
    }

    publicsynchronizedvoid subMoney() throws InterruptedException {
        money--;
        System.out.println(Thread.currentThread().getName() + ":::run:::" + money);
    }

}

结果如下：

t10:::run:::201
t18:::run:::202
t17:::run:::203
t12:::run:::204
t13:::run:::205
t14:::run:::206
t15:::run:::207
t16:::run:::208
t11:::run:::209
t19:::run:::210
t22:::run:::209
t21:::run:::208
t20:::run:::207
t25:::run:::206
t24:::run:::205
t23:::run:::204
t26:::run:::203
t27:::run:::202
t29:::run:::201
t28:::run:::200

2.Thread中join()方法阻塞调用此方法的线程(calling thread)，直到线程t完成，此线程再继续；

没有join()方法代码如下：

            public
            class
             JoinMethod {
    
            public
            static
            void main(String[] args) throws InterruptedException {
        MoneyMethod2 moneyMethod = new MoneyMethod2();
        for (int i = 0; i < 5; i++) {
            Thread t = new Thread(new MyThread4(moneyMethod), "t1" + i);
            t.start();
//            t.join(300);
            System.out.println(Thread.currentThread().getName() + ":::run:::1"+i);
        }
        
        for (int i = 0; i < 5; i++) {
            Thread t = new Thread(new MyThread5(moneyMethod), "t2" + i);
            t.start();
//            t.join(300);
            System.out.println(Thread.currentThread().getName() + ":::run:::2"+i);
        }
        System.out.println(Thread.currentThread().getName() + ":::finish:::");
    }
}

class MyThread4 implements Runnable {
    MoneyMethod2 moneyMethod;

    /**
     * 
     */public MyThread4(MoneyMethod2 moneyMethod) {
        // TODO Auto-generated constructor stubthis.moneyMethod = moneyMethod;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Runnable#run()
     */
    @Override
    publicvoid run() {
        try {
            Thread.sleep(2000);
            moneyMethod.addMoney();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block            e.printStackTrace();
        }
    }

}

class MyThread5 implements Runnable {
    MoneyMethod2 moneyMethod;

    /**
     * 
     */public MyThread5(MoneyMethod2 moneyMethod) {
        // TODO Auto-generated constructor stubthis.moneyMethod = moneyMethod;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Runnable#run()
     */
    @Override
    publicvoid run() {
        try {
            Thread.sleep(2000);
            moneyMethod.subMoney();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block            e.printStackTrace();
        }
//        System.out.println(moneyMethod.money);
        // TODO Auto-generated method stub
    }

}

class MoneyMethod2 {
    int money = 200;

    publicvoid addMoney() throws InterruptedException {
        money++;
        System.out.println(Thread.currentThread().getName() + ":::add:::" + money);
    }

    publicvoid subMoney() throws InterruptedException {
        money--;
        System.out.println(Thread.currentThread().getName() + ":::sub:::" + money);
    }

}

结果：主线程会提前走掉，然后子线程执行

main:::run:::10
main:::run:::11
main:::run:::12
main:::run:::13
main:::run:::14
main:::run:::20
main:::run:::21
main:::run:::22
main:::run:::23
main:::run:::24
main:::finish:::
t10:::add:::201
t12:::add:::202
t11:::add:::203
t13:::add:::204
t14:::add:::205
t21:::sub:::203
t20:::sub:::203
t24:::sub:::201
t22:::sub:::200
t23:::sub:::201

添加了join后，join的等待时间>线程执行时间，代码如下：

            public
            class
             JoinMethod {
    
            public
            static
            void main(String[] args) throws InterruptedException {
        MoneyMethod2 moneyMethod = new MoneyMethod2();
        for (int i = 0; i < 5; i++) {
            Thread t = new Thread(new MyThread4(moneyMethod), "t1" + i);
            t.start();
            t.join(3000);
            System.out.println(Thread.currentThread().getName() + ":::run:::1"+i);
        }
        
        for (int i = 0; i < 5; i++) {
            Thread t = new Thread(new MyThread5(moneyMethod), "t2" + i);
            t.start();
            t.join(3000);
            System.out.println(Thread.currentThread().getName() + ":::run:::2"+i);
        }
        System.out.println(Thread.currentThread().getName() + ":::finish:::");
    }
}

class MyThread4 implements Runnable {
    MoneyMethod2 moneyMethod;

    /**
     * 
     */public MyThread4(MoneyMethod2 moneyMethod) {
        // TODO Auto-generated constructor stubthis.moneyMethod = moneyMethod;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Runnable#run()
     */
    @Override
    publicvoid run() {
        try {
            Thread.sleep(2000);
            moneyMethod.addMoney();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block            e.printStackTrace();
        }
    }

}

class MyThread5 implements Runnable {
    MoneyMethod2 moneyMethod;

    /**
     * 
     */public MyThread5(MoneyMethod2 moneyMethod) {
        // TODO Auto-generated constructor stubthis.moneyMethod = moneyMethod;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Runnable#run()
     */
    @Override
    publicvoid run() {
        try {
            Thread.sleep(2000);
            moneyMethod.subMoney();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block            e.printStackTrace();
        }
//        System.out.println(moneyMethod.money);
        // TODO Auto-generated method stub
    }

}

class MoneyMethod2 {
    int money = 200;

    publicvoid addMoney() throws InterruptedException {
        money++;
        System.out.println(Thread.currentThread().getName() + ":::add:::" + money);
    }

    publicvoid subMoney() throws InterruptedException {
        money--;
        System.out.println(Thread.currentThread().getName() + ":::sub:::" + money);
    }

}

结果如下：

t10:::add:::201
main:::run:::10
t11:::add:::202
main:::run:::11
t12:::add:::203
main:::run:::12
t13:::add:::204
main:::run:::13
t14:::add:::205
main:::run:::14
t20:::sub:::204
main:::run:::20
t21:::sub:::203
main:::run:::21
t22:::sub:::202
main:::run:::22
t23:::sub:::201
main:::run:::23
t24:::sub:::200
main:::run:::24
main:::finish:::

加入join方法后，线程执行时间>join的等待时间时，代码如下：

            public
            class
             JoinMethod {
    
            public
            static
            void main(String[] args) throws InterruptedException {
        MoneyMethod2 moneyMethod = new MoneyMethod2();
        for (int i = 0; i < 5; i++) {
            Thread t = new Thread(new MyThread4(moneyMethod), "t1" + i);
            t.start();
            t.join(300);
            System.out.println(Thread.currentThread().getName() + ":::run:::1"+i);
        }
        
        for (int i = 0; i < 5; i++) {
            Thread t = new Thread(new MyThread5(moneyMethod), "t2" + i);
            t.start();
            t.join(300);
            System.out.println(Thread.currentThread().getName() + ":::run:::2"+i);
        }
        System.out.println(Thread.currentThread().getName() + ":::finish:::");
    }
}

class MyThread4 implements Runnable {
    MoneyMethod2 moneyMethod;

    /**
     * 
     */public MyThread4(MoneyMethod2 moneyMethod) {
        // TODO Auto-generated constructor stubthis.moneyMethod = moneyMethod;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Runnable#run()
     */
    @Override
    publicvoid run() {
        try {
            Thread.sleep(2000);
            moneyMethod.addMoney();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block            e.printStackTrace();
        }
    }

}

class MyThread5 implements Runnable {
    MoneyMethod2 moneyMethod;

    /**
     * 
     */public MyThread5(MoneyMethod2 moneyMethod) {
        // TODO Auto-generated constructor stubthis.moneyMethod = moneyMethod;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Runnable#run()
     */
    @Override
    publicvoid run() {
        try {
            Thread.sleep(2000);
            moneyMethod.subMoney();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block            e.printStackTrace();
        }
//        System.out.println(moneyMethod.money);
        // TODO Auto-generated method stub
    }

}

class MoneyMethod2 {
    int money = 200;

    publicvoid addMoney() throws InterruptedException {
        money++;
        System.out.println(Thread.currentThread().getName() + ":::add:::" + money);
    }

    publicvoid subMoney() throws InterruptedException {
        money--;
        System.out.println(Thread.currentThread().getName() + ":::sub:::" + money);
    }

}

结果如下：

main:::run:::10
main:::run:::11
main:::run:::12
main:::run:::13
main:::run:::14
main:::run:::20
t10:::add:::201
main:::run:::21
t11:::add:::202
main:::run:::22
t12:::add:::203
main:::run:::23
t13:::add:::204
main:::run:::24
main:::finish:::
t14:::add:::205
t20:::sub:::204
t21:::sub:::203
t22:::sub:::202
t23:::sub:::201
t24:::sub:::200

在以上代码中可以发现，在加入join()方法后主线程还是会提前走，但是所有子线程会按照执行顺序执行

原文：https://www.cnblogs.com/vstarcui/p/9841769.html

内容总结

以上是互联网集市为您收集整理的Java 中Thread的sleep、join方法解析全部内容，希望文章能够帮你解决Java 中Thread的sleep、join方法解析所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1094789.html

来源：【匿名】

【上一篇】Java多线程文件复制功能【下一篇】JAVA/JSP学习系列之五

更多 ►

【Java 中Thread的sleep、join方法解析】教程文章相关的互联网学习教程文章

java 多线程，sleep()和wait()

java 线程可谓是java中重要的一个机制，在说线程之前需要知道什么是进程，进程和线程的关系是是什麽？1.什么是进程？什么是线程？　　进程：用句简单的粗俗的来说，进程就是程序。进程是一个正在运行的程序！比如：打开一个记事本程序，那么这个正在运行的记事本程序就是一个进程。　　线程：线程是由进程所创建来执行某个功能的一个机制。那么也就是说，没有进程就没有线程。一个线程只能对应一个进程，一个进程却可以有多个线程的...

【转载】java sleep和wait的区别的疑惑?

首先，要记住这个差别，“sleep是Thread类的方法,wait是Object类中定义的方法”。尽管这两个方法都会影响线程的执行行为，但是本质上是有区别的。 Thread.sleep不会导致锁行为的改变，如果当前线程是拥有锁的，那么Thread.sleep不会让线程释放锁。如果能够帮助你记忆的话，可以简单认为和锁相关的方法都定义在Object类中，因此调用Thread.sleep是不会影响锁的相关行为。 Thread.sleep和Object.wait都会暂停当前的线程，对于CPU资...

【转】Java 并发编程：线程间的协作(wait/notify/sleep/yield/join)【代码】【图】

Java中线程中状态可分为五种：New（新建状态），Runnable（就绪状态），Running（运行状态），Blocked（阻塞状态），Dead（死亡状态）。　　New：新建状态，当线程创建完成时为新建状态，即new Thread(...)，还没有调用start方法时，线程处于新建状态。　　Runnable：就绪状态，当调用线程的的start方法后，线程进入就绪状态，等待CPU资源。处于就绪状态的线程由Java运行时系统的线程调度程序(thread scheduler)来调度。　　Runnin...

Java 中Thread的sleep、join方法解析【代码】

1.Thread中sleep方法作用是使当前线程等待，其他线程开始执行，如果有线程锁，sleep不会让出锁没有加锁代码如下：publicclass SynchronizedSleepMethod {publicstaticvoid main(String[] args) {MoneyMethod moneyMethod = new MoneyMethod();for (int i = 0; i < 10; i++) {Thread t = new Thread(new MyThread4(moneyMethod), "t1" + i);t.start();}for (int i = 0; i < 10; i++) {Thread t = new Thread(new MyThread5(moneyMet...

java 线程sleep方法

public static void main(String[] args) { Runner1 r1 = new Runner1(); Thread t = new Thread(r1); t.start(); try { Thread.sleep(10000); } catch (InterruptedException e) { } t.interrupt(); System.out.println("子线程结束"); } class Runner1 implements Runnable{ boolean flag = true; @Override public void run() { while(flag){ System.out.println("---"+new Date()+"---"); try { Thread.s...

Java 多线程(sleep)

java尽量不要用junit对多线程或sleep做测试【代码】

junit对多线程测试和sleep的支持不太好，碰到这些情况的测试时，尽量避免使用junit，最好直接使用一个main函数来测试。因为junit执行的程序必须是激活状态的。而sleep是睡眠状态，一旦没有其他激活状态的线程，junit程序就会自动退出。如下： import org.junit.Test;import java.util.concurrent.SynchronousQueue; import java.util.concurrent.TimeUnit;public class Test14BlockingQueue {/*** 输出如下：* start to sleep* 1...

Java多线程基础六——sleep()方法的理解，执行顺序的两种不同情况案例(run 和 start 对sleep的不同反映)【代码】【图】

方法简单解释 sleep()方法的作用就是在指定的毫秒数内让当前“正在执行”的线程进入休眠状态，在这里这个“正在执行”的线程指的是this.currentThread()返回的线程下面照例通过一些例子进行方法解释：在下面的测试运行结果重点看他们的输出的顺序 package MyThread; public class mythread extends Thread{@Overridepublic void run() {try {System.out.println("run threadName="+this.currentThread().getName()+"开始");Thread...

java中wait和sleep的区别

下面补充wait() 和 sleep() 的区别：1，wait() 执行后，释放执行权，也释放锁，与它同步的线程或者其它的线程都可以拿到执行权。2，sleep() 执行后，释放执行权，但不释放锁，即与它不拥有同一个锁的线程可以拿到执行权，但与它同步的线程不可以拿到执行权。

java sleep和wait的区别的疑惑?【代码】

问题：sleep方法没有释放锁:不让出资源　　wait方法释放了锁：使得其他线程可以使用同步控制块或者方法　　sleep不释放锁线程是进入阻塞状态还是就绪状态？　　sleep是不是还占着CPU，是互斥还是同步？作者：大宽宽链接：https://www.zhihu.com/question/23328075/answer/665978836来源：知乎　　首先说，虽然大家用Java Thread的api，但实际上Thread是OS提供的抽象和功能。这么理解会让整个问题更清楚。千万不要从类啊，静态方...

Java中wait和sleep方法的区别【代码】

1、两者的区别这两个方法来自不同的类分别是Thread和Object 最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法(锁代码块和方法锁)。 wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用(使用范围) sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常 sleep方法属于Thread类中方法，表示让一个线程进入睡眠状态，等待一定的时...

java-检测用户何时完成写入-循环中调用Thread.sleep()【代码】

我想建立一个搜索,以在用户完成书写后向您显示结果. 如果必须在本地数据库中进行搜索,则每次用户释放密钥时都会触发搜索. 就我而言,我必须将Web请求发送到公开搜索功能的API点.该服务器每分钟仅允许来自单个IP的20个请求. 因此,我编写了一个线程来检测用户何时真正完成编写： >(虽然为真)>保存搜索框文字>等待400毫秒>检查搜索框文本是否与之前保存的文本相同码：private void checkIfUserFinishedWritingFunction() {while(true)...

java-有什么好的示例程序演示Thread.sleep()抛出的InterruptedException处理不当？【代码】

我一直在阅读有关InterruptedException的内容,并且很明显,没有在所有情况下都能正确处理它的灵丹妙药. 我还没有看到的是一些示例代码,演示了如果异常处理不当会导致什么错误.当然,我意识到有些效果(例如线程饥饿,我认为是其中之一)很难证明.我想将其限制为演示Thread.sleep()的正确使用. 您将如何为此设计一个比较实际的示例程序？到目前为止,这是我的想法： >创建一个简单的GUI应用程序以演示响应速度的降低.有一个UI线程和一个简...

android-RxJava Thread.sleep在另一个线程【代码】

如何在Android中每隔一秒钟使用RxJava更新UI？我正在尝试做这样的事情：for (int i = 0; i <10 ; i++) { //testrx.Observable.just(getSleep()).subscribeOn(Schedulers.newThread()).observeOn(AndroidSchedulers.mainThread()).subscribe(v->updateTime());//update textView}private <T> int getSleep() {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}return 0;}但是Thread.sleep()在ui线程...

android-避免使用RxJava的Thread.sleep【代码】

我将observable应用于此方法,但是在调用此方法后,它表示主线程上的工作过多.任何帮助表示赞赏fun isBatteryHealthGood(): Observable<Boolean> {var count = 0intent = context.registerReceiver(broadCastReceiver, IntentFilter(Intent.ACTION_BATTERY_CHANGED))while (batteryStatus == null && count < maxCount) {Thread.sleep(1000)count++}return Observable.just(batteryStatus == BatteryManager.BATTERY_HEALTH_GOOD) }解...

首页 / JAVA / Java 中Thread的sleep、join方法解析

Java 中Thread的sleep、join方法解析

内容导读

内容图文

内容总结

内容备注

内容手机端

【Java 中Thread的sleep、join方法解析】教程文章相关的互联网学习教程文章

SLEEP - 相关标签

解析 - 相关标签

方法 - 相关标签

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程