线程常用操作方法

最新推荐文章于 2020-09-30 16:24:46 发布
最新推荐文章于 2020-09-30 16:24:46 发布
阅读量135 收藏
点赞数
分类专栏： Java 基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chaoyv/article/details/84606508
版权

本章目标
了解设置和取得线程名称
了解线程的强制运行
了解线程的休眠
了解线程的礼让
了解线程的中断操作

 

线程操作的主要方法


  

取得和设置线程名称
在Thread类中，可以通过getName()方法取得线程的名称，通过setName()方法设置线程的名称。
线程的名称一般在启动线程前设置，但也允许为已经运行的线程设置名称。允许两个Thread对象有相同的名字，但为了清晰，应该尽量避免这种情况的发生。
另外，如果程序并没有为线程指定名称，则系统会自动的为线程分配一个名称。

 

设置和取得线程的名字

class MyThread implements Runnable{//实现 Runnable 接口
	public void run(){//覆写接口中的 run() 
		for(int i=0; i<3; i++){//循环输出 3 次
			//取得当前线程的名称
			System.out.println(Thread.currentThread().getName()+"运行，i = "+i);
		}
	}
}
public class ThreadNameDemo {
	public static void main(String[] args) {
		MyThread my =new MyThread();//定义 Runnable 子类对象
		new Thread(my).start();//系统自动设置线程名称
		new Thread(my,"线程-A").start();//手工设置线程名称
		new Thread(my,"线程-B").start();//手工设置线程名称
		new Thread(my).start();//系统自动设置线程名称
		new Thread(my).start();//系统自动设置线程名称
	}
/* 结果：
 * Thread-0运行，i = 0
 * 线程-A运行，i = 0
 * 线程-A运行，i = 1
 * 线程-A运行，i = 2
 * 线程-B运行，i = 0
 * Thread-0运行，i = 1
 * 线程-B运行，i = 1
 * Thread-2运行，i = 0
 * Thread-1运行，i = 0
 * Thread-2运行，i = 1
 * 线程-B运行，i = 2
 * Thread-0运行，i = 2
 * Thread-2运行，i = 2
 * Thread-1运行，i = 1
 * Thread-1运行，i = 2
 * */
}

 

程序说明
从运行结果中发现没有设置线程名称的其余三个线程对象的名字都是很有规律的：Thread-0、Thread-1、Thread-2，从之前讲解的static关键字可以知道，在Thread类中必然存在一个static类型的属性，用于为线程自动命名。

 

观察程序的输出

class MyThread implements Runnable{//实现 Runnable 接口
	public void run(){//覆写接口中的 run() 
		for(int i=0; i<3; i++){//循环输出 3 次
			//取得当前线程的名称
			System.out.println(Thread.currentThread().getName()+"运行，i = "+i);
		}
	}
}
public class CurrentThreadDemo {
	public static void main(String[] args) {
		MyThread my =new MyThread();//定义 Runnable 子类对象
		new Thread(my,"线程").start();//启动线程
		my.run();//直接调用 run 方法
	}
/* 结果：
 * main运行，i = 0
 * 线程运行，i = 0
 * main运行，i = 1
 * 线程运行，i = 1
 * main运行，i = 2
 * 线程运行，i = 2
 * */
}

 

判断线程是否启动
通过Thread类之中的start()方法通知CPU这个线程已经准备好启动，之后就等待分配CPU资源，运行此线程了。那么如何判断一个线程是否已经启动了呢？在Java中可以使用isAlive()方法来测试线程是否已经启动而且仍然在启动。

 

判断线程是否启动

class MyThread implements Runnable{//实现 Runnable 接口
	public void run(){//覆写 run() 方法
		for(int i=0; i<3; i++){//循环输出 3 次
			//取得当前线程的名称
			System.out.println(Thread.currentThread().getName()+"运行 --> "+i);
		}
	}
}
public class ThreadAliveDemo {
	public static void main(String[] args) {
		MyThread mt =new MyThread();//实例化对象
		Thread t = new Thread(mt,"线程");//实例化 Thread 对象
		System.out.println("线程开始执行之前 --> "+t.isAlive());//判断是否启动
		t.start();//启动线程
		System.out.println("线程开始执行之后 --> "+t.isAlive());//判断是否启动
		for(int i=0; i<3; i++){//循环输出 3 次
			System.out.println("main 运行 -->"+i);//输出
		}
		System.out.println("代码执行之后 --> "+t.isAlive());//后面的输出结果不确定
	}
/* 结果：
 * 线程开始执行之前 --> false
 * 线程开始执行之后 --> true
 * main 运行 -->0
 * main 运行 -->1
 * main 运行 -->2
 * 代码执行之后 --> true
 * 线程运行 --> 0
 * 线程运行 --> 1
 * 线程运行 --> 2
 * */
}

 

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

 

