Thread详解

最新推荐文章于 2024-10-25 16:21:33 发布
最新推荐文章于 2024-10-25 16:21:33 发布
阅读量835 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lyg468088/article/details/41626449
本文介绍了Java中创建线程的多种方式，包括继承Thread类、实现Runnable接口、使用Callable和Future，以及线程的生命周期管理。此外还探讨了如何控制线程执行，如线程的睡眠、让步、优先级调整等。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

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 9719
当我们重写Thread类中的run方法时，经常会看到这样的代码： public void run() { super.run(); System.out.println(Thread.currentThread().getName()); }  这个super() 到底有什么用呢？先看一下 Thread 类中的实现： private...
Fluent 中Domain和thread的个人理解
lanshahewu的博客
02-19 3251
简单理解，Domain的级别要比Thread的级别高。先看这个汇总。
浅谈线程（thread）
superwangxinrui的博客
04-09 353
什么是线程呢？线程和进程又有什么区别和联系呢？   线程是进程的一个执行分支，线程在进程内部运行（指的是线程在进程的虚拟地址空间内运行）。在Linux中，内核看到的线程也是PCB来表示，创建的新PCB和·原PCB共用相同的虚拟地址空间。Linux中用进程来模拟线程，这种线程也称为轻量级进程（LWP），统一了进程和线程的管理。一个进程可以并发多个线程，每个线程并行执行多个任务。线程的存在是为了并发执...
Android应用：霓虹灯
lyg468088的专栏
05-26 584
package com.example.lamp; import java.util.Timer; import java.util.TimerTask; import android.app.Activity; import android.os.Bundle; import android.os.Handler; import android.os.Message; import
膜态沸腾UDF【转载】
asd165654的博客
03-01 1838
膜态沸腾的UDF，添加注释。其中获取VOF梯度的方法详见前面的日志，其中很多宏无法通过UDF手册查阅， 蒸汽相中的质量源项的一般形式为： 式中： 通过一阶近似，热流之差可表达为： 式中： 通过此近似，源项变为： 因为没有内部质量源项，所以也想的质量源项变为： 能源方程的潜热变为： 截面的物性包括，表面张力为0.1N/m，...
手撕Java系列-Thread详解，Thread源码解读，Thread核心方法，Thread安全问题，Thread用到的设计模式
横竖撇折点
10-25 1155
手撕Java系列-Thread详解，Thread源码解读，Thread核心方法，Thread安全问题，Thread用到的设计模式
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）设备和嵌入式系统。它提供了丰富的组件和服务，如线程管理、内存管理、任务调度、...
C# Thread详解
Fortunatever的博客
05-21 4462
一、类Thread的定义 public sealed partial class Thread : CriticalFinalizerObject Thread类只继承了一个抽象类CritiacalFinalizerObject 二、Thread内部的定义的类 1、StartHelper类 1.1、类StartHelper的定义 private sealed class StartHelper 1.2、类StartHelper中的定义的字段 //该线程中允许使用的最大栈深 internal int _m
进程(Process)和线程(Thread)
Forrest He的专栏
09-12 2916
进程(Process)和线程(Thread)1.Process特点(1)进程在执行过程中有内存单元的初始入口点，并且进程存活过程中始终拥有独立的内存地址空间；(2)进程的生存期状态包括创建、就绪、运行、阻塞和死亡等类型；(3)从应用程序进程在执行过程中向CPU发出的运行指令形式不同，可以将进程的状态分为用户态和核心态。处于用户态下的进程执行的是应用程序指令、处于核心态下的应用程序进
【Java并发编程】深入分析Thread(七)
程序员小毛驴的博客
01-28 6319
一、线程    1.1什么是线程？     线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有
Thread类讲解
威威的博客
10-05 2191
详细介绍 Thread 的属性和用法
thread（高级）
东贝鸟的博客
07-08 375
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 =
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
玩转java多线程 之线程创建 （详细）
weixin_45806131的博客
09-23 178
线程创建有三种方式： 第一：继承Thread类（重点） 第二：实现Runnable接口（重点） 第三：实现Callable接口（了解） 代码明天给大家补充完整~
RT-Thread编程高阶用法-函数扩展之$Sub$$与$Super$$
Bruce.yang的嵌入式之旅
06-02 1532
前面移植了RT-Thread Nano，其实准确来说那不叫移植，那叫做部署，因为移植的工作官方已经帮我们做好了。文章链接：小熊派移植RT-Thread Nano1、引发思考-相关资料检索...
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...
C#语法：多线程编程(Thread)
superSmart_Dong的博客
06-02 1152
操作系统为了提高效率将一个进程分成多个线程。有一个主线程其他的都为子线程，在认识多线程前，我们的代码都是在主线程中执行的。都有一个规则就是 必须执行当前代码才会执行之后的代码。那么问题就来了，假如说有一个非常耗时的操作，比如加载数据或文件下载，难不成数据加载完之前，之后的代码以及其他代码都不执行吗?我们用过不少软件，比如迅雷、百度云，在下载文件的时候还可以进行其他操作，程序不会因为当前任务没执行完
高并发编程-Thread_正确关闭线程的三种方式
小工匠
09-22 2万+
文章目录概述 概述 通过阅读源码或者官方的API，可以知道 Thread#stop() 方法已经被废弃了。 大致意思 这种方法本质上是不安全的。 使用Thread.stop停止线程会导致它解锁所有已锁定的监视 如果先前由这些监视器保护的任何对象处于不一致状态，则损坏的对象将对其他线程可见，从而可能导致任意行为。 stop的许多用法应由仅修改某些变量以指示目标线程应停止运行的代码代替。...
c++ std::thread详解
最新发布
07-24
<think>我们根据用户的问题和提供的参考资料，详细讲解C++中std::thread的使用，包括线程创建、管理、同步机制等。 参考资料主要涉及[^1][^2][^3][^4]，我们将结合这些内容进行讲解。 内容大纲： 1. 线程创建：使用函数指针、Lambda、函数对象、成员函数等 2. 线程管理：join和detach 3. 线程同步：互斥锁（std::mutex）和条件变量（std::condition_variable）等 4. 参数传递的注意事项 5. 线程局部存储（thread_local） 6. 异常处理 我们将按照上述结构详细展开，并给出代码示例。</think>### C++ `std::thread` 使用详解：线程创建与管理 C++11 引入的 `<thread>` 头文件提供了强大的多线程支持，其中 `std::thread` 是线程管理的核心类。以下是详细使用指南： --- #### 一、线程创建方式 线程可通过多种可调用对象创建： 1. **函数指针** ```cpp void task(int param) { std::cout << "线程执行: " << param << std::endl; } int main() { std::thread t(task, 42); // 创建线程并传递参数 t.join(); } ``` 2. **Lambda 表达式**（推荐） ```cpp std::thread t([](const std::string& msg) { std::cout << "Lambda线程: " << msg << std::endl; }, "Hello Thread"); ``` 3. **函数对象（Functor）** ```cpp struct Task { void operator()(int x) const { std::cout << "函数对象: " << x*x << std::endl; } }; std::thread t(Task{}, 5); // 传递函数对象实例 ``` 4. **类成员函数** ```cpp class Worker { public: void run(const std::string& data) { std::cout << "成员函数线程: " << data << std::endl; } }; Worker w; std::thread t(&Worker::run, &w, "Data"); // 需传递对象指针[^3] ``` --- #### 二、线程生命周期管理 1. **`join()`**：阻塞当前线程直到目标线程完成 ```cpp std::thread t([]{ /* 任务 */ }); t.join(); // 主线程在此等待 ``` 2. **`detach()`**：分离线程（后台运行，无法再控制） ```cpp std::thread t([]{ /* 长时间任务 */ }); t.detach(); // 主线程继续执行 ``` > ⚠️ 警告：未`join()`或`detach()`的线程析构时会调用`std::terminate()`[^2] 3. **`joinable()`**：检查线程是否可管理 ```cpp if (t.joinable()) { t.join(); // 安全操作 } ``` --- #### 三、线程同步机制 避免数据竞争需使用同步原语： 1. **互斥锁 (`std::mutex`)** ```cpp std::mutex mtx; int counter = 0; void safe_increment() { std::lock_guard<std::mutex> lock(mtx); // RAII自动解锁 ++counter; } ``` 2. **条件变量 (`std::condition_variable`)** 实现线程间通信： ```cpp std::condition_variable cv; std::mutex mtx; bool data_ready = false; // 生产者线程 void producer() { std::lock_guard<std::mutex> lock(mtx); data_ready = true; cv.notify_one(); // 通知消费者 } // 消费者线程 void consumer() { std::unique_lock<std::mutex> lock(mtx); cv.wait(lock, []{ return data_ready; }); // 阻塞直到条件满足 } ``` --- #### 四、参数传递注意事项 1. **默认按值传递**：参数被复制到线程独立内存空间 ```cpp int x = 10; std::thread t([](int a){ a *= 2; }, x); // x值不变 ``` 2. **引用传递需用 `std::ref` 包装** ```cpp int y = 20; std::thread t([](int& b){ b *= 2; }, std::ref(y)); // y变为40 ``` 3. **移动语义优化大对象** ```cpp std::vector<int> big_data(1000); std::thread t([](std::vector<int>&& data){ // 使用移动后的数据 }, std::move(big_data)); // 转移所有权 ``` --- #### 五、线程局部存储 (`thread_local`) 创建线程私有变量： ```cpp thread_local int thread_id = 0; // 每个线程独立副本 void print_id() { std::cout << "线程ID: " << thread_id++ << std::endl; } int main() { std::thread t1(print_id); // 输出0 std::thread t2(print_id); // 输出0（非1） t1.join(); t2.join(); } ``` --- #### 六、异常处理 线程内异常需捕获处理，否则导致程序终止： ```cpp void risky_task() { try { throw std::runtime_error("线程内部错误"); } catch (const std::exception& e) { std::cerr << "捕获异常: " << e.what() << std::endl; } } ``` --- ### 最佳实践 1. 优先使用 RAII 包装器（如 `std::lock_guard`） 2. 避免全局变量，使用参数传递数据 3. 用 `std::async` 替代 `std::thread` 实现任务并行（简化资源管理）[^4] 4. C++20 推荐 `std::jthread`（自动管理生命周期） ```cpp // std::async 示例 auto future = std::async(std::launch::async, []{ return std::sqrt(2.0); // 异步计算 }); double result = future.get(); // 获取结果 ``` --- ### 相关问题 1. 如何实现线程池以提高大量小任务的性能？ 2. `std::atomic` 在无锁编程中如何应用？ 3. 多线程调试有哪些常用工具和技巧？ 4. C++20 协程如何简化异步编程模型？ > 源码示例在 GCC/Clang 需编译选项：`-std=c++11 -pthread` > MSVC 需启用：`/std:c++latest /EHsc` [^1]: 线程创建方式与参数传递机制 [^2]: 线程生命周期管理关键点 [^3]: 类成员函数线程化实现 [^4]: 高级异步任务处理方案
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值