Java 基础学习之多线程四（线程操作相关方法）

旧城等待， 2024-04-17 05:45 71阅读 0赞

**声明：** 本博客的是实例代码，不规范，正式写代码时把 main() 放到一个单独的类中会更规范一点。

### 1.取得和设置线程的名称 ###

在 Thread 类中通过 getName() 方法取得线程名称，通过 setName() 方法设置线程的名称。线程名称一般在启动前设置，但也允许为已经运行的线程设置名称。允许两个线程 Thread 对象有相同的名字，但为了清晰，应该尽量避免这种情况的发生。  
**提示：** 在线程操作中，如果没有为一个线程指定名称，则系统在使用时会为线程分配一个名称，名称格式为 Thread-Xx。

###### 实例1代码： ######

package self.learn.thread;
    
    public class MyThread implements Runnable {                 // 实现 Runnable 接口
    
    	public static void main(String[] args) { 
    		// TODO Auto-generated method stub 
    		MyThread thread1 = new MyThread();         // 实例化 Runnable 子类对象 
    		new Thread(thread1).start();               // 系统自动设置线程名称
    		new Thread(thread1, "线程-A").start();      // 手动设置线程名称
    		new Thread(thread1, "线程-B").start();      // 手动设置线程名称
    		new Thread(thread1).start();               // 系统自动设置线程名称
    	}
    
    	public void run() {                                //覆写 Runnable 接口中 run() 方法
    		for(int i = 0; i < 3; i++) { 
    			System.out.println(Thread.currentThread().getName()+"运行，i="+i);
    		}
    	}	
    }

###### 运行结果截图： ######

![在这里插入图片描述][20190823170644641.png]  
   从 static 关键字可知，在 Thread 类中必然存在一个 static 类属性，用于为线程自动命名。

###### 实例2代码： ######

package self.learn.thread;
    
    public class MyThread implements Runnable {                 // 实现 Runnable 接口
    
    	public static void main(String[] args) { 
    		// TODO Auto-generated method stub 
    		MyThread thread1 = new MyThread();         // 实例化 Runnable 子类对象 
    		new Thread(thread1, "线程").start();      // 手动设置线程名称
    		thread1.run();
    
    	}
    
    	public void run() {                                //覆写 Runnable 接口中 run() 方法
    		for(int i = 0; i < 3; i++) { 
    		   // currentThread() 返回目前正在执行的线程
    			System.out.println(Thread.currentThread().getName()+"运行，i="+i);
    		}
    	}	
    }

###### 运行结果截图： ######

![在这里插入图片描述][20190823171301863.png]  
   上面的程序中，主方法直接通过 Runnable 接口的子类对象调用的 run() 方法，另外一个是通过线程对象调用 start() 方法启动的，从结果中发现，主方法实际上也是一个线程。另外要提醒读者的是，在 Java 中所有的线程都是同时启动的，哪个线程先抢占到了 CPU 资源，哪个就先运行。

###### 提问：Java 程序每次运行至少启动几个线程？ ######

因为 Java 是多线程的编程语言，所有对于 Java 程序运行的时候也是以线程的方式启动的，那么主方法也就是一个线程（main）,但是对于一个 Java 程序来说，一个 Java 程序运行至少会启动几个线程？

###### 回答：至少启动两个线程。一个是 main线程;另一个是 垃圾收集线程。 ######

每当使用 Java 命令执行一个类的时候，实际上都会启动一个 JVM。每一个 JVM 实际上就是在操作系统中启动了一个进程， Java 本身具备了垃圾收集 机制。所以在 Java 运行时至少会启动两个线程：一个是 main线程;另一个是 垃圾收集线程。

### 2.判断线程是否启动 ###

通过前面的讲解可知，通过 Thread 类中的方法 start() 通知 CPU 这个线程是否已经准备好启动。然后就等待分配 CPU 资源，运行此线程。在 Java 中可以使用 isAlive() 方法来测试线程是否已经启动且仍然在运行。

###### 实例3代码： ######