线程的强制运行

class MyThread implements Runnable{//实现 Runnable 接口
	public void run(){//覆写 run() 方法
		for(int i=0; i<50; i++){//循环输出 50 次
			//输出线程的名称
			System.out.println(Thread.currentThread().getName()+"运行 --> "+i);
		}
	}
}
public class ThreadJoinDemo {
	public static void main(String[] args) {
		MyThread mt =new MyThread();//实例化对象
		Thread t = new Thread(mt,"线程");//实例化 Thread 对象
		t.start();//启动线程
		for(int i = 0; i<50; i++){//循环 50 次
			if(i>10){//判断变量内容
				try{
					t.join();//线程 t 进行强制运行
				}catch(Exception e){}//需要进行异常处理
			}
			System.out.println("Main 线程运行 --> "+i);
		}
	}
/* 结果：
 * Main 线程运行 --> 0
 * Main 线程运行 --> 1
 * Main 线程运行 --> 2
 * Main 线程运行 --> 3
 * Main 线程运行 --> 4
 * Main 线程运行 --> 5
 * Main 线程运行 --> 6
 * Main 线程运行 --> 7
 * Main 线程运行 --> 8
 * Main 线程运行 --> 9
 * Main 线程运行 --> 10
 * 线程运行 --> 0
 * 线程运行 --> 1
 * 线程运行 --> 2
 * 线程运行 --> 3
 * 线程运行 --> 4
 * 线程运行 --> 5
 * 线程运行 --> 6
 * 线程运行 --> 7
 * 线程运行 --> 8
 * 线程运行 --> 9
 * 线程运行 --> 10
 * 线程运行 --> 11
 * 线程运行 --> 12
 * 线程运行 --> 13
 * 线程运行 --> 14
 * 线程运行 --> 15
 * 线程运行 --> 16
 * 线程运行 --> 17
 * 线程运行 --> 18
 * 线程运行 --> 19
 * 线程运行 --> 20
 * 线程运行 --> 21
 * 线程运行 --> 22
 * 线程运行 --> 23
 * 线程运行 --> 24
 * 线程运行 --> 25
 * 线程运行 --> 26
 * 线程运行 --> 27
 * 线程运行 --> 28
 * 线程运行 --> 29
 * 线程运行 --> 30
 * 线程运行 --> 31
 * 线程运行 --> 32
 * 线程运行 --> 33
 * 线程运行 --> 34
 * 线程运行 --> 35
 * 线程运行 --> 36
 * 线程运行 --> 37
 * 线程运行 --> 38
 * 线程运行 --> 39
 * 线程运行 --> 40
 * 线程运行 --> 41
 * 线程运行 --> 42
 * 线程运行 --> 43
 * 线程运行 --> 44
 * 线程运行 --> 45
 * 线程运行 --> 46
 * 线程运行 --> 47
 * 线程运行 --> 48
 * 线程运行 --> 49
 * Main 线程运行 --> 11
 * Main 线程运行 --> 12
 * Main 线程运行 --> 13
 * Main 线程运行 --> 14
 * Main 线程运行 --> 15
 * Main 线程运行 --> 16
 * Main 线程运行 --> 17
 * Main 线程运行 --> 18
 * Main 线程运行 --> 19
 * Main 线程运行 --> 20
 * Main 线程运行 --> 21
 * Main 线程运行 --> 22
 * Main 线程运行 --> 23
 * Main 线程运行 --> 24
 * Main 线程运行 --> 25
 * Main 线程运行 --> 26
 * Main 线程运行 --> 27
 * Main 线程运行 --> 28
 * Main 线程运行 --> 29
 * Main 线程运行 --> 30
 * Main 线程运行 --> 31
 * Main 线程运行 --> 32
 * Main 线程运行 --> 33
 * Main 线程运行 --> 34
 * Main 线程运行 --> 35
 * Main 线程运行 --> 36
 * Main 线程运行 --> 37
 * Main 线程运行 --> 38
 * Main 线程运行 --> 39
 * Main 线程运行 --> 40
 * Main 线程运行 --> 41
 * Main 线程运行 --> 42
 * Main 线程运行 --> 43
 * Main 线程运行 --> 44
 * Main 线程运行 --> 45
 * Main 线程运行 --> 46
 * Main 线程运行 --> 47
 * Main 线程运行 --> 48
 * Main 线程运行 --> 49
 * */
}

 

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

 

