Thread详解

最新推荐文章于 2022-10-05 07:23:16 发布
最新推荐文章于 2022-10-05 07:23:16 发布
阅读量788 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lyg468088/article/details/41626449
版权

1.继承THread类创建线程类

<span style="font-family:Times New Roman;font-size:18px;">package com.simplethread.test;
public class FirstThread extends Thread{
	private int i;
	//重写run()方法，run()方法体就是线程执行体
	public void run()
	{
		for(;i<10;i++)
		{
			//当线程继承Thread类时，直接使用this即可获取当前线程
			//Thread对象的getName()返回当前线程的名字
			//因此可以直接调用getName()方法返回当前线程的名字
			System.out.println(getName()+" "+i);
		}
	}
	public static void main(String[] args) {
		for(int i=0;i<5;i++)
		{
			//调用Thread的currentThread()方法获取当前线程
			System.out.println(Thread.currentThread().getName()+" "+i);
			if(i==2)
			{
				//创建并启动第一个线程
				new FirstThread().start();
				//创建并启动第二个线程
				new FirstThread().start();
			}			
		}
	}
}
</span>
2.实现Ruunable接口创建线程类 

package com.simplethread.test;
public class SecondThread implements Runnable{
	private int i;
	//run()方法同样是线程执行体
	public void run()
	{
		for(;i<10;i++)
		{
			//当线程类实现Runnable接口时
			//如果想获取当前线程，只能用Thread.currentThread()方法
			System.out.println(Thread.currentThread().getName()					+" "+i);
		}
	}
	public static void main(String[] args) {
		for(int i=0;i<5;i++)
		{
			System.out.println(Thread.currentThread().getName()
					+" "+i);
			if(i==2)
			{
				SecondThread st=new SecondThread();
				//通过new Thread(target,name)方法创建新线程
				new Thread(st,"新线程1").start();
				new Thread(st,"新线程2").start();
			}
		}
	}
}

3.使用Callable和Future创建线程 

package com.simplethread.test;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class ThirdThread {
	public static void main(String[] args) {		
		//先创建Callable对象
		ThirdThread rt=new ThirdThread();
		FutureTask<Integer> task=new FutureTask<Integer>( 
				new Callable<Integer>() {  
            public Integer call() { 
            	int i=0;
            	for(;i<10;i++)
            	{
            		System.out.println(Thread.currentThread().getName()
            				+"的循环变量i的值："+i);
            	}
                return i;  
            }  
        });
		for(int i=0;i<10;i++)
		{
			System.out.println(Thread.currentThread().getName()
					+"的循环变量i的值："+i);
			if(i==3)
			{
				//实质还是以Callable对象来创建并启动线程
				new Thread(task,"有返回值的线程").start();
			}
		}
		try
		{
			//获取线程返回值
			System.out.println("子线程返回值："+task.get());
		}
		catch(Exception ex)
		{
			ex.printStackTrace();
		}
	}
}
4.线程的生命周期 

package com.simplethread.test;
public class InvokeRun extends Thread{
	private int i;
	//重写run()方法，run()方法的方法体就是线程执行体
	public void run()
	{
		for(;i<10;i++)
		{
			//直接调用run()方法时，Tread的this.getName()返回的是该对象的名字
			//而不是当前线程的名字
			//使用Thread.currentThread().getName()总是获取当前线程的名字
			System.out.println(Thread.currentThread().getName()+" "+i);
		}
	}
	public static void main(String[] args) throws InterruptedException {
		for(int i=0;i<10;i++)
		{
			//调用Thread的currentThread()方法获取当前线程
			System.out.println(Thread.currentThread().getName()+" "+i);
			if(i==5)
			{
				//直接调用线程的run()方法
				//系统会把线程对象当成普通对象，把run()方法当成普通方法
				//所以下面两行代码并不会启动两个线程，而是依次执行两个run()方法
				new InvokeRun().run();
				new InvokeRun().run();
			}
		}
	}
}
5.线程死亡 

package com.simplethread.test;
public class StartedDeadThread extends Thread{
	private int i;
	//重写run()方法，run()方法的方法体就是线程执行体
	public void run()
	{
		for(;i<10;i++)
		{
			System.out.println(getName()+" "+i);
		}
	}
	public static void main(String[] args) {
		//创建线程对象
		StartedDeadThread sd=new StartedDeadThread();
		for(int i=0;i<10;i++)
		{
			//调用Threade的currentThread()方法获取当前线程
			System.out.println(Thread.currentThread().getName()
					+" "+i);
			if(i==5)
			{
				//启动线程
				sd.start();
				//判断启动后台线程的isAlive()值，输出true
				System.out.println(sd.isAlive());
			}
			//当线程处于新建、死亡两种状态时，isAlive()方法返回false
			//当i>5时，该线程肯定已经启动过了，如果sd.isAlive()为假时
			//那就是死亡状态了
			if(i>5&&(sd.isAlive()))
			{
				//试图再次启动线程
				sd.start();
			}
		}
	}
}

6.控制线程

Join线程：

