Java线程操作方法

最新推荐文章于 2022-05-20 20:38:43 发布
最新推荐文章于 2022-05-20 20:38:43 发布
阅读量74 收藏
点赞数
文章标签： java

 

取得和设置线程名称

//=================================================
// File Name       :	Thread_demo
//------------------------------------------------------------------------------
// Author          :	Common


// 接口名：MyThread
// 属性：
// 方法：
class MyThread_1 implements Runnable{	//实现Runnable接口
	private String name;
	
//	public MyThread_1(String name) {	//构造方法
//		super();
//		this.name = name;
//	}
	
	@Override
	public void run() {								//覆写Thread类中的run()方法
		// TODO 自动生成的方法存根
		for (int i=0;i<10;i++){
//			System.out.println(name+"运行，i="+i);
			System.out.println(Thread.currentThread().getName()+",i="+i);	//取出当前线程的名称
		}
	}
	
}



//主类
//Function        : 	Thread_demo
public class Runnable_demo {

	public static void main(String[] args) {
		
		MyThread_1 mt1 = new MyThread_1();	//实例化Runnable子类对象
		new Thread(mt1).start();								//系统自动设置线程名称
		new Thread(mt1,"线程A").start();				//手工自动设置线程名称
		new Thread(mt1,"线程B").start();				//手工自动设置线程名称
		new Thread(mt1).start();								//系统自动设置线程名称
		new Thread(mt1).start();								//系统自动设置线程名称
	}

}

手工设置线程名称　　　　系统自动设置线程名称

　　　　　　　　

 

判断线程是否启动

使用isAlive()方法来判断线程是否已经启动而且仍然在启动

//=================================================
// File Name       :	Thread_demo
//------------------------------------------------------------------------------
// Author          :	Common


// 接口名：MyThread
// 属性：
// 方法：
class MyThread_1 implements Runnable{	//实现Runnable接口
	private String name;
	
	public MyThread_1(String name) {	//构造方法
		super();
		this.name = name;
	}
	
	@Override
	public void run() {								//覆写Thread类中的run()方法
		// TODO 自动生成的方法存根
		for (int i=0;i<10;i++){
//			System.out.println(name+"运行，i="+i);
			System.out.println(Thread.currentThread().getName()+",i="+i);	//取出当前线程的名称
		}
	}
	
}



//主类
//Function        : 	Thread_demo
public class Runnable_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		MyThread_1 mt1 = new MyThread_1("线程A ");	//实例化Runnable子类对象
		MyThread_1 mt2 = new MyThread_1("线程B ");	//实例化Runnable子类对象
		Thread t1 = new Thread(mt1);							//实例化Thread类对象
		Thread t2 = new Thread(mt2);							//实例化Thread类对象
		System.out.println("线程开始执行之前-->"+t1.isAlive());
		t1.start();																	//启动线程
		System.out.println("线程开始执行之后-->"+t1.isAlive());
		t2.start();																	//启动线程

	}

}

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

 

线程的强制运行

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

 

线程的休眠

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

程序在执行的时候，每次的输出都会间隔500ms，达到了延时操作的效果。

Thread.sleep()方法要用try和catch语句包围

//=================================================
// File Name       :	Thread_demo
//------------------------------------------------------------------------------
// Author          :	Common


// 接口名：Mythread
// 属性：
// 方法：
class Mythread implements Runnable{	//实现Runnable接口
	
	@Override
	public void run() {								//覆写Thread类中的run()方法
		// TODO 自动生成的方法存根
		for (int i=0;i<5;i++){
			try{
				Thread.sleep(500);						//线程休眠
			}catch (Exception e){}				//需要异常处理
				System.out.println(Thread.currentThread().getName()+",i="+i);	//取出当前线程的名称
		}
	}
	
}

//主类
//Function        : 	ThreadSleep_demo
public class ThreadSleep_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Mythread m = new Mythread();
		new Thread(m,"线程").start();
	}

}

 

中断线程

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

一个线程启动之后进入了休眠状态，原来是要休眠10s之后再继续执行，但是主方法在线程启动之后的2s之后就将其中断，休眠一旦中断之后将执行catch中的代码。

