《java多线程编程核心技术》第一章 Java多线程技能

短命女 2023-06-20 06:09 69阅读 0赞

1 currentThread()方法

currentThread()方法可返回代码段正在被哪个线程调用的信息。
案例1:

  1. package com.wuk.demo01;
  2. public class MyThread extends Thread{
  3. public MyThread(){
  4. //main
  5. System.out.println("MyThread----"+Thread.currentThread().getName());
  6. }
  7. @Override
  8. public void run() {
  9. //A
  10. System.out.println("run-----"+Thread.currentThread().getName());
  11. }
  12. }
  13. package com.wuk.demo01;
  14. public class MainTest {
  15. public static void main(String[] args) {
  16. MyThread myThread = new MyThread();
  17. myThread.setName("A");
  18. myThread.start();
  19. // myThread.run();
  20. }
  21. }

结果:

  1. MyThread----main
  2. run-----A

结论:
因为构造方法是被main线程调用的,而run()是被A线程调用的。

案例2:

  1. package com.wuk.demo02;
  2. public class CountOperate extends Thread{
  3. public CountOperate(){
  4. System.out.println("CountOperate----开始");
  5. //thread-0
  6. System.out.println("CountOperate----this----"+this.getName());
  7. //main
  8. System.out.println("CountOperate----currentThread----"+Thread.currentThread().getName());
  9. System.out.println("CountOperate----结束");
  10. }
  11. @Override
  12. public void run() {
  13. System.out.println("run----开始");
  14. //Thread-0
  15. System.out.println("run----this----"+this.getName());
  16. //A
  17. System.out.println("run----currentThread----"+Thread.currentThread().getName());
  18. System.out.println("run----结束");
  19. }
  20. }
  21. package com.wuk.demo02;
  22. public class MainTest02 {
  23. public static void main(String[] args) {
  24. CountOperate countOperate = new CountOperate();
  25. Thread t1 = new Thread(countOperate);
  26. t1.setName("A");
  27. t1.start();
  28. }
  29. }

结果:

  1. CountOperate----开始
  2. CountOperate----this----Thread-0
  3. CountOperate----currentThread----main
  4. CountOperate----结束
  5. run----开始
  6. run----this----Thread-0
  7. run----currentThread----A
  8. run----结束

结论:
this:表示的就是当前所在的类的对象。
Thread.currentThread():表示的就是当前代码正在被哪个线程执行的信息。

2 isAlive()

判断当前线程是否处于活动状态。
活动状态是指线程已经启动尚未终止,当线程处于正在运行或者准备运行的状态,就认为线程是存活的。

案例:

  1. package com.wuk.demo04;
  2. public class CountOperate04 extends Thread{
  3. public CountOperate04(){
  4. System.out.println("CountOperate----开始");
  5. System.out.println("CountOperate----this--name--"+this.getName());
  6. System.out.println("CountOperate----this--isAlive--"+this.isAlive());
  7. System.out.println("CountOperate----结束");
  8. }
  9. @Override
  10. public void run() {
  11. System.out.println("run----开始");
  12. System.out.println("run---currentThread--Thread--name--"+Thread.currentThread().getName());
  13. System.out.println("run----currentThread--Thread--isAlive--"+Thread.currentThread().isAlive());
  14. System.out.println("run----currentThread--this--name--"+this.getName());
  15. System.out.println("run----currentThread--this--isAlive--"+this.isAlive());
  16. System.out.println("run----结束");
  17. }
  18. }
  19. package com.wuk.demo04;
  20. public class MainTest04 {
  21. public static void main(String[] args) throws InterruptedException {
  22. CountOperate04 countOperate04 = new CountOperate04();
  23. Thread thread = new Thread(countOperate04);
  24. System.out.println("main---begin--"+thread.isAlive());
  25. thread.setName("A");
  26. thread.start();
  27. System.out.println("main---end--"+thread.isAlive());
  28. Thread.sleep(1000);
  29. System.out.println("main--sleeped-end--"+thread.isAlive());
  30. }
  31. }
  32. CountOperate----开始
  33. CountOperate----this--name--Thread-0
  34. CountOperate----this--isAlive--false
  35. CountOperate----结束
  36. main---begin--false
  37. main---end--true
  38. run----开始
  39. run---currentThread--Thread--name--A
  40. run----currentThread--Thread--isAlive--true
  41. run----currentThread--this--name--Thread-0
  42. run----currentThread--this--isAlive--false
  43. run----结束
  44. main--sleeped-end--false

3 sleep()方法

作用是在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)。

4 getId()方法

作用是获取线程的唯一标识。

5 停止线程

5.1 停止不了的线程

interrupt()并不会真正停止线程。
interrupted() 测试当前线程是否已经中断,执行后会将状态标志清除为false。
isInterrupted() 测试线程Thread对象是否已经是中断状态,不清除状态。