package com.simplethread.test;
public class JoinThread extends Thread{
	//提供一个有参数的构造器，用于设置该线程的名字
	public JoinThread(String name)
	{
		super(name);
	}
	//重写run()方法，定义线程执行体
	public void run()
	{
		for(int i=0;i<10;i++)
		{
			System.out.println(getName()+" "+i);			
		}
	}
	public static void main(String[] args) throws InterruptedException {
			//启动子线程
		new JoinThread("新线程").start();
		for(int i=0;i<10;i++)
		{
			if(i==2)
			{
				JoinThread jt=new JoinThread("被Join的线程：");
				jt.start();
				//main线程调用了jt线程的join()方法，main线程
				//必须等jt执行结束后向下执行
				jt.join();
			}
			System.out.println(Thread.currentThread().getName()+" "+i);
		}
	}
}
7.后台线程 

package com.simplethread.test;
public class DaemonThread extends Thread{
	//定义后台线程的线程执行体与普通线程没有任何区别
	public void run()
	{
		for(int i=0;i<10;i++)
		{
			System.out.println(getName()+" "+i);
		}
	}
	public static void main(String[] args) {
		DaemonThread t=new DaemonThread();
		//将此线程设置成后台线程
		t.setDaemon(true);
		t.start();
		//启动后台线程
		for(int i=0;i<5;i++)
		{
			System.out.println(Thread.currentThread().getName()+" "+i);
		}
		//------程序执行到此处，前台线程(main线程)结束-------
		//后台线程也应该随之结束
	}
}

8.线程睡眠：sleep 

package com.simplethread.test;
import java.util.Date;
public class SleepTest {
	public static void main(String[] args) throws InterruptedException {
		for(int i=0;i<10;i++)
		{
			System.out.println("当前时间："+new Date());
			//调用Sleep()方法让当前线程暂停1s
			Thread.sleep(2000);
		}

	}

}

9.线程让步：yield 

package com.simplethread.test;
public class YieldTest extends Thread{
		public YieldTest(String name)
		{
			super(name);
		}
		//定义run()方法作为线程执行体
		public void run()
		{
			for(int i=0;i<10;i++)
			{
				System.out.println(getName()+" "+i);
				//当i=5时，使用yield()方法让当前线程让步
				if(i==5)
				{
					Thread.yield();
				}
			}
		}
	public static void main(String[] args) {
		//启动两个并发线程
		YieldTest yt1=new YieldTest("高级");
		//将yt1设置成最高优先级
		yt1.setPriority(Thread.MAX_PRIORITY);
		yt1.start();
		YieldTest yt2=new YieldTest("低级");
		//将yt2设置成最高优先级
		yt2.setPriority(Thread.MIN_PRIORITY);
		yt2.start();
	}
}

10.改变线程优先级 

package com.simplethread.test;
public class PriorityTest extends Thread{
	//定义一个有参数的构造器，用于创建线程指定时指定name
	public PriorityTest(String name)
	{
		super(name);
	}
	public void run()
	{
		for(int i=0;i<10;i++)
		{
			System.out.println(getName()+",其优先级是： "
		+getPriority()+",循环变量的值为："+i);
		}
	}
	public static void main(String[] args) {
		//改变线程的优先级
		Thread.currentThread().setPriority(6);
		for(int i=0;i<20;i++)
		{
			if(i==10)
			{
				PriorityTest low=new PriorityTest("低级");
				low.start();
				System.out.println("创建之初的优先级："+
				low.getPriority());
				//设置改线程为最低优先级
				low.setPriority(Thread.MIN_PRIORITY);
			}
			if(i==15)
			{
				PriorityTest high=new PriorityTest("高级");
				high.start();
				System.out.println("创建之初的优先级："+
				high.getPriority());
				//设置该线程为最高优先级
				high.setPriority(Thread.MAX_PRIORITY);
			}
		}
	}
}










