//=================================================
// File Name       :	Thread_demo
//------------------------------------------------------------------------------
// Author          :	Common


// 接口名：Mythread_1
// 属性：
// 方法：
class Mythread_1 implements Runnable{	//实现Runnable接口
	
	@Override
	public void run() {								//覆写Thread类中的run()方法
		// TODO 自动生成的方法存根
		System.out.println("进入run方法");
		try{
			Thread.sleep(10000);						//线程休眠
			System.out.println("休眠完成");
				}catch (Exception e){				//需要异常处理
			System.out.println("休眠被终止");
			return;												//让程序返回被调用处
		}
		System.out.println("run方法结束");
	}
	
}

//主类
//Function        : 	ThreadSleep_demo
public class ThreadInterrupt_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Mythread_1 m = new Mythread_1();
		Thread t = new Thread(m,"线程");
		t.start();
		try{
			Thread.sleep(2000);			//主线程2s之后再执行中断
		}catch(Exception e){}
		t.interrupt();
	}

}

 

后台线程

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

 

线程的优先级

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

//=================================================
// File Name       :	Thread_demo
//------------------------------------------------------------------------------
// Author          :	Common


// 接口名：MyThread
// 属性：
// 方法：
class MyThread_1 implements Runnable{	//实现Runnable接口
	private String name;
	
//	public MyThread_1(String name) {	//构造方法
//		super();
//		this.name = name;
//	}
	
	@Override
	public void run() {								//覆写Thread类中的run()方法
		// TODO 自动生成的方法存根
		for (int i=0;i<10;i++){
			//System.out.println(name+"运行，i="+i);
			System.out.println(Thread.currentThread().getName()+",i="+i);	//取出当前线程的名称
		}
	}
	
}



//主类
//Function        : 	Thread_demo
public class Runnable_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		MyThread_1 mt1 = new MyThread_1();	//实例化Runnable子类对象
		MyThread_1 mt2 = new MyThread_1();	//实例化Runnable子类对象
		MyThread_1 mt3 = new MyThread_1();	//实例化Runnable子类对象
		Thread t1 = new Thread(mt1,"线程A");							//实例化Thread类对象
		Thread t2 = new Thread(mt2,"线程B");							//实例化Thread类对象
		Thread t3 = new Thread(mt3,"线程C");							//实例化Thread类对象
//		System.out.println("线程开始执行之前-->"+t1.isAlive());
		t1.setPriority(Thread.MIN_PRIORITY);
		t2.setPriority(Thread.NORM_PRIORITY);
		t3.setPriority(Thread.MAX_PRIORITY);
		t1.start();																	//启动线程
//		System.out.println("线程开始执行之前-->"+t1.isAlive());
		t2.start();																	//启动线程
		t3.start();																	//启动线程
		
//		MyThread_1 mt1 = new MyThread_1();	//实例化Runnable子类对象
//		new Thread(mt1).start();								//系统自动设置线程名称
//		new Thread(mt1,"线程A").start();				//手工自动设置线程名称
//		new Thread(mt1,"线程B").start();				//手工自动设置线程名称
//		new Thread(mt1).start();								//系统自动设置线程名称
//		new Thread(mt1).start();								//系统自动设置线程名称
	}

}

 线程将根据优先级的大小来决定哪个线程会先运行，但是并非线程的优先级越高就一定会先执行，哪个线程先执行将由CPU的调度决定。

主方法的优先级是NORM，通过Thread.currentThread().getPriority()来取得主方法的优先级，结果是5

 

线程的礼让

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

//=================================================
// File Name       :	Thread_demo
//------------------------------------------------------------------------------
// Author          :	Common


// 接口名：MyThread
// 属性：
// 方法：
class MyThread_1 implements Runnable{	//实现Runnable接口
	private String name;
	
//	public MyThread_1(String name) {	//构造方法
//		super();
//		this.name = name;
//	}
	
	@Override
	public void run() {								//覆写Thread类中的run()方法
		// TODO 自动生成的方法存根
		for (int i=0;i<10;i++){
			//System.out.println(name+"运行，i="+i);
			System.out.println(Thread.currentThread().getName()+",i="+i);	//取出当前线程的名称
			if(i==3){
				System.out.println("线程礼让：");
				Thread.currentThread().yield();	//线程礼让
			}
		}
	}
	
}