线程的休眠

class MyThread implements Runnable{//实现 Runnable 接口
	public void run(){//覆写接口中的 run() 
		for(int i=0; i<5; i++){//循环输出 5 次
			try{
				Thread.sleep(500);//线程休眠
			}catch(Exception e){}//需要异常处理
			//输出线程的名称
			System.out.println(Thread.currentThread().getName()+"运行，i = "+i);
		}
	}
}
public class ThreadSleepDemo {
	public static void main(String[] args) {
		MyThread mt =new MyThread();//实例化对象
		new Thread(mt,"线程").start();//启动线程
	}
/* 结果：
 * 线程运行，i = 0
 * 线程运行，i = 1
 * 线程运行，i = 2
 * 线程运行，i = 3
 * 线程运行，i = 4
 * */
}

 

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

 

线程的中断

class MyThread implements Runnable{//实现 Runnable 接口
	public void run(){//覆写 run() 方法 
		System.out.println("1、进入 run() 方法");
		try{
			Thread.sleep(10000);//休眠 10s
			System.out.println("2、已经完成休眠");
		}catch(Exception e){
			System.out.println("3、休眠被终止");
			return;//让程序返回被调用处
		}
		System.out.println("4、run 方法正常结束");
	}
}
public class ThreadInterruptDemo {
	public static void main(String[] args) {
		MyThread mt =new MyThread();//实例化子类对象
		Thread t = new Thread(mt,"线程");//实例化线程对象
		t.start();
		try{
			Thread.sleep(2000);//稍微停 2s 再继续中断
		}catch(Exception e){
		}
		t.interrupt();//中断线程执行
	}
/* 结果：
 * 1、进入 run() 方法
 * 3、休眠被终止
 * */
}

 

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

 

后台线程的设置

class MyThread implements Runnable{//实现 Runnable 接口
	public void run(){//覆写 run() 方法 
		while(true){//无限制循环
			//输出线程名称
			System.out.println(Thread.currentThread().getName()+"在运行。");
		}
	}
}
public class ThreadDaemonDemo {
	public static void main(String[] args) {
		MyThread mt =new MyThread();//实例化子类对象
		Thread t = new Thread(mt,"线程");//实例化 Thread 类对象
		t.setDaemon(true);//此线程在后台运行
		t.start();//启动线程
	}
/* 结果：
 * 线程在运行。
 * 线程在运行。
 * 线程在运行。
 * 线程在运行。
 * 线程在运行。
 * 线程在运行。
 * 线程在运行。
 * 线程在运行。
 * 线程在运行。
 * 线程在运行。
 * ……
 * */
}

 

线程的优先级
在Java的线程操作中，所有的线程在运行前都会保持在就绪状态，那么此时，那个线程的优先级高，那个线程就有可能会先被执行。

 

线程优先级
在Java的线程中使用setPriority()方法可以设置一个线程的优先级，在Java的线程中一共有以下三种优先级

 

测试线程优先级

