Java——多线程、线程池

最新推荐文章于 2025-08-22 13:45:39 发布

大大大Ni

最新推荐文章于 2025-08-22 13:45:39 发布

阅读量199

点赞数

CC 4.0 BY-SA版权

分类专栏：小白学Java 文章标签： java

本文链接：https://blog.csdn.net/qq_53861505/article/details/129599028

小白学Java 专栏收录该内容

19 篇文章

订阅专栏

本文详细介绍了进程和线程的概念，以及单进程和多进程操作系统的区别。接着阐述了线程作为进程内的执行路径，以及线程与进程的关系。在Java中，通过继承Thread类或实现Runnable接口创建多线程应用程序，并展示了使用线程池的方式。此外，还提到了线程的优先级设定、线程命名、线程休眠、线程礼让、线程合并、线程中断以及守护线程的使用方法，提供了具体的代码示例。

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

多线程

一、什么是进程

进程是系统进行资源分配和调用的独立单元，每一个进程都有它的独立内存空间和系统资源。

二、单进程操作系统和多进程操作系统的区别

单进程操作系统：dos（一瞬间只能执行一个任务）

多进程单用户操作系统：Windows（一瞬间只能执行多个任务）

多进程多用户操作系统：Linux（一瞬间只能执行多个任务）

三、什么是线程，理解线程和进程的关系

1.什么是线程

线程是进程里面的一条执行路径，每个线程同享进程里面的内存空间和系统资源

一个进程可以有多个线程：各个线程都有不同的分工

2.理解线程和进程的关系

进程与进程之间的关系：进程之间的内存空间和系统资源是独立的

同一个进程里的多条线程：线程之间的内存空间和系统资源是共享的

进程里：可以有一条或一条以上的线程

进程里只有一条线程的情况下，这条线程就叫做主线程

进程里有多条线程的情况下，只有一条线程叫做主线程

Ps：线程是在进程里的，他们是包含关系

四、Java中，如何来编写多线程的应用程序、有哪些方法？

1.线程类

创建MyThread类，继承Thread，重写run方法

public class Test {
	
	public static void main(String[] args) {
		
		//创建线程的对象
		MyThread t = new MyThread();
		//启动线程
		t.start();
	}
}
//线程类
class MyThread extends Thread{
	
	//当前线程抢到cpu资源后，就会执行run方法
	@Override
	public void run() {
		System.out.println("当前线程抢到资源了");
	}
}

2.任务类

创建Task类，实现Runnable接口中的run方法

public class Test {
	
	public static void main(String[] args) {
		
		Thread t = new Thread(new Task());
		t.start();
	}
}
//任务类
class Task implements Runnable{

	//当前线程抢到cpu资源后，就会执行run方法
	@Override
	public void run() {
		System.out.println("抢到资源了");
	}
}

3.带返回值的任务类

创建Task任务类，实现Callable接口中的call方法

submit()方法提交Callable任务获取一个Future实例

Futrue实例调用get()方法即可获取Callable任务返回值。

import java.util.concurrent.Callable;
public class Task implements Callable<?>{
    //? -- 代表返回值的类型
    @Override
    public ? call(){
        
        return ?类型的返回值;
    }
}

eg: 计算一个包含了两万个整数的数组，分多个线程来进行计算，最后汇总计算出的结果

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test01 {
	
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//创建2万个整数的数组
		int[] number = new int[20000];
		
		//初始化数组 -- 数组包含从1-20000的整数
		for(int i =0;i<number.length;i++) {
			number[i] = i+1;
		}
		
		//创建自定义线程池
		ThreadPoolExecutor pool = new ThreadPoolExecutor(
				4,//线程池中常驻核心线程数
				4,//线程池能够容纳同时执行的最大线程数
				0,//多余的空闲线程存活时间
				TimeUnit.MILLISECONDS,//时间单位
				new ArrayBlockingQueue<>(10)//任务队列，被提交但尚未执行的任务
				
				);
		
		
		//创建任务
		Task task1 = new Task(0, 5000, number);//第一个线程任务计算0~5000的整数和
		Task task2 = new Task(5000, 10000, number);//第二个线程任务计算5000~10000的整数和
		Task task3 = new Task(10000, 15000, number);//第三个线程任务计算10000~15000的整数和
		Task task4 = new Task(15000, 20000, number);//第四个线程任务计算15000~20000的整数和
		 
		//提交任务
     //submit()方法提交Callable任务获取一个Future实例
		Future<Integer> f1 = pool.submit(task1);
		Future<Integer> f2 = pool.submit(task2);
		Future<Integer> f3 = pool.submit(task3);
		Future<Integer> f4 = pool.submit(task4);
		
		//合并运算结果
     //Futrue实例调用get()方法即可获取Callable任务返回值
		int result = f1.get() + f2.get()+f3.get()+f4.get();
		System.out.println("运行结果为："+result);
        
		pool.shutdown(); //关闭线程池
	}
	
}
class Task implements Callable<Integer>{

	private int startIndex;
	private int endIndex;
	private int[] number;
	