//主类
//Function        : 	Thread_demo
public class Runnable_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		MyThread_1 mt1 = new MyThread_1();	//实例化Runnable子类对象
		MyThread_1 mt2 = new MyThread_1();	//实例化Runnable子类对象
		MyThread_1 mt3 = new MyThread_1();	//实例化Runnable子类对象
		Thread t1 = new Thread(mt1,"线程A");							//实例化Thread类对象
		Thread t2 = new Thread(mt2,"线程B");							//实例化Thread类对象
		Thread t3 = new Thread(mt3,"线程C");							//实例化Thread类对象
//		System.out.println("线程开始执行之前-->"+t1.isAlive());
		t1.setPriority(Thread.MIN_PRIORITY);
		t2.setPriority(Thread.NORM_PRIORITY);
		t3.setPriority(Thread.MAX_PRIORITY);
		t1.start();																	//启动线程
//		System.out.println("线程开始执行之前-->"+t1.isAlive());
		t2.start();																	//启动线程
		t3.start();																	//启动线程
		
//		MyThread_1 mt1 = new MyThread_1();	//实例化Runnable子类对象
//		new Thread(mt1).start();								//系统自动设置线程名称
//		new Thread(mt1,"线程A").start();				//手工自动设置线程名称
//		new Thread(mt1,"线程B").start();				//手工自动设置线程名称
//		new Thread(mt1).start();								//系统自动设置线程名称
//		new Thread(mt1).start();								//系统自动设置线程名称
	}

}

 　　　　线程礼让也是不一定的