class MyThread implements Runnable{//实现 Runnable 接口
	public void run(){//覆写 run() 方法 
		for(int i = 0; i<5; i++){//循环 5 次
			try{
				Thread.sleep(500);//线程休眠
			}catch(Exception e){}//需要异常处理
			//输出线程名称
			System.out.println(Thread.currentThread().getName()+"运行，i = "+i);
		}
	}
}
public class ThreadPriorityDemo {
	public static void main(String[] args) {
		Thread t1 = new Thread(new MyThread(),"线程 A");//实例化线程对象
		Thread t2 = new Thread(new MyThread(),"线程 B");//实例化线程对象
		Thread t3 = new Thread(new MyThread(),"线程 C");//实例化线程对象
		t1.setPriority(Thread.MIN_PRIORITY);//设置线程优先级为最低
		t2.setPriority(Thread.MAX_PRIORITY);//设置线程优先级为最高
		t3.setPriority(Thread.NORM_PRIORITY);//设置线程优先级为中等
		t1.start();//启动线程
		t2.start();//启动线程
		t3.start();//启动线程
	}
/* 结果：
 * 线程 B运行，i = 0 —>第 2 个线程（t2）的优先级为：MAX_PRIORITY
 * 线程 C运行，i = 0 —>第 2 个线程（t3）的优先级为：NORM_PRIORITY
 * 线程 A运行，i = 0 —>第 2 个线程（t1）的优先级为：MIN_PRIORITY
 * 线程 B运行，i = 1
 * 线程 C运行，i = 1
 * 线程 A运行，i = 1
 * 线程 B运行，i = 2
 * 线程 C运行，i = 2
 * 线程 A运行，i = 2
 * 线程 A运行，i = 3
 * 线程 C运行，i = 3
 * 线程 B运行，i = 3
 * 线程 A运行，i = 4
 * 线程 C运行，i = 4
 * 线程 B运行，i = 4
 * */
}

 
主方法的优先级是NORM_PRIORITY
public class MainPriorityDemo {
  public static void main(String[] args) {
  System.out.println("主方法的优先级：" +
  Thread.currentThread().getPriority());  // 取得主方法的优先级
  }
}
程序运行结果：
主方法的优先级：5
  程序中取得线程优先级的结果是“5”，数字5对应的是“NORM_PRIORITY”这个优先级，所以主线程的优先级是中等级别。

 

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

 

线程的礼让

class MyThread implements Runnable{//实现 Runnable 接口
	public void run(){//覆写 run() 方法 
		for(int i = 0; i<5; i++){//不断输出
			//输出线程名称
			System.out.println(Thread.currentThread().getName()+"运行 --> "+i);
			if(i==3){
				System.out.print("线程礼让：");
				//线程礼让
				Thread.currentThread().yield();
			}
		}
	}
}
public class ThreadYieldDemo {
	public static void main(String[] args) {
		MyThread my =new MyThread();//实例化 MyThread 对象
		Thread t1 = new Thread(my,"线程 A");//定义线程对象
		Thread t2 = new Thread(my,"线程 A");//定义线程对象
		t1.start();//启动多线程
		t2.start();//启动多线程
	}
/* 结果：
 * 线程 A运行 --> 0
 * 线程 A运行 --> 0
 * 线程 A运行 --> 1
 * 线程 A运行 --> 1
 * 线程 A运行 --> 2
 * 线程 A运行 --> 3
 * 线程礼让：线程 A运行 --> 2
 * 线程 A运行 --> 4
 * 线程 A运行 --> 3
 * 线程礼让：线程 A运行 --> 4
 * */
}

 