	public Task(int startIndex, int endIndex, int[] number) {	
		this.startIndex = startIndex;
		this.endIndex = endIndex;
		this.number = number;
	}

	@Override
	public Integer call() throws Exception {
		int sum = 0;
		for(int i =startIndex;i<endIndex;i++) {
			sum+=number[i];
		}
		return sum;
	}	
}

系统计算输出结果：
 运行结果为：200010000

4.线程池

含义：存放线程的容器 – 事先创建若干个可执行的线程放入一个池（容器）中，需要的时候从池中直接获取线程，使用完毕后放回池中，不用进行销毁，从而减少了创建和销毁线程对象的开销。、

优点：降低资源消耗，提高响应速度，方便管理；线程可以复用，可以控制最大并发数，可以管理线程。

JDK1.8开始Java提供了一些线程池 – 工作中不会使用Java自带的线程池（因为存在bug），所以都是使用自定义线程池。

4.1 Java自带线程池

//创建单个线程的线程池
ExecutorService pool = Executors.newSingleThreadExecutor();

//提交任务
pool.execute(task);

//创建指定个数的线程的线程池
ExecutorService pool = Executors.newFixedThreadPool(3);

//提交任务
pool.execute(task);

//创建可缓存线程的线程池(闲置时间60s，60s没有工作的线程就销毁掉)
ExecutorService pool = Executors.newCachedThreadPool();

//提交任务
pool.execute(task);

//创建可提交定时任务的线程池
ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);//3 -- 表示3个线程的线程池

//定时提交任务
pool.schedule(task, 5, TimeUnit.SECONDS);//在五秒后提交task任务
//task--要提交的任务
//5 -- 时间
//TimeUnit.SECONDS -- 时间单位

4.2 自定义线程池

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test {
	public static void main(String[] args) {
		
		//自定义线程池
		ThreadPoolExecutor pool = new ThreadPoolExecutor(
				5, //核心线程数 -- 不能被回收
				20,//最大线程数
				60,//闲置时间
				TimeUnit.SECONDS,//时间单位
				new ArrayBlockingQueue<>(50),//有界队列 -- 任务队列
				new ThreadFactory() {//自定义线程工厂
					private int num = 1;
					@Override
					public Thread newThread(Runnable r) {
						Thread thread = new Thread(r);
						thread.setName("自定义线程池中的线程" + num);//自定义线程名
						thread.setPriority(Thread.MAX_PRIORITY);//定义优先级
						num++;
						return thread;
					}
				}, 
				new RejectedExecutionHandler() {//自定义拒绝策略
					@Override
					public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
						System.out.println(r + "被拒绝了~~~");
					}
				});
		
		//注意：
		//1.60秒闲置时间只能回收普通线程
		//2.核心线程和普通线程没有区别，都是线程，只不过是回不回收的问题
		
		//设置了该方法，60秒闲置时间后可以回收核心线程
		//大概率不会调用该方法 -- 因为如果回收了核心线程，线程池就没有线程复用率这么一说
		pool.allowCoreThreadTimeOut(true);
		
		for (int i = 1; i <= 1000; i++) {
			Task task = new Task(i);
			
			//提交任务
			//pool.execute(task);
			
			//提交任务 - 返回Future<?>，带有返回值的任务类的返回值就发在Future对象中
			pool.submit(task);
			
		}		
		pool.shutdown();//关闭线程		
	}
}
//任务类线程
class Task implements Runnable{
	
	private int num;
	
	public Task(int num) {
		this.num = num;
	}

	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"执行了第"+ num + "个任务。");
	}	
}

运行结果.jpg:

在这里插入图片描述

五、线程的优先级

a.setPriority(Thread.MAX_PRIORITY);//10 最高
b.setPriority(Thread.NORM_PRIORITY);//5	中等
c.setPriority(Thread.MIN_PRIORITY);//1 	最低

六、给线程自定义名称

第一种：

创建一个线程类MyThread，继承Thread

//测试类
public class Test {
	public static void main(String[] args) {
		//创建线程类对象，并传入线程名为 A
		MyThread a = new MyThread("A");
		//启动线程
		a.start();
	}

}


//MyThread线程类
class MyThread extends Thread{
   //自定义私有属性线程名
	private String threadName;
   //有参构造传入线程名
	public MyThread(String name) {
		this.threadName = name;	
	
	}
   //重写run方法
	@Override
	public void run() {
		for (int i = 1; i <=100; i++) {
			//循环打印100次线程名+i
			System.out.println(threadName+ ":"+i);
		}
	}

}

第二种：

//测试类
public class Test {
	public static void main(String[] args) {
		//创建线程类对象，并传入线程名为 A
		MyThread a = new MyThread("A");
		//启动线程
		a.start();
	}

}
//线程类MyThread
class MyThread extends Thread{
    //有参构造传入线程名
	public MyThread(String name) {
		super(name);		
	}
	@Override
	public void run() {
		for (int i = 1; i <=100; i++) {
           //返回当前正在执行的线程对象的引用
			Thread thread = Thread.currentThread();
           //通过thread.getName()获取线程的名字
			System.out.println(thread.getName()+ ":"+i);
		}
	}
}

七、线程休眠

