多线程创建及其方法

最新推荐文章于 2024-08-01 15:05:06 发布
最新推荐文章于 2024-08-01 15:05:06 发布
阅读量880 收藏 13
点赞数 20
文章标签： java 开发语言
@Stringzhua
本文链接：https://blog.csdn.net/weixin_60583755/article/details/140695984
版权

怎么创建多线程？

方式1:继承Thread类的方式进行实现 

步骤1:继承Thread类

步骤2:重写run方法

步骤3:创建MyThread的对象，调用start方法启动线程

MyThread类

public class MyThread extends Thread {
	// 重写run方法，线程要执行的代码
    // 方式1:继承Thread类的方式进行实现
	// 步骤1:继承Thread类
	// 步骤2:重写run方法
	@Override
	public void run() {
		for (int i = 0; i <= 50; i++) {
//			setName("测试");
			System.out.println(getName() + ":" + i);
		}
	}
}

 测试类

package day30_多线程;

public class Demo01 {
	// 步骤3:创建MyThread的对象，调用start方法启动线程
	public static void main(String[] args) {
		MyThread t1 = new MyThread();
		t1.setName("线程1");// 给创建设置名字
		// 开启线程--此处需要注意:不能直接调用run方法，否则就是对象的创建和方法的调用
		t1.start();
		for (int i = 0; i <= 50; i++) {
			System.out.println("main" + i);
		}
	}
}

方式2:实现Runnable接口的方式进行实现 

1.自定义一个类实现Runnable接口
2.重写run方法
3.创建自定义类的对象，将其作为参数
4.创建一个Thread对象，参数为3，并开启线程 

 MyRunnable类

public class MyRunable implements Runnable {
	@Override
	public void run() {
		for (int i = 0; i <= 50; i++) {
			// getName()为Thread类的方法,不能直接使用getName()方法
			// MyRunable和Thread类没有继承关系
			// 通过Thread的静态方法获取当前线程对象后获取方法名字
			Thread t1 = Thread.currentThread();
			System.out.println(t1.getName() + ":" + i);
		}
	}
}

测试类

public class Demo02 {
	// 方式2:实现Runnable接口的方式进行实现
	// 1.自定义一个类实现Runnable接口
	// 2.重写run方法
	// 3.创建自定义类的对象，将其作为参数
	// 4.创建一个Thread对象，参数为3，并开启线程
	public static void main(String[] args) {
		// 创建MyRunable的对象,表示多线程要执行的任务
		MyRunable r1 = new MyRunable();

		// 创建线程对象
		Thread t1 = new Thread(r1);
		Thread t2 = new Thread(r1);
		t1.setName("子线程1");
		t2.setName("子线程2");
		t1.start();// 开启线程
		t2.start();

		// 设置主线程的名字
		Thread mainThread = Thread.currentThread();
		mainThread.setName("main主线程");
		for (int i = 0; i <= 50; i++) {
			System.out.println(mainThread.getName() + ":" + i);
		}
	}
}

方式3:实现Callable接口的方式进行实现线程(和方式2相同)

MyCallable类 

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer> {
	//线程要执行的代码
    // 步骤1:创建一个实现类来实现Callable接口
	// 步骤2:重写ca11方法(有返回值，表示多线程执行的任务的返回值)
	@Override
	public Integer call() throws Exception {
		int sum = 0;
		for (int i = 0; i <= 100; i++) {
			sum += i;
		}
		return sum;
	}
}

 测试类

package day30_多线程;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Demo03 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		// 方式3:实现Callable接口的方式进行实现线程---和方式2相同
		// 特点：可以获取到多线程的运行结果
        // 步骤3:创建实现类对象
		// 步骤4:创建FutureTask类型的对象(管理多线程执行后的结果)
		// 步骤5:Thread类的对象的创建，并启动

		// 创建Callable实现类对象(表示多线程要执行的任务)
		MyCallable m1 = new MyCallable();
		// 创建FutureTask对象(作用管理多线程的运行结果)
		FutureTask<Integer> ft = new FutureTask<Integer>(m1);
		// 创建线程对象
		Thread t1 = new Thread(ft);
		// 启动线程
		t1.start();

		// 获取多线程运行的结果
		Integer num = ft.get();
		System.out.println(num);
	}
}