package self.learn.thread;
    
    public class MyThread implements Runnable {                  // 实现 Runnable 接口
    
    	public static void main(String[] args) { 
    		// TODO Auto-generated method stub 
    		MyThread thread1 = new MyThread();                 // 实例化 Runnable 子类对象 
    		Thread t = new Thread(thread1, "线程");             // 实列化 Thread 对象
    		System.out.println("线程开始执行之前 -->"+t.isAlive()); //判断是否启动
    		t.start();                                         // 启动线程
    		System.out.println("线程开始执行之后 -->"+t.isAlive()); //判断是否启动
    		for(int i = 0; i < 3; i++) {  
    			System.out.println("main 运行，i="+i);          // 输出
    		}
    		System.out.println("线程开始执行之后 -->"+t.isAlive()); //后面的输出结果不确定
    
    	}
    
    	public void run() {                                     //覆写 Runnable 接口中 run() 方法
    		for(int i = 0; i < 3; i++) {  
    			System.out.println(Thread.currentThread().getName()+"运行，i="+i);
    		}
    	}	
    }

###### 运行结果截图： ######

![在这里插入图片描述][20190823173739549.png]  
   上面的程序执行结果是不确定的，有可能到最后线程已经不存活了，但也有肯继续存活，这要看哪个线程先执行完。

###### 主线程有可能比其他线程先执行完。 ######

因为线程操作的不确定性，所以主线程有肯最先执行完，此时其他线程不会受到影响，也不会随着主线程的结束而结束。

### 3.线程的强制运行 ###

在线程操作中，可以使用 join() 方法让一个线程强制运行。在线程强制运行期间，其他线程无法运行，必须等待此线程完成之后才可以继续执行。

###### 实例4代码： ######

package self.learn.thread;
    
    public class MyThread implements Runnable {                  // 实现 Runnable 接口
    
    	public static void main(String[] args) { 
    		// TODO Auto-generated method stub 
    		MyThread thread1 = new MyThread();                 // 实例化 Runnable 子类对象 
    		Thread t = new Thread(thread1, "线程");             // 实列化 Thread 对象
    		t.start();                                         // 启动线程
    	    for(int i = 0; i < 10; i++) { 
    	    	if(i > 5) { 
    	    		try { 
    					t.join();                              // 线程 t 进行强制运行
    				} catch (Exception e) {                     // 需要进行异常处理
    					// TODO: handle exception
    					System.out.println("线程 t 进行强制运行异常:"+e.getMessage());
    				}
    	    	}
    	    	System.out.println("Main 线程运行 -->"+i);
    	    }
    
    	}
    
    	public void run() {                                     //覆写 Runnable 接口中 run() 方法
    		for(int i = 0; i < 5; i++) {  
    			System.out.println(Thread.currentThread().getName()+"运行，i="+i);
    		}
    	}	
    }

###### 运行结果截图： ######

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkxNjY0MQ_size_16_color_FFFFFF_t_70]  
   由实验结果可得，此后所有的输出都将由一个线程完成，主线程必须等待这个线程执行之后才会继续执行。

### 4.线程的休眠 ###

在程序中允许一个线程进行暂时的休眠，直接使用 Thread.sleep() 方法即可实现。

###### 实例5代码： ######

package self.learn.thread;
    
    public class MyThread implements Runnable {                  // 实现 Runnable 接口
    
    	public static void main(String[] args) { 
    		// TODO Auto-generated method stub 
    		MyThread thread1 = new MyThread();                 // 实例化 Runnable 子类对象 
    		Thread t = new Thread(thread1, "线程");             // 实列化 Thread 对象
    		t.start();                                         // 启动线程 
    	}
    
    	public void run() {                                     //覆写 Runnable 接口中 run() 方法
    		for(int i = 0; i < 3; i++) {  
    			try { 
    				Thread.sleep(500);                        // 线程休眠 500 毫秒
    			} catch (Exception e) { 
    				// TODO: handle exception
    				System.out.println("线程休眠出现异常："+e.getMessage());
    			}
    			System.out.println(Thread.currentThread().getName()+"运行，i="+i);
    		}
    	}	
    }

###### 运行结果截图： ######