使用方法：sleep()

需求：编写一个随机点名的程序，要求倒数三秒后输出被点中的名字

import java.util.Random;
public class Test {
	public static void main(String[] args) throws InterruptedException {
		
		String[] name = {"小鲁班","蔡文姬","李元芳","瑶","阿离","兰陵王"};
		
		//利用随机数随机生成一个0~6的整数做为索引去匹配name数组中的名字完成点名
        Random random = new Random();
		int index = random.nextInt(name.length);
		for (int i = 3; i >0; i--) {
			System.out.println(i);
         
         //线程休眠。此方法为静态方法，写在哪个线程中，哪个线程就休眠
			Thread.sleep(1000);//休眠1秒钟
		}
		System.out.println(name[index]);
		
	}

}

八、线程的礼让

线程礼让：指的是让当前线程退出CPU资源，马上进入到抢资源的状态

使用方法：yield()

需求：创建两个线程A,B，分别各打印1-100的数字，其中B一个线程，每打印一次，就礼让一次

线程A:

public class A extends Thread{
	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println("A：" + i);
		}
	}
}

线程B:

public class B extends Thread{

	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println("B：" + i);
			
			//礼让：让当前线程退出CPU资源，马上进入到抢资源的状态
			Thread.yield();
		}
	}
}

测试类：

public class Test {
	public static void main(String[] args) throws InterruptedException {	
		A a = new A();
		B b = new B();
		
		a.start();
		b.start();
		
	}
}

九、线程的合并

使用方法：join()

需求：主线程和子线程各打印200次，从1开始每次增加1，当主线程打印到10之后，让子线程先打印完再打印主线程

创建子线程MyThread类

public class MyThread extends Thread{
	
	@Override
	public void run() {
		for (int i = 1; i <= 200; i++) {
			System.out.println("子线程：" + i);
		}
	}
}

创建主线程测试类

public class Test01 {
	public static void main(String[] args) throws InterruptedException {
		
		MyThread t = new MyThread();
		t.start();
		
		for (int i = 1; i <= 200; i++) {
			System.out.println("主线程：" + i);
			if(i == 10){
				//让子线程加入当前线程中
				t.join();
			}
		}
		
	}
}

十、线程的中断

使用方法：

stop() – 立即停止当前线程

该方法已经过时，使用该方法会直接中断当前线程，当线程中存在循环时，可能导致循环进行到一半直接停止。

需求：循环打印1234，并在3秒后停止打印

测试类：

public class Test {
	public static void main(String[] args) throws InterruptedException {
		
		MyThread t = new MyThread();
		t.start();
		
		Thread.sleep(3000);

		//终止子线程(立即停止)
		t.stop();
		
	}
	
}

MyThread线程类：

public class MyThread extends Thread{

	@Override
	public void run() {
		while(true){
			System.out.println("1");
			System.out.println("2");
			System.out.println("3");
			System.out.println("4");
		}
	}
}

interrupt() – 中断当前线程

使用该方法中断线程时，会继续

isInterrupted() – 用于判断线程是否中断

测试类：

public class Test {
	public static void main(String[] args) throws InterruptedException {
		
		MyThread t = new MyThread();
		t.start();
		
		Thread.sleep(3000);
       
		//中断这个线程
		t.interrupt();
	}
	
}

MyThread线程类：

public class MyThread extends Thread{

	@Override
	public void run() {
		//Thread.currentThread().isInterrupted() -- 判断当前线程是否死亡
		//true - 死亡 
		//false - 没死
		
		while(!Thread.currentThread().isInterrupted()){
			
			System.out.println("1");
			System.out.println("2");
			System.out.println("3");
			System.out.println("4");
		}
	}
}

十一、线程守护

方法：setDaemon(true) – true 开启守护线程 – false – 关闭守护线程

守护线程默默守护着前台线程，当所有的前台线程都消亡后，守护线程会自动消亡

注：垃圾回收器就是守护线程

创建测试类：

public class Test {
	public static void main(String[] args) throws InterruptedException {
		
		MyThread t = new MyThread();
		t.setDaemon(true);//设置当前线程为守护线程
		t.start();
		
		for (int i = 1; i <= 5; i++) {
			System.out.println("主线程：" + i);
			Thread.sleep(1000);
		}
		
	}
}

class MyThread extends Thread{
	@Override
	public void run() {
		while(true){
			System.out.println("守护线程默默守护着前台线程");
			try {
				//注意：子类中重写的父类的run方法，父类的run方法没有抛异常，子类重写时也不能抛异常
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

public class Test {
	public static void main(String[] args) throws InterruptedException {
		
		MyThread t = new MyThread();
		t.setDaemon(true);//设置当前线程为守护线程
		t.start();
		
		for (int i = 1; i <= 5; i++) {
			System.out.println("主线程：" + i);
			Thread.sleep(1000);
		}
		
	}
}

class MyThread extends Thread{
	@Override
	public void run() {
		while(true){
			System.out.println("守护线程默默守护着前台线程");
			try {
				//注意：子类中重写的父类的run方法，父类的run方法没有抛异常，子类重写时也不能抛异常
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}