线程的创建方式

已于 2023-07-16 21:06:52 修改
阅读量350 收藏
点赞数 11
文章标签： jvm
于 2023-07-16 20:54:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62226624/article/details/131753956
版权

目录

一、线程与进程的区别

二、线程

三、线程的创建方式

1. 继承java.lang.Thread类创建

2.实现java.lang.Runnable接口创建

3.实现 java.util.concurrent.Callable接口创建

4.通过线程池创建

一、线程与进程的区别

        进程（Process）是程序的一次执行过程，是系统运行程序的基本单位。操作系统运行一个程序，即是一个进程从创建、运行到消亡的过程。

        线程（Thread）是进程划分的更小的运行单位，是进程内部的子任务。

        两者关系：一个进程可以包含一个或多个线程，但至少会有一个主线程。

        

线程与进程的区别
比较方面进程线程

根本

区别

进程是操作系统资源分配的基本单位线程是处理器任务调度和执行的基本单位

资源

开销

（1）每个进程都有独立的代码副本和数据空间；

（2）进程之间的切换，资源开销大

（1）每个线程都有自己独立的运行栈和程序计数器；

（2）线程之间的切换，资源开销小

包含

关系

包含被包含（线程的执行是并行的）

内存

分配

进程之间的资源和内存空间相互独立同一进程内的所有线程共享本进程的内存空间和资源

影响

关系

一个进程崩溃后，在保护模式下不会对其他进程产生影响一个线程崩溃，会导致整个进程退出（多进程比多线程健壮）

执行

过程

每个独立的进程有程序运行的入口和出口线程不能独立执行，必须依赖在应用程序（进程）中，由应用程序提供多个执行控制

二、线程

        线程是CPU的最小执行单位，线程也有单线程和多线程之分。

       1. 单线程

        单线程是进程中只有一个线程，单线程在程序执行时，所走的程序路径按照连续顺序排下来，前面的线程必须处理好，后面的才会执行。

        2.多线程

        由一个以上的线程组成的程序称为多线程程序。Java中，所有的执行都是从主线程（main方法）开始执行，然后在主线程的某个位置创建并启动新的线程。

三、线程的创建方式

1. 继承java.lang.Thread类创建

  Thread的子类SubThread：

//Thread的子类SubThread
class SubThread extends Thread{
	
	int random=(int)(Math.random()*1000);
	@Override
	public void run() {
		System.out.println("【子线程】开始执行");
		try {
			Thread.sleep(random);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		// TODO Auto-generated method stub
		System.out.println("【子线程】结束执行，休眠；"+random+"毫秒");
	}
	
	 
}

  主线程main方法：

public class ThreadDemo1{
	public static void main(String[] args) throws InterruptedException {
		//主线程开始
		System.out.println("【主线程】开始执行！即将创建子线程！");
		
		//创建并启动子线程
		SubThread sub=new SubThread();
		sub.start();
		
		//主线程结束
		System.out.println("【主线程】当子线程sub执行结束后，主线程main结束执行!");
	}
}

 

        主线程和子线程的结束是随机的，但可以通过join（）方法来实现插队操作，让子线程每次都执行完在主线程结束。

//主线程调用sub中的join()方法
		sub.join();//子线程插队，插入到当前线程的main的执行序列前

 

2.实现java.lang.Runnable接口创建

  抽象父类Task：

//父类任务
abstract class Task{
	abstract void execute();
}

  子类EmailTask：

//子类任务
class EmailTask extends Task implements Runnable{

	@Override
	void execute() {
		Thread currentThread=Thread.currentThread();
		String name=currentThread.getName();
		System.out.printf("邮件对象%s正在被执行，启动smtp服务器！\n",name);
		
	}

	@Override
	public void run() {
		execute();
		
	}	
	
	
}

 测试类ThreadDemo2：

public class ThreadDemo2 {
	
	public static void main(String[] args) {
		//每个Runnable接口的实现类，封装了线程执行的逻辑
		EmailTask emailTask=new EmailTask();
		
		//线程的创建还是只能通过new关键字实现 
		Thread t1=new Thread(emailTask,"【线程戊】");
		Thread t2=new Thread(emailTask,"【线程戌】");
		Thread t3=new Thread(emailTask,"【线程卯】");
		
		t1.start();
		t2.start();
		t3.start();
	}
}

