经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » Java相关 » Java » 查看文章
Java 多线程(三)—— 线程的生命周期及方法
来源:cnblogs  作者:chen_hao  时间:2018/11/3 13:54:30  对本文有异议

 

线程的方法

1、sleep(long millis)

线程休眠:让执行的线程暂停一段时间,进入计时等待状态。

        static void sleep(long millis):调用此方法后,当前线程放弃 CPU 资源,在指定的时间内,sleep 所在的线程不会获得可运行的机会,此状态下的线程不会释放同步锁。

      该方法更多的是用来模拟网络延迟,让多线程并发访问同一资源时的错误效果更加明显。

2、wait()

线程等待:一旦一个线程执行到wait(),就释放当前的锁。

    注意:此方法必须在同步代码块或同步方法中

3、notify()/notifyAll()

唤醒:唤醒wait的一个或所有的线程

      注意:此方法需和wait()成对使用,必须在同步代码块或同步方法中

注意sleep()和 wait() 的区别,sleep指定时间内当前线程放弃 CPU 资源,线程不会释放同步锁,wait 会放弃 CPU 资源,同时也会放弃 同步锁

4、join()

联合线程:表示这个线程等待另一个线程完成后(死亡)才执行,join 方法被调用之后,线程对象处于阻塞状态。写在哪个线程中,哪个线程阻塞

    这种也称为联合线程,就是说把当前线程和当前线程所在的线程联合成一个线程

5、yield()

礼让线程:表示当前线程对象提示调度器自己愿意让出 CPU 资源。

     调用该方法后,线程对象进入就绪状态,所以完全有可能:某个线程调用了 yield() 方法,但是线程调度器又把它调度出来重新执行。

sleep() 和 yield() 方法的区别:

  ①、都能使当前处于运行状态的线程放弃 CPU资源,把运行的机会给其他线程

  ②、sleep 方法会给其他线程运行的机会,但是不考虑其他线程优先级的问题;yield 方法会优先给更高优先级的线程运行机会

  ③、调用 sleep 方法后,线程进入计时等待状态,调用 yield 方法后,线程进入就绪状态。

 

join示例:

  1. public class TestThread1 {
  2. public static void main(String [] args){
  3. SubThread1 subThread1=new SubThread1();
  4. subThread1.start();
  5. for (int i=0;i<=100;i++){
  6. System.out.println(Thread.currentThread().getName()+":"+i);
  7. if(i==20){
  8. try {
  9. subThread1.join();
  10. } catch (InterruptedException e) {
  11. e.printStackTrace();
  12. }
  13. }
  14. }
  15. }
  16. }
  17. class SubThread1 extends Thread{
  18. @Override
  19. public void run(){
  20. for (int i=0;i<=100;i++){
  21. try {
  22. Thread.currentThread().sleep(100);
  23. } catch (InterruptedException e) {
  24. e.printStackTrace();
  25. }
  26. System.out.println(Thread.currentThread().getName()+":"+i);
  27. }
  28. }
  29. }

运行结果:

  1. main:0
  2. main:1
  3. main:2
  4. main:3
  5. main:4
  6. main:5
  7. main:6
  8. main:7
  9. main:8
  10. main:9
  11. main:10
  12. Thread-0:0
  13. Thread-0:1
  14. Thread-0:2
  15. Thread-0:3
  16. Thread-0:4
  17. Thread-0:5
  18. Thread-0:6
  19. Thread-0:7
  20. Thread-0:8
  21. Thread-0:9
  22. Thread-0:10
  23. .
  24. .
  25. .
  26. Thread-0:99
  27. Thread-0:100
  28. main:11
  29. main:12
  30. main:13
  31. main:14
  32. main:15
  33. .
  34. .
  35. main:98
  36. main:99
  37. main:100

运行结果分析:在main线程中调用线程A的join()方法,此时main线程停止执行,直至A线程执行完毕,main线程再接着join()之后的代码执行

 

 线程的通信

  1. /**
  2. * @author: ChenHao
  3. * @Description:使用两个线程打印1-100,线程1,线程2交替打印
  4. * 线程通信:如下的三个关键字使用的话,都得在同步代码块或同步方法中。
  5. * wait():一旦一个线程执行到wait(),就释放当前的锁。
  6. * notify()/notifyAll():唤醒wait的一个或所有的线程
  7. * 如果不使用break,程序将不会停止
  8. * @Date: Created in 10:50 2018/10/29
  9. */
  10. public class TestPrintNum {
  11. public static void main(String [] args){
  12. PrintNum printNum=new PrintNum();
  13. Thread thread1=new Thread(printNum);
  14. Thread thread2=new Thread(printNum);
  15. thread1.start();
  16. thread2.start();
  17. }
  18. }
  19. class PrintNum implements Runnable{
  20. int num=1;
  21. @Override
  22. public void run(){
  23. while (true){
  24. synchronized (this){
  25. notify();
  26. if(num<=100){
  27. try {
  28. Thread.sleep(100);
  29. } catch (InterruptedException e) {
  30. e.printStackTrace();
  31. }
  32. System.out.println(Thread.currentThread().getName()+":"+num++);
  33. }else {
  34. break;
  35. }
  36. try {
  37. wait();
  38. } catch (InterruptedException e) {
  39. e.printStackTrace();
  40. }
  41. }
  42. }
  43. }
  44. }

运行结果:

  1. Thread-0:1
  2. Thread-1:2
  3. Thread-0:3
  4. Thread-1:4
  5. Thread-0:5
  6. Thread-1:6
  7. Thread-0:7
  8. Thread-1:8
  9. Thread-0:9
  10. Thread-1:10
  11. .
  12. .
  13. .

运行结果分析:当第一个线程获取锁之后,打印后wait,释放锁;第二个线程获取锁,并唤醒第一个线程,打印后wait;交替打印

 

 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号