5.2能停止的线程-异常法

  1. package com.wuk.demo05;
  2. public class MyThread05 extends Thread {
  3. @Override
  4. public void run() {
  5. try {
  6. for (int i = 0; i <5000; i++) {
  7. if(this.interrupted()){
  8. System.out.println("线程已经停止"+i);
  9. throw new InterruptedException();
  10. }
  11. System.out.println("i="+i);
  12. }
  13. System.out.println("for循环下面的代码");
  14. }catch (InterruptedException ex){
  15. ex.printStackTrace();
  16. }
  17. }
  18. }
  19. package com.wuk.demo05;
  20. public class MainTest05 {
  21. public static void main(String[] args) throws InterruptedException {
  22. MyThread05 t1 = new MyThread05();
  23. t1.start();
  24. Thread.sleep(50);
  25. t1.interrupt();
  26. System.out.println("是否停止1=" + t1.interrupted());
  27. System.out.println("是否停止2=" + t1.interrupted());
  28. System.out.println("end");
  29. }
  30. }

在这里插入图片描述

5.3 在沉睡中停止

  1. package com.wuk.demo05;
  2. public class MyThread05 extends Thread {
  3. @Override
  4. public void run() {
  5. try {
  6. System.out.println("begin-------");
  7. Thread.sleep(5000);
  8. System.out.println("end--------");
  9. }catch (InterruptedException ex){
  10. System.out.println("在线程沉睡中终止他"+this.isInterrupted());
  11. ex.printStackTrace();
  12. }
  13. }
  14. }
  15. package com.wuk.demo05;
  16. public class MainTest05 {
  17. public static void main(String[] args) throws InterruptedException {
  18. MyThread05 t1 = new MyThread05();
  19. t1.start();
  20. Thread.sleep(50);
  21. t1.interrupt();
  22. }
  23. }

在这里插入图片描述结论:
在线程sleep时候停止它,会直接进入catch语句,并且清除停止状态值。

5.4 能停止的线程-return

  1. package com.wuk.demo05;
  2. public class MyThread05 extends Thread {
  3. @Override
  4. public void run() {
  5. for (int i = 0; i <5000; i++) {
  6. if(this.isInterrupted()){
  7. System.out.println("线程已经停止"+i);
  8. return;
  9. }
  10. System.out.println("i="+i);
  11. }
  12. System.out.println("for循环下面的代码");
  13. }
  14. }
  15. package com.wuk.demo05;
  16. public class MainTest05 {
  17. public static void main(String[] args) throws InterruptedException {
  18. MyThread05 t1 = new MyThread05();
  19. t1.start();
  20. Thread.sleep(50);
  21. t1.interrupt();
  22. System.out.println("是否停止1=" + t1.interrupted());
  23. System.out.println("是否停止2=" + t1.interrupted());
  24. System.out.println("end");
  25. }
  26. }

在这里插入图片描述

6 暂停线程

用suspend()暂停线程,用resume()恢复线程。
缺点:
1 会造成公共的同步对象的独占,使得其他线程无法对公共对象的访问。

2 会因为线程的暂停而导致数据不同步。

7 yield()方法

作用是放弃当前cpu资源,让其他线程占用,但是放弃时间不确定,有可能刚放弃马上又获取到。

8 线程的优先级

优先级高的会获取较多的CPU资源。
设置线程优先级的方法是:setPriority()。
线程优先级等级为1-10。

8.1 线程优先级的继承性

线程的优先级具有继承性,比如A线程启动B线程,则B线程的优先级与A是一样的。

8.2 优先级具有规则性

高优先级的线程总是大部分优先执行完,但是不代表高优先级的全部被执行完。
同时与线程的调用顺序无关。

8.3 优先级具有随机性

也就是说优先级高的不一定每次都是优先执行。

9 守护线程

守护线程的设置:setDaemon(true)。

  1. package com.wuk.demo05;
  2. public class MyThread05 extends Thread {
  3. @Override
  4. public void run() {
  5. for (int i = 0; i <5000; i++) {
  6. try {
  7. Thread.sleep(1);
  8. } catch (InterruptedException e) {
  9. e.printStackTrace();
  10. }
  11. System.out.println("i="+i);
  12. }
  13. }
  14. }
  15. package com.wuk.demo05;
  16. public class MainTest05 {
  17. public static void main(String[] args) throws InterruptedException {
  18. MyThread05 t1 = new MyThread05();
  19. //设置t1为main的守护线程
  20. t1.setDaemon(true);
  21. t1.start();
  22. Thread.sleep(1000);
  23. System.out.println("main停止");
  24. }
  25. }

在这里插入图片描述

发表评论

表情:
评论列表 (有 0 条评论,69人围观)

还没有评论,来说两句吧...

相关阅读