        创建的3个线程共同竞争CPU的资源分配，每次执行的概率是随机的。

3.实现 java.util.concurrent.Callable接口创建

 Callable的实现类SumCallTask：

class SumCallTask implements Callable<Integer>{
	//私有成员变量
	private int begin,end;
	
	public SumCallTask(int begin,int end) {
		this.begin=begin;
		this.end=end;
		
	}
	
	
	@Override
	public Integer call() throws Exception {//实现不同数据范围的计算任务
		int tol=0;
		for(int i=begin;i<=end;i++) {//内部实现逻辑
			tol+=i;
		}
		System.out.println(Thread.currentThread().getName());
		return tol;
	}
	
}

        查阅Thread源码你会发现，Threa的有参构造方法中没有与Callable实现类有关的构造方法，而SumCallTask的功能是实现指定范围内的计算任务的，是需要有返回值的。

        Callable接口的实现类并不能直接与Thread线程建立联系，此时我们需要了解一个类FutureTask<V>：

         FutureTask实现了RunnableFuture接口，而RunnableFuture接口有继承自Runnable接口，等同于间接的FutureTask实现了Runnable接口。

 

         而且FutureTask内部定义了get方法，用于获取当前任务的返回值。刚好，适用于需要得到返回值的功能。

 测试类FutureTaskDemo：

public class FutureTaskDemo {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//SumCallTask实现Callable接口，实现不同数据范围的计算任务
		SumCallTask sct1=new SumCallTask(1, 300);
		SumCallTask sct2=new SumCallTask(301, 600);
		SumCallTask sct3=new SumCallTask(601, 1000);
		
		//创建FutureTask(Runnable接口实现类)
		//通过FutureTask类型的对象来建立与线程之间的关系
		//Callable ---> FutureTask
		FutureTask<Integer> ftask1=new FutureTask<Integer>(sct1);
		FutureTask<Integer> ftask2=new FutureTask<Integer>(sct2);
		FutureTask<Integer> ftask3=new FutureTask<Integer>(sct3);
		
		//创建线程
		Thread t1=new Thread(ftask1);
		Thread t2=new Thread(ftask2);
		Thread t3=new Thread(ftask3);
		
		//启动线程
		//执行ftask1.run()，调用callable.call()得到结果outcome
		t1.start();
		t2.start();
		t3.start();
		
		//线程执行结束，分别获取各自线程的返回结果结果
		System.out.println("开始分别获取...........");
		Integer res1=ftask1.get();
		Integer res2=ftask2.get();
		Integer res3=ftask3.get();
		
		System.out.println("汇总各自计算结果：");
		Integer result=res1+res2+res3;
		System.out.println("最终结果："+result);
		
		
	}

}

class SumCallTask implements Callable<Integer>{
	//私有成员变量
	private int begin,end;
	
	public SumCallTask(int begin,int end) {//有参构造
		this.begin=begin;
		this.end=end;
		
	}
	
	
	@Override
	public Integer call() throws Exception {
		int tol=0;
		for(int i=begin;i<=end;i++) {//内部实现逻辑
			tol+=i;
		}
		System.out.println(Thread.currentThread().getName());
		return tol;
	}
	
}

结果：

实现Callable接口的子类，需要通过FutureTask实现类建立与线程Thread类之间关系。

4.通过线程池创建

        线程池是用来容纳线程的，通过Executors类的newFixedThreadPool（）方法可以创建固定大小的线程池。

//创建包含10个线程的线程池
		ExecutorService executorservice=Executors.newFixedThreadPool(10);

 在通过所创建的线程池对象的execute（）方法向线程池提交一个执行任务（创建一个Runnable接口的匿名实现类），线程池会自动分配一个空闲线程执行该任务。