chaoyv
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程的操作方式
咸蛋超人
07-20 270
线程的操作方法 课程大纲 一、 线程的操作方法 （1）、Thread (Runnabel target):分配新的thread对象 （2）、Thread(Runnable target,String name):分配新的thread对象。 （3）、Thread(String name):分配新的thread对象 （4）、static Thread currentThread():返回当
线程的常用操作方法
Rachel_pan的博客
10-10 266
一 、线程的状态 二 、线程操作的相关方法 1 、取得和设置线程的名称 在线程操作中，如果没有为一个线程指定一个名称，则系统在使用会自动为线程分配一个名称，格式为 Thread-xx class MyThread implements Runnable{ public void run(){ System.out.println("当前执行的线程名称是" + Thre...
多线程(认识多线程、线程的常用操作方法)
零度、冰点
08-03 5851
认识多线程 进程与线程： 进程是程序的一次动态执行过程，它经历了从代码加载、到执行完毕的一个完整过程，这个过程也是进程本身从产生、发展到最终消亡的过程。 多线程是实现并发机制的一种有效手段。进程和线程一样，都是实现并发的一个基本单位。 Java的多线程实现，有一下两种方式
Java线程常用的操作方法
iteye_18817的博客
06-15 167
目标： 了解设置和取得线程的名称。 了解线程的强制运行。 了解线程的休眠。 了解线程的礼让。 了解线程的中断操作。 具体内容：在多线程中所有的操作方法实际上都是从Thread类开始的。所有的操作都是在Thread类之中的。 线程操作的主要方法 NO 方法名称 类型 描述 1 public Thread（Runnable target） 构造 接收Runnable接口子类对象，实例化Threa...
java线程常用操作方法笔记
04-09
java线程常用操作方法笔记，每一点都是经过本人精心筛选出来的重点！
java语言版本的`元组`数据类型，实现了元组类型的特性以及常用操作方法，轻量级，无依赖，线程安全
06-10
java语言版本的`元组`数据类型，实现了元组类型的特性以及常用操作方法，轻量级，无依赖，线程安全。
多线程操作窗口源码
08-20
多线程是一种提高程序运行效率和性能的常用技术。 随着我们学习工作的深入，在编程中或多或少会涉及到 需要多线程的情况。多数时候，我们的操作模式是后台 线程中处理数据，计算结果，然后在前台界面（GUI） 中更新...
Java线程
12-21
线程常用方法 inturrupt打断线程 join（）线程并行执行变为串行 理解线程的概念 一个程序至少有一个进程，一个进程至少有一个线程； 线程是进程的一个实体，是CPU调度和分派的基本单位； 一个线程可以创建和撤销另...
线程基本操作
u012763405的博客
03-30 239
前言：线程神秘而又令人向往，好奇是恋上的第一步，出乎意料有时候又让你懊恼，可能你永远无法真正把握线程的小脾气，总会给你出一点状况，可这就是她的俏皮之处，想要探究更深。 她，状况不多，通常也就是NEW RUNNABLE BLOCKED WAITING TIMEED_WAITING TERMINATED 终止线程：现在很多文章都会提到了线程的安全性。我们先看下线程终止，线程终止根据我们学的直接th...
Java中线程的操作方法
june_ruikang的博客
02-27 291
对于线程来讲，所有的操作方法都是在Thread类中定义，想要明确理解线程的操作方法，应该从Thread类的方法着手。 1、设置和取得名字 设置名字：     public final void setName(String name) {         checkAccess();         this.name = name.toCharArray();     } 构造
线程常用操作
Trigl的博客
04-01 1537
本文讲解了Java中中断线程的概念和常用方法以及让步操作和优先级等概念，对线程的常用操作进行初步了解。1 停止线程Java停止一个线程是通过调用Thread类的interrupt()方法来实现的，下面具体讲一下它的相关用法。1.1 interrupt() != 立即终止调用interrupt()并不会像break语句那样直接就终止线程，它仅仅是在当前线程中打了一个停止的标记，并不是真的停止线程。
线程操作方法
Iron_Man501的博客
11-30 380
一 取得和设置线程名称在Thread的类中，可以通过getName()方法取得线程名称，通过setName()设置下那成名称。 线程的名称一般在线程启动之前设置，也允许为已经运行的线程设置，允许两个Thread类有相同的名字。 如果程序没有个线程指定名称，则系统会自动给线程分配一个。 代码如下class MyThread implements Runnable //实现Runnable接口
144.daemon守护线程
qq_43808700的博客
09-30 206
线程分为用户线程 1和守护线程 2，虚拟机不用等待守护线程执行完毕 将普通线程设置成为守护线程 package zy.thread; public class daemonThread { public static void main(String[] args) { god g = new god(); person p = new person(); g.setDaemon(true); //将上帝线程设置成守护线程 g.start(); p.start(); } } c.
线程的操作方法
偶尔记录些东西
08-17 105
多线程的常用操作方法
xjy22的博客
08-11 963
主方法本身就是一个线程，所有的线程都是通过主线程创建并启动的。run()方法相当于主类 中的main方法 class MyThread implements Runnable{ public void run() { System.out.println("当前线程：" +Thread.currentThread().getName()); } } public class Lin...
进程和线程常用函数有哪些
最新发布
07-09
进程和线程是操作系统中的重要概念，常用的函数有： 1. fork(): 创建一个新的进程，该函数会复制当前进程的副本，包括代码、数据和打开的文件等。在父进程中，该函数返回新创建进程的进程ID；在子进程中，该函数...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值