雅然风懿
关注
专栏目录
自定义Thread类中run()方法，super().run 的理解
yif01的博客
09-21 9511
当我们重写Thread类中的run方法时，经常会看到这样的代码： public void run() { super.run(); System.out.println(Thread.currentThread().getName()); }  这个super() 到底有什么用呢？先看一下 Thread 类中的实现： private...
Fluent 中Domain和thread的个人理解
最新发布
lanshahewu的博客
02-19 2259
简单理解，Domain的级别要比Thread的级别高。先看这个汇总。
浅谈线程（thread）
superwangxinrui的博客
04-09 314
什么是线程呢？线程和进程又有什么区别和联系呢？   线程是进程的一个执行分支，线程在进程内部运行（指的是线程在进程的虚拟地址空间内运行）。在Linux中，内核看到的线程也是PCB来表示，创建的新PCB和·原PCB共用相同的虚拟地址空间。Linux中用进程来模拟线程，这种线程也称为轻量级进程（LWP），统一了进程和线程的管理。一个进程可以并发多个线程，每个线程并行执行多个任务。线程的存在是为了并发执...
膜态沸腾UDF【转载】
asd165654的博客
03-01 1634
膜态沸腾的UDF，添加注释。其中获取VOF梯度的方法详见前面的日志，其中很多宏无法通过UDF手册查阅， 蒸汽相中的质量源项的一般形式为： 式中： 通过一阶近似，热流之差可表达为： 式中： 通过此近似，源项变为： 因为没有内部质量源项，所以也想的质量源项变为： 能源方程的潜热变为： 截面的物性包括，表面张力为0.1N/m，...
进程(Process)和线程(Thread)
Forrest He的专栏
09-12 2780
进程(Process)和线程(Thread)1.Process特点(1)进程在执行过程中有内存单元的初始入口点，并且进程存活过程中始终拥有独立的内存地址空间；(2)进程的生存期状态包括创建、就绪、运行、阻塞和死亡等类型；(3)从应用程序进程在执行过程中向CPU发出的运行指令形式不同，可以将进程的状态分为用户态和核心态。处于用户态下的进程执行的是应用程序指令、处于核心态下的应用程序进
C++11 并发指南之std::thread 详解
08-25
"C++11 并发指南之std::thread 详解" 本文主要介绍了 C++11 中的 std::thread 类，它是 C++11 并发指南的重要组件。std::thread 类提供了创建和管理线程的功能，允许开发者在程序中创建多个线程，从而实现并发编程...
rtthread详解
07-28
**rtthread详解** RTThread（Real-Time Thread）是一款开源、小巧、高效且功能强大的实时操作系统（RTOS），适用于物联网（IoT）设备和嵌入式系统。它提供了丰富的组件和服务，如线程管理、内存管理、任务调度、...
Java并发编程（一）Thread详解
syh121的博客
09-09 1195
一、概述 在开始学习Thread之前，我们先来了解一下 线程和进程之间的关系： 线程(Thread)是进程的一个实体，是CPU调度和分派的基本单位。 线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。 线程和进程的关系是：线程是属于进程的，线程运行在进程空间内，同一进程所产生的线程共享同一内存空间，当进程退出时该进程所产生的线程都会被强制退出并清除。 由上描述，可以得知线程作为cpu的基本调度单位，只有把多线程用好，才能充分利用cpu的多核资源。 本文基于JDK 8（也可
【Java并发编程】深入分析Thread(七)
程序员小毛驴的博客
01-28 6206
一、线程    1.1什么是线程？     线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有
Thread类讲解
威威的博客
10-05 1935
详细介绍 Thread 的属性和用法
thread（高级）
东贝鸟的博客
07-08 343
import threading import requests # def get_url(url): # user_age = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36" # head = { # 'User-Agent': user_age # } # req =
Thread类的几种常用方法
emmmsuperdan的博客
08-27 2万+
1.start（开启线程，start是通过线程来调用run方法） 2.run 此run非彼run （不是在run方法实现线程的逻辑，而是thread.run()，这个run方法是直接调用了线程中的run） 3.yield（暂停当前线程，并执行其他线程） 4.sleep（使当前线程由运行状态变成阻塞状态，若睡眠时其他线程调用了interrupt方法，会导致sleep抛出异常Interrup...
python：threading.Thread类的使用详解
热门推荐
夜夜夜夜
03-09 8万+
Python Thread类表示在单独的控制线程中运行的活动。有两种方法可以指定这种活动： 1、给构造函数传递回调对象mthread=threading.Thread(target=xxxx,args=(xxxx)) mthread.start()2、在子类中重写run() 方法 这里举个小例子：import threading, time class MyThread(threading.Th
RT-Thread编程高阶用法-函数扩展之$Sub$$与$Super$$
Bruce.yang的嵌入式之旅
06-02 1397
前面移植了RT-Thread Nano，其实准确来说那不叫移植，那叫做部署，因为移植的工作官方已经帮我们做好了。文章链接：小熊派移植RT-Thread Nano1、引发思考-相关资料检索...
玩转java多线程 之线程创建 （详细）
weixin_45806131的博客
09-23 139
线程创建有三种方式： 第一：继承Thread类（重点） 第二：实现Runnable接口（重点） 第三：实现Callable接口（了解） 代码明天给大家补充完整~
C#语法：多线程编程(Thread)
superSmart_Dong的博客
06-02 1079
操作系统为了提高效率将一个进程分成多个线程。有一个主线程其他的都为子线程，在认识多线程前，我们的代码都是在主线程中执行的。都有一个规则就是 必须执行当前代码才会执行之后的代码。那么问题就来了，假如说有一个非常耗时的操作，比如加载数据或文件下载，难不成数据加载完之前，之后的代码以及其他代码都不执行吗?我们用过不少软件，比如迅雷、百度云，在下载文件的时候还可以进行其他操作，程序不会因为当前任务没执行完
高并发编程-Thread_正确关闭线程的三种方式
小工匠
09-22 1万+
文章目录概述 概述 通过阅读源码或者官方的API，可以知道 Thread#stop() 方法已经被废弃了。 大致意思 这种方法本质上是不安全的。 使用Thread.stop停止线程会导致它解锁所有已锁定的监视 如果先前由这些监视器保护的任何对象处于不一致状态，则损坏的对象将对其他线程可见，从而可能导致任意行为。 stop的许多用法应由仅修改某些变量以指示目标线程应停止运行的代码代替。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值