![在这里插入图片描述][20190824090456484.png]  
   上面的程序执行时，每次输出的都会间隔 500 ms,达到了延迟的操作。

### 5.中断线程 ###

当一个线程运行的时候，另外一个线程可以直接通过 interrupt() 方法，中断其状态。

###### 实例6代码： ######

package self.learn.thread;
    
    public class MyThread implements Runnable {                  // 实现 Runnable 接口
    
    	public static void main(String[] args) { 		
    		MyThread thread1 = new MyThread();                 // 实例化 Runnable 子类对象 
    		Thread t = new Thread(thread1, "线程");             // 实列化 Thread 对象
    		t.start();                                         // 启动线程 
    		try { 
    			Thread.sleep(2000);                            // 稍微停 2s 在继续中断
    		} catch (Exception e) { 			}
    		t.interrupt();
    	}
    
    	public void run() {                                     //覆写 Runnable 接口中 run() 方法 
    			System.out.println("1. 进入 run 方法");
    			try { 
    				Thread.sleep(10000);                        // 线程休眠 10秒
    				System.out.println("2. 已完成休眠");
    			} catch (Exception e) { 
    				System.out.println("3. 休眠被终止");
    				System.out.println("线程休眠出现异常："+e.getMessage());
    			}
    			System.out.println("4.run 方法正常结束");		
    	}	
    }

###### 运行结果截图： ######

![在这里插入图片描述][2019082409294056.png]  
   从上面的程序可以看出，一个线程启动之后进入了休眠状态，原本是要休眠 10s 之后再继续执行，但是主方法在线程启动之后的 2s 就将其中断。

### 6.后台线程 ###

在 Java 程序中，只有前台有一个线程在运行，则整个 Java 进程都不会消失，所以此时可以设置一个后台线程，这样即使 Java 进程结束了，此后台线程依然会继续执行。要想实现这样的操作，直接使用 setDaemon() 方法即可。

###### 实例7代码： ######

package self.learn.thread;
    
    public class MyThread implements Runnable {                  // 实现 Runnable 接口
    
    	public static void main(String[] args) { 		
    		MyThread thread1 = new MyThread();                 // 实例化 Runnable 子类对象 
    		Thread t = new Thread(thread1, "线程");             // 实列化 Thread 对象
    		t.setDaemon(true);                                 // 设置线程后台运行
    		t.start();                                         // 启动线程 
    	}
    
    	public void run() {                                     //覆写 Runnable 接口中 run() 方法 
    		while(true) { 
    			System.out.println(Thread.currentThread().getName()+" 在运行");
    		}						
    	}	
    }

在线程 MyThread 类中，尽管 run() 方法中是死循环的方式，但是程序依然可以执行完，因为方法中的死循环已经设置成后台运行了。

### 7.线程的优先级 ###

1.  在 Java 的线程操作中，所有的线程在运行前都会保持在就绪状态，那么此时，哪个线程的优先级高，哪个线程就有可能会先执行。
2.  在 Java 的线程中使用 setPriority() 方法可以设置一个线程的优先级。在 Java 中一共有以下 3 种优先级，如表所示：

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>定义</th> 
   <th>描述</th> 
   <th>表示的常量</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>public static final MIN_PRIORITY</td> 
   <td>最低优先级</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>public static final NORM_PRIORITY</td> 
   <td>中等低优先级，是线程的默认优先级</td> 
   <td>5</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>public static final MAX_PRIORITY</td> 
   <td>最高优先级</td> 
   <td>10</td> 
  </tr> 
 </tbody> 
</table>

###### 实例8代码： ######

