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

于 2019-08-24 10:39:36 发布
阅读量123 收藏 1
点赞数 1
分类专栏： Java 多线程 文章标签： Java 多线程（线程操作相关方法）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40916641/article/details/100042197
版权

声明： 本博客的是实例代码，不规范，正式写代码时把 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);
		}
	}	
}
运行结果截图：

在这里插入图片描述
   从 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);
		}
	}	
}
运行结果截图：

在这里插入图片描述
   上面的程序中，主方法直接通过 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);
		}
	}	
}
运行结果截图：

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

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

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

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);
		}
	}	
}
运行结果截图：

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

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);
		}
	}	
}
运行结果截图：

在这里插入图片描述
   上面的程序执行时，每次输出的都会间隔 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 方法正常结束");		
	}	
}
运行结果截图：

在这里插入图片描述
   从上面的程序可以看出，一个线程启动之后进入了休眠状态，原本是要休眠 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 种优先级，如表所示：
序号定义描述表示的常量
1public static final MIN_PRIORITY最低优先级1
2public static final NORM_PRIORITY中等低优先级，是线程的默认优先级5
3public static final MAX_PRIORITY最高优先级10
实例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);
		}
	}	
}
运行结果截图：

在这里插入图片描述
   从上面的程序运行结果可以观察到，线程将根据设置其优先级的大小来决定哪个线程会先运行，但是读者一定要记住的是，并不一定线程的优先级高就一定会先执行，哪个线程先执行将由 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);
		}
	}	
}
运行结果截图：

在这里插入图片描述
   由上面的表可知，数字 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();           // 线程礼让
			}
		}
	}	
}
运行结果截图：

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

我是一只青蛙
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值