多线程的常见方法：

getName()方法

getName获取当前线程的名称

如果不是继承自Thread的类，则需要通过

Thread tmain = Thread.currentThread();

通过Thread的静态currentThread();方法获取当前线程对象

然后再通过getName()方法获取方法名

如果没有给线程设置名字，线程也有存在默认名称

格式:Thread-X(X的序号从0开始)

setName()方法

void setName(String name)

通过父类的单参的构造方法设置线程的名字,进行设置线程名称。

给线程设置名字

Thread.currentThread() 方法

Thread.currentThread();获取当前的线程

Thread.sleep()方法 

Thread.sleep(XXX);让指定的线程休眠多少毫秒
细节：

哪条线程执行到此方法,那么哪条线程就会在这里停留对应的时间
参数为毫秒 1秒=1000毫秒
当时间到了以后,线程会自动的醒来,继续执行下面的代码 

 MyThread类

public class MyThread extends Thread {
	public MyThread(String name) {
		super(name);
	}
	public MyThread() {
	}
    //重写run方法,线程要执行的代码
	@Override
	public void run() {
		for (int i = 0; i <= 100; i++) {
			System.out.println(getName() + ":" + i);
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

测试类

package day30_多线程方法;

public class Demo01 {
	public static void main(String[] args) throws InterruptedException {
		// getName():获取此线程名字
//		细节：如果没有给线程设置名字.线程也会有默认名称
//		格式:Thread-X(X的序号从0开始)
//		void setName(String name)设置线程的名字,构造方法进行设置线程名称
//		Thread.currentThread();获取当前的线程
//		Thread.sleep(XXX);让指定的线程休眠多少毫秒
		//细节1:哪条线程执行到此方法,那么哪条线程就会在这里停留对应的时间
//		参数为毫秒 1秒=1000毫秒
//		当时间到了以后,线程会自动的醒来,继续执行下面的代码

		MyThread m1 = new MyThread();
		m1.setName("线程1");
		m1.start();

		MyThread m2 = new MyThread("线程2");
		m2.start();

		// 主线程
		//哪条线程执行到此方法,此时获取到的就是哪个线程的对象
		Thread tmain = Thread.currentThread();
		System.out.println(tmain.getName());

		System.out.println("1111");
		Thread.sleep(3000);
		System.out.println("2222");
	}
}

getPriority()方法

getPriority() 获取优先级

setPriority() 方法

setPriority() 设置优先级 

范围1~10,默认优先级为5

数字越大优先级越高,但不是一定先执行完

 MyRunnable类

public class MyRunnable implements Runnable {
	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println(Thread.currentThread().getName() + "@" + i);
		}
	}
}

测试类

public class Demo02 {
	// getPriority() 获取优先级
	// setPriority() 设置优先级
	public static void main(String[] args) {
		MyRunnable runnable = new MyRunnable();

		Thread t1 = new Thread(runnable, "线程1");
		Thread t2 = new Thread(runnable, "线程2");

		// getPriority() 获取优先级
		// 范围1~10,默认优先级为5
		System.out.println(t1.getPriority());
		System.out.println(t2.getPriority());
		System.out.println(Thread.currentThread().getPriority());

		// 数字越大优先级越高,但不是一定先执行完
		t1.setPriority(1);
		t2.setPriority(10);

		t1.start();
		t2.start();
	}
}

setDaemon(true)设置守护线程

//守护线程
public class Demo03 {
	public static void main(String[] args) {
		MyThread1 t1 = new MyThread1();
		MyThread2 t2 = new MyThread2();
		t1.setName("女神线程");
		t2.setName("(备胎)守护线程");
		// 在调用start()方法前,
		// 调用setDaemon(true)将t2线程标记为守护线程
		t2.setDaemon(true);
		t1.start();
		t2.start();
	}
}

class MyThread1 extends Thread {
	@Override
	public void run() {
		for (int i = 0; i <= 10; i++) {
			System.out.println(getName() + "@" + i);
		}
	}
}

class MyThread2 extends Thread {
	@Override
	public void run() {
		for (char c = 'A'; c <= 'Z'; c++) {
			System.out.println(getName() + "@" + c);
		}
	}
}

用户线程：我们平常创建的普通线程；
守护线程：用来服务于用户线程的线程，在JVM中，所有非守护线程都执行完毕后，无论有没有守护线程，虚拟机都会自动退出；而守护线程执行结束后，虚拟机不会自动退出。

守护线程不一定会执行完，但是普通线程一定会执行完 