weixin_33827965
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
深入理解Java多线程编程中的常用方法及应用
微笑听雨
07-25 864
本文将深入探讨Java多线程编程中的常用方法，包括创建和启动线程、线程的休眠和中断、线程间的通信等，详细解析每个方法的用途及其应用场景。同时，我们也将讨论一些过时但历史上曾经广泛使用的方法，帮助读者全面了解Java多线程编程的方方面面。通过这些内容，读者可以更好地编写高效、可靠的多线程程序。
java线程同步操作实例详解
08-27
Java线程同步操作实例详解 Java线程同步操作是指在多线程编程中，为了避免线程之间的数据不一致和混乱，采取的一种机制，以确保线程安全。Java提供了多种方式来实现线程同步，包括synchronized关键字、Lock接口、...
Java 线程操作
Yan__Ran的博客
05-18 812
一、进程与线程 计算机中，把一个任务（浏览器、播放器或是其他）称为进程，而进程的子任务则称为线程 多进程模式（每个进程只有一个线程）： ┌──────────┐ ┌──────────┐ ┌──────────┐ │Process │ │Process │ │Process │ │┌────────┐│ │┌────────┐│ │┌────────┐│ ││ Thread ││ ││ Thread ││ ││ Thread ││ │└────────┘│ │└────────┘│ │
Java线程操作
YIMT的博客
07-27 354
Java线程操作 一、获取线程相关信息 //获取线程信息的相关方法 Thread main = Thread.currentThread(); //线程名字 String name = main.getName(); System.out.println("name:"+name); //获取线程id long id = main.getId(); System.out.print...
java线程操作
cesium的专栏
05-18 9939
java里实现线程主要有两种方式，一种是继承Thread类(位于默认的java.lang包内)，一种是实现Runnadle接口，其中Thread类亦是通过Runnable实现。方式一：     class TestThread extends Thread{       //成员变量（私有）     //构造函数（共有，无返回值）       public void run()
Java中的线程操作
tb1542的博客
10-26 149
文章目录1. 创建和运行线程1.1 使用Thread1.2 使用Runnable1.3 FutureTask配合Thread2. Thread类中常见方法sleep与yieldsleepyield线程优先级守护线程3. 线程的状态3.1 线程的五种状态（操作系统角度）3.2 线程的六种状态（Java API角度） 1. 创建和运行线程 1.1 使用Thread Thread t = new Thread(){ public void run(){ // do something
Java线程同步方法实例总结
08-27
Java线程同步方法实例总结主要介绍了Java线程同步方法，结合实例形式总结分析了Java线程同步、并发控制相关实现方法及操作注意事项。开发者可以根据实际情况选择合适的同步方法，确保程序的正确性和效率。
Java线程组操作实例分析
08-25
本文主要介绍了Java线程组操作的相关知识点，包括ThreadGroup类的作用、Thread类与ThreadGroup类的关系、ThreadGroup类的主要方法等。通过实战示例，演示了如何使用ThreadGroup类创建线程组和管理线程。Java开发者...
Java 控制线程的方法
08-19
Java 控制线程的方法 Java 控制线程的方法是指在 Java 编程语言中控制线程执行的各种方法和技术。 Java 提供了多种方式来控制线程的执行，包括 join() 方法、后台线程（Daemon Thread）等。 join() 方法 Join() ...
Java中断线程的方法
12-22
这里我们将详细讨论如何安全地中断Java线程。 首先，最简单且最安全的线程中断方式是让线程自然执行完毕。当`run()`方法执行完成，线程就会结束。这适用于那些有明确结束点的线程。例如： ```java @Override ...
java 线程 操作_java 线程操作
weixin_42311427的博客
02-22 104
一、线程初始化两种方法：1.将类声明为Thread类的子类，重写Thead的run方法class PrimeThread extends Thread {long minPrime;PrimeThread(long minPrime) {this.minPrime = minPrime;}public void run() {// compute primes larger than minPri...
java 线程 操作_Java线程操作方法
weixin_32479557的博客
02-15 176
取得和设置线程名称//=================================================// File Name :Thread_demo//------------------------------------------------------------------------------// Author :Common// ...
java 操作线程_java线程操作
weixin_29421565的博客
02-22 102
前言进程：内存运行的程序。线程：进程中的一个执行单元。创建多线程的方式本质都是调用自己写的run方法。1继承thread抽象类Thread thread = new Thread(){@Overridepublic void run() {for(int i=0;i<10;i++){System.out.println("线程创建的第一种方式："+Thread.currentThread()...
Java线程基础操作
chiyan4098的博客
07-01 211
进程和线程的概念 进程 比较好理解,打开Windows 的任务管理器进程页里的一个个 exe 就可以理解为一个进程。 线程可以理解是在进程中独立运行的子任务 ，具体见百度百科 https://baike.baidu.com/item/%E7%BA%BF%E7%A8%8B 使用线程 创...
java线程操作_java多线程的操作
weixin_34986860的博客
02-26 164
上篇博客简单了介绍了Java的多线程的概念，与进程的区别，两种创建方式，状态及获取线程名称等内容。这篇文章接着介绍Java的多线程。主要从一下几方面介绍。1 线程类的常用方法1.1 start()启动线程执行run方法1.2Thread.sleep()/sleep(long millis)当前线程睡眠/millis的时间(millis指定睡眠时间是其最小的不执行时间，因为sleep(millis...
Java 多线程操作
wuyouke的专栏
09-10 304
在介绍多线程之前，先介绍并发和并行的区别： 并发：是指在某一段时间内发生多个事件； 并行：是指在同一时刻发生多个事件； 在操作系统中，有多个CPU，可以并发进行多程序的并发执行，而单CPU，只能进行CPU资源的调度，并行执行程序； 进程和线程的区别： 进程：拥有自己独立的内存空间； 线程：最小的CPU调度单位 多线程实现方式： 1）继承于java.lang.Thread 定义类，...
Java 线程常用操作
m0_67698950的博客
05-20 191
线程的常用操作 设置线程名字：setName() 获取线程名称：getName() 线程唯一Id：getId() // 自定义线程名称 String threadName = "threadName"; // 构造方法方式 Thread thread = new Thread(() -> { System.out.println("线程名=" + Thread.currentThread().getName()); },threadName); // set方法方式// thread
Java线程join方法实战与多线程概念详解
在这个"join方法使用示例"的Java代码中，我们探讨了如何利用`Thread`类中的`join()`方法来协调主线程与子线程的执行流程。 `join()`方法是Java中用于线程同步的一种机制，它使得主线程（调用`join()`的线程）会暂停...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值