package self.learn.thread;
    
    public class MyThread implements Runnable {                  // 实现 Runnable 接口
    
    	public static void main(String[] args) { 		
    		      Thread thread1 = new Thread(new MyThread(),"线程 A");  
    		      Thread thread2 = new Thread(new MyThread(),"线程 B"); 
    		      Thread thread3 = new Thread(new MyThread(),"线程 C"); 
    		      thread1.setPriority(Thread.MIN_PRIORITY);           // 设置线程优先级为 最低
    		      thread2.setPriority(Thread.NORM_PRIORITY);          // 设置线程优先级为 中等
    		      thread3.setPriority(Thread.MAX_PRIORITY);           // 设置线程优先级为 最高
    		      thread1.start();                                    // 启动线程
    		      thread2.start();
    		      thread3.start();
    	}
    
    	public void run() {                                     //覆写 Runnable 接口中 run() 方法 
    		for(int i = 0; i < 5; i++) { 
    			try { 
    				Thread.sleep(500);                        // 线程休眠 500 毫秒
    			} catch (Exception e) { 
    				System.out.println("线程休眠出现异常:"+e.getMessage());
    			}
    			System.out.println(Thread.currentThread().getName()+"运行，i="+i);
    		}
    	}	
    }

###### 运行结果截图： ######

![在这里插入图片描述][20190824101054880.png]  
   从上面的程序运行结果可以观察到，线程将根据设置其优先级的大小来决定哪个线程会先运行，但是读者一定要记住的是，并不一定线程的优先级高就一定会先执行，哪个线程先执行将由 CPU 的调度决定。

###### 实例9代码：（主方法 mian 的优先级是 NORM\_PRIORITY） ######

package self.learn.thread;
    
    public class MyThread implements Runnable {                  // 实现 Runnable 接口
    
    	public static void main(String[] args) { 		
    		System.out.println("主方法的优先级:"+Thread.currentThread().getPriority());
    	}
    
    	public void run() {                                     //覆写 Runnable 接口中 run() 方法 
    		for(int i = 0; i < 5; i++) { 
    			try { 
    				Thread.sleep(500);                        // 线程休眠 500 毫秒
    			} catch (Exception e) { 
    				System.out.println("线程休眠出现异常:"+e.getMessage());
    			}
    			System.out.println(Thread.currentThread().getName()+"运行，i="+i);
    		}
    	}	
    }

###### 运行结果截图： ######

![在这里插入图片描述][20190824101737301.png]  
   由上面的表可知，数字 5 对应的优先级是 “NORM\_PRIORITY”，所以主线程的优先级是中等级别。

### 8.线程的礼让 ###

在线程操作中，也可以使用 yield() 方法将一个线程的操作暂时让给其他线程执行。

###### 实例10代码： ######

package self.learn.thread;
    
    public class MyThread implements Runnable {                  // 实现 Runnable 接口
    
    	public static void main(String[] args) { 		
    		MyThread myThread = new MyThread();                // 实例化 MyThread 对象
    		Thread thread1 = new Thread(myThread,"线程 A");      // 定义线程对象
    		Thread thread2 = new Thread(myThread,"线程 B");      // 定义线程对象
    		thread1.start();                                   // 启动多线程
    		thread2.start();
    	}
    
    	public void run() {                                     //覆写 Runnable 接口中 run() 方法 
    		for(int i = 0; i < 5; i++) { 
    			System.out.println(Thread.currentThread().getName()+"运行，i="+i);
    			if(i == 3) { 
    				System.out.print("线程礼让:");
    				Thread.yield();           // 线程礼让
    			}
    		}
    	}	
    }

###### 运行结果截图： ######

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkxNjY0MQ_size_16_color_FFFFFF_t_70 1]  
   从上面的运行结果可以发现，每当线程满足条件（i == 3）,就会将本线程暂停，而让其他线程先执行。

[20190823170644641.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/699dd96602bd4926a1c128aae9e9dc02.png
[20190823171301863.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/1844bdecba474a6ea4976b686b78e981.png
[20190823173739549.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/1ecc3438633a40698aced31fa6ebb834.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkxNjY0MQ_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/71fe13053780481697b6d81a85938817.png
[20190824090456484.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/283d35f5236c4ae1962dadd1eb885ce9.png
[2019082409294056.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/ce5ee0f8bef64082810e770701ab6b65.png
[20190824101054880.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/ab128d03ac664b679d76427e63061924.png
[20190824101737301.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/c27c4421be3c417d9cd2fe24c30f6204.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkxNjY0MQ_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/a9e777978f0c44c392de331702e86365.png