executorservice.execute(new Runnable() {

				@Override
				public void run() {
					System.out.println(Thread.currentThread().getName()+"被执行了1次");
					try {
						//休眠1秒
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					
				}
				
			});

 如果没有空闲线程，则该任务处于等待队列（工作队列）。

        完整代码：

//线程的创建方式4：通过线程池创建
public class ThreadPoolsDemo {
	public static void main(String[] args) {
		
		//创建包含10个线程的线程池
		ExecutorService executorservice=Executors.newFixedThreadPool(10);
		
		while(true) {//不确定数量的线程请求
			//向线程池提交一个执行任务（Runnable接口的实现类对象）
			//线程池分配一个“空闲线程”执行该任务
			//如果没有空闲线程，则该任务处于“等待队列（工作队列）”
			executorservice.execute(new Runnable() {

				@Override
				public void run() {
					System.out.println(Thread.currentThread().getName()+"被执行了1次");
					try {
						//休眠1秒
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					
				}
				
			});
		}
		
	}
}

结果：

 以上就是我对线程及线程的创建的理解，欢迎诸君一起探讨，不对请指正哦！

秃屠土吐.
关注
Java线程的创建方式
m0_54202121的博客
04-24 2295
7.Callable&Future 接口 ​ 目前我们学习了有两种创建线程的方法-一种是通过创建 Thread 类，另一种是通过使用 Runnable 创建线程。但是，Runnable 缺少的一项功能是，当线程终止时（即 run（）完成时），我们无法使线程返回结果。为了支持此功能， Java 中提供了 Callable 接口。 现在我们学习的是创建线程的第三种方案—Callable 接口 Callable 接口的特点如下(重点) • 为了实现 Runnable，需要实现不返回任何内容的 run（）方
java 的线程怎么创建_Java线程的创建
weixin_33178839的博客
02-25 108
多线程指的是一个程序运行时，会包含多个线程同时进行。Java创建线程有三种基本的方法，分别是继承Thread类，实现Runnable接口(推荐的实现方式)，实现Callable接口实现Java多线程。1.继承Thread类，然后重写Thread 的run()方法，基本语法格式为public MyThread extends Thread { @Override public void run()...
创建线程的几种方式
tlh980911的博客
10-31 538
2】创建Runnable实现类的实例，并用这个实例作为Thread的target来创建Thread对象，这个Thread对象才是真正的线程对象。1】定义Runnable接口的实现类，一样要重写run()方法，这个run（）方法和Thread中的run()方法一样是线程的执行体。1】定义Thread类的子类，并重写该类的run()方法，该方法的方法体就是线程需要完成的任务，run()方法也称为线程执行体。使用线程池可以不用线程的时候放回线程池，用的时候再从线程池取，项目开发中主要使用线程池。
线程是什么？线程的相关概念以及基本的使用方法说明【内附可执行源码注释完整】
Jacksqh的博客
11-22 3687
本文讲解了线程的一些概念以及相关的使用场景以及方法，希望能够对您有些许帮助。
在windows操作系统中创建线程，即打开应用软件
最新发布
qq_43118674的博客
01-16 410
在windows操作系统中创建线程，即打开应用软件
计算机后端-Java-Java核心基础-第21章 常用类 03. 复习：线程通信和新的线程创建方式等.avi
05-22
计算机后端-Java-Java核心基础-第21章 常用类 03. 复习：线程通信和新的线程创建方式
Java创建线程三种方式的优缺点
08-26
继承Thread类创建线程是Java中最基本的线程创建方式。这种方式下，需要创建一个继承自Thread类的子类，并重写run方法。例如： ```java public class Thread1 extends Thread { @Override public void run() { ...
多线程-----2.线程的创建（四种方式）
ITCSDN_的博客
05-29 1109
一、线程与进程 ◆ 说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。 ◆ 而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位。 ◆ 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的的单位。 通俗的说，进程就是电脑中一个程序，比如说QQ，写字板等，而QQ中你和每一个人聊天都是一个线程，写字板中你写东西，或者保存都是需要线程去操作的。 注意：很多多线程是模拟出来的，真正的多线
Java多线程中线程的两种创建方式及比较代码示例
08-28
两种线程创建方式的比较 通过实现Runnable接口创建线程和通过继承Thread类创建线程都是创建线程的有效方法。但是，两种方法有其优缺点。 通过实现Runnable接口创建线程的优点是可以更好地实现多线程的并发性和灵活...
线程的创建、线程的基础方法（详细）
AwwzJ_0821的博客
03-13 1666
当进程中有多个线程时，此时每个线程都有一个PCB（在Linux 中，进程和线程也没有明显区分，线程被称为轻量级进程），一个进程就对应了一组 PCB。也可能会出现如下情况，因为这里用到了多线程，t1 线程和 t2 线程是并发运行的，所以谁先输出是不确定的。多个线程之间的调度顺序是不确定的，有时需要控制线程的执行顺序，要控制线程之间的顺序，其中一种方法就是线程等待。在如下代码中，调用 join 方法的线程是 main 线程，是针对 t 线程对象调用的，此时就是。join 操作默认情况下，是死等，不合理。
创建线程的四种方式
m0_58473539的博客
01-12 4930
无
线程的定义和使用
qq945813954的博客
08-04 298
一 、 线程 1.1 什么是线程 线程是程序执行的最小单位，进程是系统执行的最小单位，进程会被系统设置单独的地址空间和其他资源，各个进程的资源是相互独立的，进程的资源是进程内的线程共享；一个进程可以有多个线程，且至少有一个线程，一个线程只能有一个进程（线程上下文内容是记录的当前线程执行的cpu位置，因为每个线程的资源是相互独立的，所以一个线程不能拥有多个进程）。 1.2 创建线程 1.2.1 创建 创建线程方式：继承Thread，或者直接new Thread（）； 每个Threa...
线程创建的过程
一蓑烟雨任平生
09-23 1549
用户态创建线程 无论是进程还是线程，在内核里面都是任务，管起来不是都一样吗？但是问题来了，如果两个完全一样，那为什么咱们前两节写的程序差别那么大？如果不一样，那怎么在内核里面加以区分呢？ 其实，线程不是一个完全由内核实现的机制，它是由内核态和用户态合作完成的。pthread_create 不是一个系统调用，是 Glibc 库的一个函数，所以我们还要去 Glibc 里面去找线索。 果然，我们在 nptl/pthread_create.c 里面找到了这个函数。这里的参数我们应该比较熟悉了。 n...
线程创建的四种方式
热门推荐
weixin_44989630的博客
05-16 1万+
java中创建线程的四种方法以及区别 Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。Java可以用四种方式来创建线程，如下所示： 1）继承Thread类创建线程 2）实现Runnable接口创建线程 3）使用Callable和Future创建线程 4）使用线程池例如用Executor框架 下面让我们分别来看看这四种创建线程的方法。 ------------------------继承Thread类创建线程--------------------- .
Thread类和runnable接口
weixin_44199948的博客
02-28 480
Thread类 package com.thread; //创建线程方式一:继承Thread类，重写run()方法，调用start开启线程 //线程开启不一定立即执行，由cpu调度执行 public class TestThread1 extends Thread{ @Override public void run() { //run方法线程体 for (int i = 0; i <20; i++) { System.out.p
Java创建线程的七种方法，你知道几种？
GoodManS的CSDN
10-04 4295
方法1 ：继承Thread类 方法2 ：实现Runnable接口 方法3：匿名内部类 创建Thread 子类对象 方法4：匿名内部类 创建Runnable子类对象 方法5：使用 lambda 表达式 创建Runnable 子类对象 方法6：使用线程池！！！重点 方法7：使用Callable！！！重点
创建线程的七种方法 （图解 全网最全最详细）
Xiang想
05-14 3499
1、继承Thread；2、实现Runnable；3、实现Callable接口；4、创建线程池；5、Timer定时器；6、Lambda jdk1.8新特性Stream流之并行流；7、Spring实现多线程
Java线程创建方式对比与详解
本章内容主要围绕线程在Java编程中的核心概念与实践展开，包括线程的基础知识，线程的创建两种方式，以及线程控制、同步和生命周期等关键点。首先，线程被定义为程序内部的顺序控制流，与进程相比，线程更轻量，共享...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值