• 33.线程中常用的方法【20220811】

    线程中常用的方法

    1.static Thread currentThread()得到当前正在运行的线程对象
    2.void start() 启动线程
    3.String getName()返回该线程的名称。
            1.当没有设置线程名称的时候，系统会赋予线程一个默认的名称“Thread-0,Thread-1......”
            2.主线程【主方法的执行线程】的名称默认是“main”
    4.void    setName(String name)设置线程名称

    1. package com.wangxing.test;
    2. public class MyThread implements Runnable{
    3. 	@Override
    4. 	public void run() {
    5. 	  for(int i=1;i<=100;i++){
    6. 		  //1.static Thread currentThread()得到当前正在运行的线程对象
    7. 		  Thread  dangqianThread=Thread.currentThread();
    8. 		  //3.String getName()返回该线程的名称。
    9. 		  String  threadname=dangqianThread.getName();
    10. 		  System.out.println(threadname+"===="+i);
    11. 	  }
    12. 	}
    13. }
    14.  
    15. package com.wangxing.test;
    16. public class TestMain {
    17. 	public static void main(String[] args) {
    18. 		//得到主线程的名称
    19. 		//1.static Thread currentThread()得到当前正在运行的线程对象
    20. 		//Thread mainth=Thread.currentThread();
    21. 		//String name=mainth.getName();
    22. 		//System.out.println("主线程的线程名称=="+name);
    23. 	
    24. 		//创建目标对象
    25. 		MyThread  mt=new MyThread();
    26. 		//创建线程对象
    27. 		//1.通过Thread类的构造方法设置线程名称
    28. 		//Thread th1=new Thread(mt,"线程1");
    29. 		//Thread th2=new Thread(mt,"线程2");
    30. 		Thread th1=new Thread(mt);
    31. 		Thread th2=new Thread(mt);
    32. 		//2.void	setName(String name)设置线程名称
    33. 		th1.setName("线程A");
    34. 		th2.setName("线程B");
    35. 		//启动线程
    36. 		//2.void start() 启动线程
    37. 		th1.start();
    38. 		th2.start();
    39. 	}
    40. }

    线程的优先级

    线程的优先级---就是线程的执行先后。
    默认情况下所有线程的优先级都是一样，都是5。
    我们可以通过void    setPriority(int newPriority) 更改线程的优先级。
    1.线程的优先级有10个级别，分别使用整数1~10来表示。数字越大优先级越高。
    2.为了方便操作，java将10个级别有规定成3个级别，分别是最低的优先级，中等优先级，最高的优先级，并且将这3个级别封装成了静态常量    
        static int    MAX_PRIORITY 线程可以具有的最高优先级。10
        static int    MIN_PRIORITY线程可以具有的最低优先级。1
        static int    NORM_PRIORITY分配给线程的默认优先级。5
        int    getPriority() 返回线程的优先级。
    3.设置线程的优先级的时候，数字越大优先级越高，数字越小优先级越低。优先级越高并不代表就一定会优先执行，只是被优先执行的几率增大，因此不要试图通过控制线程的优先级，来保证某一个线程，总是第一个执行。

    1. package com.wangxing.test1;
    2. public class TestMain {
    3. 	public static void main(String[] args) {
    4. 		MyThread  mt=new MyThread();
    5. 		Thread th1=new Thread(mt);
    6. 		Thread th2=new Thread(mt);
    7. 		th1.setName("线程A");
    8. 		th2.setName("线程B");
    9. 		
    10. 		//默认情况下所有线程的优先级都是一样，都是5。
    11. 		//void	setPriority(int newPriority) 更改线程的优先级。
    12. 		//参数int newPriority---就是线程优先级的级别
    13. 		//线程的优先级有10个级别，分别使用整数1~10来表示。数字越大优先级越高。
    14. 		//th1.setPriority(2);
    15. 		//th2.setPriority(8);
    16. 		//为了方便操作，java将10个级别有规定成3个级别，
    17. 		//最低的优先级----static int MIN_PRIORITY=1
    18. 		//中等优先级-----static int	 NORM_PRIORITY=5
    19. 		//最高的优先级----static int MAX_PRIORITY=10
    20. 		th1.setPriority(Thread.MIN_PRIORITY);
    21. 		th2.setPriority(Thread.MAX_PRIORITY);
    22. 		//设置线程的优先级的时候，数字越大优先级越高，数字越小优先级越低。
    23. 		//优先级越高并不代表就一定会优先执行，只是被优先执行的几率增大
    24. 		//因此不要试图通过控制线程的优先级，来保证某一个线总是第一个执行。
    25. 		th1.start();
    26. 		th2.start();
    27. 		//默认情况下所有线程的优先级都是一样，都是5。
    28. 		//int	getPriority() 返回线程的优先级。
    29. 		int thpri1=th1.getPriority();
    30. 		int thpri2=th2.getPriority();
    31. 		//得到主线程的优先级
    32. 		Thread mainThread=Thread.currentThread();
    33. 		int mainpri=mainThread.getPriority();
    34. 		System.out.println("线程A的优先级=="+thpri1);
    35. 		System.out.println("线程B的优先级=="+thpri2);
    36. 		System.out.println("主线程的优先级=="+mainpri);
    37. 	}
    38. }

    守护线程的相关操作方法

    用户线程----通常情况之下我们所创建的线程都是普通线程，非守护线程，也叫用户线程。
    守护线程----也叫精灵线程,当所有用户线程都执行完毕以后，自动结束运行的线程就是守护线程.[共死]
    1.boolean    isDaemon() 测试该线程是否为守护线程。
    2.void    setDaemon(boolean on) 将该线程标记为守护线程用户线程。
    特征：当所有用户线程都执行完毕以后，无论守护线程能否可以继续运行，都要立刻停止运行。

    1. package com.wangxing.test2;
    2. public class MyThread implements Runnable{
    3. 	@Override
    4. 	public void run() {
    5. 	  for(int i=1;i<=100;i++){
    6. 		  //1.static Thread currentThread()得到当前正在运行的线程对象
    7. 		  Thread  dangqianThread=Thread.currentThread();
    8. 		  //3.String getName()返回该线程的名称。
    9. 		  String  threadname=dangqianThread.getName();
    10. 		  System.out.println(threadname+"===="+i);
    11. 	  }
    12. 	}
    13. }
    14.  
    15. package com.wangxing.test2;
    16. public class TestThread implements Runnable{
    17. 	@Override
    18. 	public void run() {
    19. 	  while(true){
    20. 		  Thread  dangqianThread=Thread.currentThread();
    21. 		  String  threadname=dangqianThread.getName();
    22. 		  System.out.println(threadname+"====守护线程");
    23. 	  }
    24. 	}
    25. }
    26.  
    27. package com.wangxing.test2;
    28. public class TestMain {
    29. 	public static void main(String[] args) {
    30. 		MyThread  mt=new MyThread();
    31. 		Thread th1=new Thread(mt);
    32. 		Thread th2=new Thread(mt);
    33. 		th1.setName("线程A");
    34. 		th2.setName("线程B");
    35. 		
    36. 		Thread th3=new Thread(new TestThread());
    37. 		th3.setName("线程C");
    38. 		//2.void setDaemon(boolean on) 将该线程标记为守护线程用户线程。
    39. 		th3.setDaemon(true);
    40. 		
    41. 		//1.boolean	isDaemon() 测试该线程是否为守护线程。
    42. 		//System.out.println("线程A---isDaemon=="+th1.isDaemon());
    43. 		//System.out.println("线程B---isDaemon=="+th2.isDaemon());
    44. 		//System.out.println("线程C---isDaemon=="+th3.isDaemon());
    45. 		th1.start();
    46. 		th2.start();
    47. 		th3.start();
    48. 	}
    49. }

    static void    sleep(long millis) 设置线程休眠【暂停】指定的时间【毫秒】

    1. 例如:闹钟程序
    2. package com.wangxing.test3;
    3.  
    4. import java.text.SimpleDateFormat;
    5. import java.util.Date;
    6.  
    7. public class MyThread implements Runnable{
    8. 	//保存闹钟时间的变量
    9. 	private  String  naozhongtime="";
    10. 	public MyThread(String  naozhongtime){
    11. 		this.naozhongtime=naozhongtime;
    12. 	}
    13. 	@Override
    14. 	public void run() {
    15. 		//设置时间格式
    16. 		SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
    17. 		boolean  flag=true;
    18. 		while(flag){
    19. 			//static void sleep(long millis) 设置线程休眠【暂停】指定的时间【毫秒】
    20. 			try {
    21. 				Thread.sleep(1000);
    22. 			} catch (InterruptedException e) {
    23. 				e.printStackTrace();
    24. 			}
    25. 			//得到当前系统时间
    26. 			Date date=new Date();
    27. 			String  time=sdf.format(date);
    28. 			System.out.println(time);
    29. 			if(time.equals(naozhongtime)){
    30. 				System.out.println("闹钟时间到！");
    31. 				flag=false;
    32. 			}
    33. 		}
    34. 	}
    35. }
    36.  
    37.  
    38. package com.wangxing.test3;
    39. import java.io.BufferedReader;
    40. import java.io.InputStreamReader;
    41.  
    42. public class TestMain {
    43. 	public static void main(String[] args) throws Exception{
    44. 		System.out.println("请输入闹钟时间:");
    45. 		BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    46. 		String  naozhongtime=input.readLine();
    47. 		//创建目标对象
    48. 		MyThread myth=new MyThread(naozhongtime);
    49. 		//创建线程对象
    50. 		Thread  th=new Thread(myth);
    51. 		//启动线程
    52. 		th.start();
    53. 	}
    54. }

    void    interrupt() 中断线程休眠【暂停】。会进入异常【InterruptedException】。

    1. package com.wangxing.test4;
    2.  
    3. import java.text.SimpleDateFormat;
    4. import java.util.Date;
    5.  
    6. public class MyThread implements Runnable{
    7. 	@Override
    8. 	public void run() {
    9. 		 for(int i=1;i<=100;i++){
    10. 			  try {
    11. 				Thread.sleep(500);
    12. 			} catch (InterruptedException e) {
    13. 				e.printStackTrace();
    14. 			}
    15. 			  Thread  dangqianThread=Thread.currentThread();
    16. 			  String  threadname=dangqianThread.getName();
    17. 			  System.out.println(threadname+"===="+i);
    18. 			 if(i==10){
    19. 				 System.out.println("休息10秒，接着执行");
    20. 				 try {
    21. 						Thread.sleep(10000);
    22. 					} catch (InterruptedException e) {
    23. 						System.out.println("休眠时间没有结束，强制被主线程中断");
    24. 					}
    25. 			 }
    26. 		 }
    27. 	}
    28. }
    29.  
    30. package com.wangxing.test4;
    31.  
    32. import java.io.BufferedReader;
    33. import java.io.InputStreamReader;
    34.  
    35. public class TestMain {
    36. 	public static void main(String[] args) throws Exception{
    37. 		//创建目标对象
    38. 		MyThread myth=new MyThread();
    39. 		//创建线程对象
    40. 		Thread  th=new Thread(myth);
    41. 		th.setName("线程A");
    42. 		//启动线程
    43. 		th.start();
    44. 		
    45. 		for(int i=1;i<=100;i++){
    46. 			try {
    47. 				Thread.sleep(500);
    48. 			} catch (InterruptedException e) {
    49. 				e.printStackTrace();
    50. 			}
    51. 			  Thread  dangqianThread=Thread.currentThread();
    52. 			  String  threadname=dangqianThread.getName();
    53. 			  System.out.println(threadname+"===="+i);
    54. 			  if(i==25){
    55. 				  //void interrupt() 中断线程休眠【暂停】。会进入异常【InterruptedException】。
    56. 				  th.interrupt(); 
    57. 			  }
    58. 		 }
    59. 	}
    60. }

    void join(long millis)【强制线程执行】等待该线程终止的时间最长为 millis 毫秒。
    注意:强制线程执行时，其他的线程不能与之交替运行。

    1. package com.wangxing.test5;
    2.  
    3. import java.text.SimpleDateFormat;
    4. import java.util.Date;
    5.  
    6. public class MyThread implements Runnable{
    7. 	@Override
    8. 	public void run() {
    9. 		 for(int i=1;i<=100;i++){
    10. 			  try {
    11. 				Thread.sleep(500);
    12. 			} catch (InterruptedException e) {
    13. 				e.printStackTrace();
    14. 			}
    15. 			  Thread  dangqianThread=Thread.currentThread();
    16. 			  String  threadname=dangqianThread.getName();
    17. 			  System.out.println(threadname+"===="+i);
    18. 		 }
    19. 	}
    20. }
    21.  
    22. package com.wangxing.test5;
    23.  
    24. import java.io.BufferedReader;
    25. import java.io.InputStreamReader;
    26.  
    27. public class TestMain {
    28. 	public static void main(String[] args) throws Exception{
    29. 		//创建目标对象
    30. 		MyThread myth=new MyThread();
    31. 		//创建线程对象
    32. 		Thread  th=new Thread(myth);
    33. 		th.setName("线程A");
    34. 		//启动线程
    35. 		th.start();
    36. 		
    37. 		for(int i=1;i<=100;i++){
    38. 			try {
    39. 				Thread.sleep(500);
    40. 			} catch (InterruptedException e) {
    41. 				e.printStackTrace();
    42. 			}
    43. 			  Thread  dangqianThread=Thread.currentThread();
    44. 			  String  threadname=dangqianThread.getName();
    45. 			  System.out.println(threadname+"===="+i);
    46. 			if(i==20){
    47. 				//void join(long millis)【强制线程执行】等待该线程终止的时间最长为 millis 毫秒。
    48. 				th.join(5000);
    49. 			} 
    50. 		 }
    51. 	}
    52. }
  • 相关阅读:
    【C++】C/C++内存管理
    一种基于差分进化和灰狼算法的混合优化算法-附代码
    STM32（五）：STM32指南者-按键控制灯开关实验
    redis的基本数据类型(一)
    策略模式在springboot中的使用
    RabbitMQ
    初阶扫雷（超详解）
    Go语言 并发与通道
    初识MySQL
    AWS中国峰会2024 半日游
  • 原文地址：https://blog.csdn.net/guizhaiteng/article/details/126286853