 Thread.yield()方法

让出当前的cpu的执行权,让结果更加均匀一点,也不是绝对均匀
当前的线程让出执行权后,再次进行抢夺资源也可能会抢到

public class Demo04 {
	public static void main(String[] args) {
		MyThread3 t1 = new MyThread3("线程1");
		MyThread3 t2 = new MyThread3("线程2");

		t1.start();
		t2.start();
	}
}

class MyThread3 extends Thread {
	public MyThread3(String string) {
		super(string);
	}

	@Override
	public void run() {
		for (int i = 0; i <= 100; i++) {
			System.out.println(getName() + "@" + i);
			// 让出当前的cpu的执行权,让结果更加均匀一点,也不是绝对均匀
			// 当前的线程让出执行权后,再次进行抢夺资源也可能会抢到
			Thread.yield();
		}
	}
}

线程插队：join()方法 

如果想要先执行线程1,再执行main方法,使用join,插队

将线程t1添加到当前线程的前面执行 

//join方法
public class Demo06 {
	public static void main(String[] args) throws InterruptedException {
		// 如果想要先执行线程1,再执行main方法,使用join,插队
		MyThread4 t1 = new MyThread4();
		t1.setName("线程");
		t1.start();

		// 将线程t1添加到当前线程的前面执行
		t1.join();
		for (int i = 0; i < 100; i++) {
			System.out.println("main@" + i);
		}
	}
}

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

 

 

 

        

Stringzhua
关注
  • 20
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java多线程案例及其代码实现
weixin_59771320的博客
03-28 8495
目录 案例一：单例模式 1.饿汉模式的代码实现 2.懒汉模式 案例二：阻塞队列 1.线程安全 2.产生阻塞效果 1.如果队列为空，尝试出队列，就会出现阻塞现象，阻塞到队列不为空为止。 2.如果队列未满，尝试入队列，也会出现阻塞，阻塞到队列不为满为止。 案例三：定时器 1.描述任务 2.组织任务（使用一定的数据结构把这些任务给放到一起） 3.执行时间到了的任务 案例四：线程池 案例一：单例模式 线程安全的单例模式有两种典型实现： 1.饿...
Python多线程及其基本使用方法实例分析
09-18
Python的多线程是编程中实现并发执行任务的重要机制，尤其在处理大量数据或需要同时进行多种操作的场景中。然而，Python的多线程在实际应用中有一些独特的限制，这些都源于Python的全局解释器锁（GIL，Global ...
多线程问题及其解决方法
hhy651208678的博客
11-13 1104
进程：就是一个应用程序。 线程：CUP的切换执行线 创建多线程的三种方式：继承，实现，匿名对象。推荐实现runnable接口，单继承，多实现 用户线程，没有做其它操作，就是直接创建的线程。 守护线程，可以对线程new Thread().setDaemon(true);当主线程执行完成后，守护线程也立即结束。 -- 主线程就是程序在运行的标致，当主线程结束，就是程序结束，程序结...
多线程概念及多线程三种创建方式
郝开的博客
02-08 1805
多线程概念及多线程三种创建方式多线程相关概念创建线程方式1：继承Thread类，重写run()，调用start()开启线程创建线程方式2：实现Runnable接口，重写run()，执行线程需要丢给Runnable接口实现类(Thread类实现了Runnable)，调用start开启线程继承Thread和实现Runable对比创建线程方式3：实现Callable接口，带返回值的 多线程相关概念 线程就是独立的执行路径 程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程、gc线程 main()称之
java创建多线程的四种方式及其区别
baihualindesu的博客
04-26 8744
java创建多线程有如下四种方式： 继承Thread类创建线程 实现Runnable接口创建线程 使用Callable和Future创建线程 使用线程池创建（使用java.util.concurrent.Executor接口） 下面分别介绍这四种创建多线程的方式 1. ----------------------继承Thread类创建线程------------------------...
java多线程
m0_46702681的博客
06-19 1658
javajava。
Java创建多线程的四种方式以及优缺点
Venus's Blog
04-22 5万+
java有以下四种创建多线程的方式： 1:继承Thread类创建线程 2:实现Runnable接口创建线程 3:使用Callable和FutureTask创建线程 4:使用线程池，例如用Executor框架创建线程 DEMO代码： package thread; import java.util.concurrent.*; public class ThreadTes...
python多线程原理及其实现
东南飘雪
02-17 3133
Python多线程原理与实现 目的： （1）了解python线程执行原理 （2）掌握多线程编程与线程同步 （3）了解线程池的使用 1 线程基本概念 1.1 线程是什么？ 线程是指进程内的一个执行单元,也是进程内的可调度实体. 与进程的区别: (1) 地址空间:进程内的一个执行单元;进程至少有一个线程;它们共享进程的地址空间;而进程有自己独立的地址空间; (2) 资源拥有:进程是资源分配和拥有的单...
QT多线程编程详解
热门推荐
coolboywjun的专栏
04-24 8万+
一、线程基础 1、GUI线程与工作线程 每个程序启动后拥有的第一个线程称为主线程，即GUI线程。QT中所有的组件类和几个相关的类只能工作在GUI线程，不能工作在次线程，次线程即工作线程，主要负责处理GUI线程卸下的工作。 2、数据的同步访问 每个线程都有自己的栈，因此每个线程都要自己的调用历史和本地变量。线程共享相同的地址空间。 二、QT多线程简介 QT通过三种形式提供了对线程...
实现多线程有两种方式及其区别
hello__word__的博客
09-28 5598
实现多线程有两种方式：(自JDK1.5之后有三种，最后一种并不常用)  　　1.继承Thread类  　　2.实现Runnable接口（Callable接口）   一个类如果实现了Runnable接口或者继承了Thread类，那么它就是一个多线程类，如果是要实现多线程，还需要重写run()方法，所以run() 方法是多线程的入口。   但是在启动多线程的时候，不是从run()方法开始的
QThread创建多线程之子类化QThread方法
BUSHUAID的博客
07-02 1230
使用 QThread 类创建多线程方法之一：使用子类化的QThread
c语言多进程多线程编程
07-21
线程创建和切换的开销比进程小，因此在需要频繁交互或轻量级并发的场景中，多线程更合适。 2. **创建线程**：C语言标准库并不直接支持线程操作，但可以通过第三方库如POSIX线程库（pthread）来实现。`pthread_...
python多线程并发实例及其优化
09-19
接下来介绍多线程的使用方法，以及如何通过循环创建和启动多个线程： ```python import threading from datetime import datetime def thread_func(): # 线程函数 print('我是一个线程函数', datetime.now()) ...
Java多线程中关于join方法的使用实例解析
08-31
本文将深入探讨`join()`方法的使用及其在Java多线程中的作用。 `join()`方法是`java.lang.Thread`类的一个成员方法，它的主要功能是让当前线程等待调用`join()`方法的线程执行完毕后再继续执行。这意味着，当主线程...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 587
1.导入hutool的maven依赖。2.复制一下代码执行。
社区养老服务小程序的设计
Karen198的博客
07-31 499
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
深入理解Java注解
最新发布
weixin_55745942的博客
08-01 544
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
JavaSE面向对象进阶
qq_45348840的博客
07-30 465
需求：在实际开发中，经常会遇到一些数组使用的工具类;请按照如下要求编写一个数组的工具类：ArrayUtil提供一个工具类方法printArr,用于返回整数数组的内容。返回的字符串格式如：[10,20,50,34,100 ]（只考虑整数数组，且只考虑一维数组)提供这样一个工具方法getAerage,用于返回平均分。（只考虑浮点型数组，且只考虑一维数组)定义一个测试类TestDemo,调用该工具类的工具方法，并返回结果。// 私有化构造方法// 定义静态方法，方便调用。i++) {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值