java多线程基础（知识+代码示例）

最新推荐文章于 2023-02-08 22:34:08 发布
最新推荐文章于 2023-02-08 22:34:08 发布
阅读量2.6k 收藏 1
点赞数 11
分类专栏： java 文章标签： java 算法 哈希算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41746479/article/details/121618114
版权

目录

实现多线程的两种基础方式

方式一：继承Thread类

方式二：实现Runnable接口

线程常用方法

线程优先级设置

线程的插队和礼让

线程的中断

守护线程 

线程同步

多线程时间比较

实现多线程的两种基础方式

方式一：继承Thread类

java中一个类只能继承一个父类，如果当前类已经继承了其他类了，则不能使用这种方法。

class Way1 extends Thread {

	private boolean bool = true;// 用于控制进程结束

	public void run() {// 编写具体的逻辑代码
		while (bool) {
			System.out.println("way1线程执行" + "    线程名为：" + Thread.currentThread().getName());
			try {
				Thread.sleep(100);// 睡眠0.1秒
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	public boolean isBool() {// 可用于查看线程的状态
		return bool;
	}

	public void setBool(boolean bool) {// 可用于改变线程的状态
		this.bool = bool;
	}
}

public class Text1 {

	public static void main(String[] args) throws InterruptedException {
		Way1 way1 = new Way1();
		way1.start();
		Thread.sleep(5000);// 主线程睡眠5秒，这个时候子线程仍然在执行
		way1.setBool(false);// 然后关闭线程
	}

}

方式二：实现Runnable接口

避免了方式一的问题，但是在开启线程的时候代码实现略有不同。

class Way2 implements Runnable {

	private boolean bool = true;// 用于控制进程结束

	@Override
	public void run() {// 编写具体的逻辑代码
		while (bool) {
			System.out.println("way2线程执行" + "    线程名为：" + Thread.currentThread().getName());
			try {
				Thread.sleep(100);// 睡眠0.1秒
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	public boolean isBool() {// 可用于查看线程的状态
		return bool;
	}

	public void setBool(boolean bool) {// 可用于改变线程的状态
		this.bool = bool;
	}

}

public class Text1 {

	public static void main(String[] args) throws InterruptedException {
		Way2 way2 = new Way2();
		Thread thread = new Thread(way2);
		thread.start();// new Thread(way2).start();
		Thread.sleep(5000);// 主线程睡眠5秒，这个时候子线程仍然在执行
		way2.setBool(false);// 然后关闭线程
	}

}

线程常用方法

线程优先级设置

// 线程优先级为1~10，不在范围内会抛出异常
// 设置优先级  setPriority();
// 获取优先级  getPriority();

		System.out.println(Thread.MAX_PRIORITY);// 最高优先级：10
		System.out.println(Thread.NORM_PRIORITY);// 一般优先级：5
		System.out.println(Thread.MIN_PRIORITY);// 最低优先级：1

		// 对于方式1实现的多线程
		Way1 way1 = new Way1();
		way1.setPriority(10);// 设置优先级
		System.out.println(way1.getPriority());// 查看优先级

		// 对于方式2实现的多线程
		Way2 way2 = new Way2();
		Thread thread = new Thread(way2);
		thread.setPriority(5);
		System.out.println(way1.getPriority());// 查看优先级

线程的插队和礼让

// 线程的礼让： Thread.yield();   该方法为静态方法，不一定礼让成功。如果资源充足礼让不成功
// 线程的插队： 类名.join();    插队成功后先执行完插入的线程的所有任务，再执行当前线程
// 获取电脑核数：Runtime.getRuntime().availableProcessors();

class Way1 extends Thread {

	private boolean bool = true;// 用于控制进程结束
	private int count = 0;// 记录执行次数

	@Override
	public void run() {// 编写具体的逻辑代码
		while (bool) {
			System.out.println((++count) + "   way1线程执行" + "    线程名为：" + Thread.currentThread().getName());
			if (count == 15)
				break;
			try {
				Thread.sleep(100);// 睡眠0.1秒
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	public boolean isBool() {// 可用于查看线程的状态
		return bool;
	}

	public void setBool(boolean bool) {// 可用于改变线程的状态
		this.bool = bool;
	}

}

public class Text1 {

	public static void main(String[] args) throws InterruptedException {

		Way1 way1 = new Way1();
		way1.start();

		for (int i = 1; i <= 10; i++) {
			Thread.sleep(100);
			System.out.println(i + "   主线程执行" + "   线程名为：" + Thread.currentThread().getName());
			if (i == 5)
				way1.join();//**本来同时执行，让way1插队先执行**
		}
	}
}

运行结果：

线程的中断

//线程中断：  类名.interrupt();    不是中止是中断


class Way1 extends Thread {

	private boolean bool = true;// 用于控制进程结束
	private int count = 0;

	@Override
	public void run() {// 编写具体的逻辑代码
		while (bool) {
			for (int i = 1; i <= 5; i++) {// 输出5次停20秒
				System.out.println((i) + "   way1线程执行" + "    线程名为：" + Thread.currentThread().getName());
			}
			try {
				Thread.sleep(200000);//停200秒
			} catch (InterruptedException e) {
				System.out.println("捕获中断");
			}
		}
	}

	public boolean isBool() {// 可用于查看线程的状态
		return bool;
	}

	public void setBool(boolean bool) {// 可用于改变线程的状态
		this.bool = bool;
	}

}

public class Text1 {

	public static void main(String[] args) throws InterruptedException {

		Way1 way1 = new Way1();
		way1.start();

		for (int i = 1; i <= 10; i++) {
			Thread.sleep(5000);//5秒过后
			way1.interrupt();//**提前结束休眠再次启动**
		}
	}
}

运行结果： 

守护线程 

/*
 * 设置守护线程： 类名.setDaemon();   当主线程下有子线程时 如果子线程可以无限的执行，那么当主线程执行结束后，子线程并不会结束。
 * 如果我们想子线程随着主线程一同结束，就要设置为守护线程
 */
class DaemonThread extends Thread {

	private boolean bool = true;// 用于控制进程结束
	private int count = 0;

	@Override
	public void run() {// 编写具体的逻辑代码
		while (bool) {
			System.out.println((++count) + "   子线程执行" + "    线程名为：" + Thread.currentThread().getName());
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	public boolean isBool() {// 可用于查看线程的状态
		return bool;
	}

	public void setBool(boolean bool) {// 可用于改变线程的状态
		this.bool = bool;
	}

}

public class Text1 {

	public static void main(String[] args) throws InterruptedException {

		DaemonThread dt = new DaemonThread();
		dt.setDaemon(true);//**设置为守护线程，当主线程结束时子线程一同结束**
		dt.start();

		for (int i = 1; i <= 5; i++) {
			System.out.println((i) + "   主线程执行" + "    线程名为：" + Thread.currentThread().getName());
			Thread.sleep(1000);// 5秒过后
		}
	}
}

运行结果：

线程同步

java线程同步 synchronized详解
 

多线程时间比较

通过使用欧拉筛求素数、朴素方法求素数、多线程朴素方法求素数来进行时间比较，多线程消耗的时间是一个大概的值，不是准确的。因为在求素数的过程中，程序执行的太快了，多个线程有可能拿了同一个数做运算，这就导致多线程的运算量大于的朴素方法。

class GetPrime extends Thread {

	public static int count = 2;
	public static int num = 0;// 记录素数个数
	public int n;// 求素数的范围
	long startTime;
	long endTime;
	public static boolean[] bool = new boolean[10000000];//减少重复计算

	GetPrime(int n) {
		this.n = n;
	}

	@Override
	public void run() {// 编写具体的逻辑代码
		while (count <= n) {//多线程求素数的时候有可能count还没有加1，另一个线程拿了相同的数做比较，这样写是为了减少重复的计算，但仍然不彻底
			if (bool[count] == false) {//这个数没有拿过，拿过来标记为true
				bool[count] = true;
				int a = count;
				count++;
				if (Prime(a) == true)
					num++;
			} else
				count++;
		}
		endTime = System.currentTimeMillis(); // 获取开始时间
	}

	public static boolean Prime(int number) {// 朴素方法求素数

		for (int i = 2; i <= Math.sqrt(number); i++) {
			if (number % i == 0)
				return false;
		}
		return true;
	}
}

public class Text1 {

	public static void GetPrime(int n) {// 欧拉筛求素数，素数都被保留在prime数组当中
		int[] prime = new int[n + 10];
		boolean[] bool = new boolean[n + 10];
		int count = 0;
		for (int i = 2; i <= n; i++) {
			if (bool[i] == false) {
				prime[count++] = i;
				bool[i] = true;
			}
			for (int j = 0; j < count; j++) {
				if (i * prime[j] > n)
					break;
				bool[i * prime[j]] = true;
				if (i % prime[j] == 0)
					break;
			}
		}
		System.out.println(count);// 输出个数
	}

	public static boolean Prime(int number) {// 朴素方法求素数

		for (int i = 2; i <= Math.sqrt(number); i++) {
			if (number % i == 0)
				return false;
		}
		return true;
	}

	public static void main(String[] args) throws InterruptedException {
		int count = 0;
		int n = 1000000;
		long startTime = System.currentTimeMillis(); // 获取开始时间
		GetPrime(n);
		long endTime = System.currentTimeMillis(); // 获取结束时间
		System.out.println("欧拉筛程序运行时间：" + (endTime - startTime) + "ms"); // 输出程序运行时间

		// 6977
		startTime = System.currentTimeMillis(); // 获取开始时间
		for (int i = 2; i <= n; i++) {
			if (Prime(i) == true)
				count++;
		}
		System.out.println(count);// 输出个数
		endTime = System.currentTimeMillis(); // 获取结束时间
		System.out.println("朴素for循环程序运行时间：" + (endTime - startTime) + "ms"); // 输出程序运行时间

		startTime = System.currentTimeMillis(); // 获取开始时间
		GetPrime P1 = new GetPrime(n);
		GetPrime P2 = new GetPrime(n);
		GetPrime P3 = new GetPrime(n);
		GetPrime P4 = new GetPrime(n);
		P1.start();//开4个线程
		P2.start();
		P3.start();
		P4.start();
		Thread.sleep(1000);
		System.out.println(GetPrime.num);// 输出个数
		endTime = System.currentTimeMillis(); // 获取结束时间
		System.out.println("朴素多线程for循环程序运行时间：" + (P1.endTime - startTime) + "ms"); // 输出程序运行时间

	}
}

运行结果：

可以看到，多线程在做了许多重复的计算过后，消耗的时间仍然比朴素for循环快。

也可以看到，多线程没有欧拉筛快，说明算法对效率的提高是多么的大！！！

算不出来没办法
关注
  • 11
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
Java|Java多线程案例
Autovy blog
05-04 2392
线程的创建及状态 1.线程的生命周期 2.创建一个线程 import java.util.concurrent.TimeUnit; public class ThreadStateTest { public static void main(String[] args) throws InterruptedException { // 创建一个线程对象 Thread thread = new Thread(); System.out.println
java 多线程-锁详解及示例代码
09-01
本文主要介绍 Java 多线程锁的基础知识，这里整理了相关资料及示例代码有兴趣的小伙伴可以参考下
Java 多线程案例
小钟不想敲代码
02-08 2219
多线程案例
Java多线程使用案例【附可运行代码】
weixin_44391786的博客
10-18 2713
Java多线程使用
Java多线程（附代码示例）
SimpleZihao的博客
10-08 1642
1. 一些概念 线程就是独立的执行路径 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程 main()称之为主线程，是系统的入口，用于执行整个程序 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序不能人为干预 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制 线程会带来额外的开销，如cpu调度时间，并发控制开销 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致 2. 开启多线程的几种方式 1. 继承Thre
【JavaSE】一文搞懂Java多线程，代码示例，清晰明了（上）
小新要变强的博客
09-23 3126
一文搞懂Java多线程，代码示例，清晰明了
实例代码讲解JAVA多线程
08-19
主要介绍讲解JAVA多线程的有关知识，文中示例代码非常详细，供大家参考和学习，感兴趣的朋友可以了解下
Java 多线程实例讲解（一）
09-01
本文主要介绍Java 多线程的知识，这里整理了详细的资料及简单示例代码有需要的小伙伴可以参考下
java多线程-同步块实例讲解
09-01
本文主要介绍java多线程-同步块的知识，这里整理了相关的详细资料及简单示例代码，有兴趣的小伙伴可以参考下
java多线程-读写锁原理
09-01
本文主要介绍java多线程的知识，这里整理了相关资料及简单示例代码，有兴趣的小伙伴可以参考下
Java多线程实例代码
08-09
6个非常经典的java多线程实例！欢迎下载!!!
Java多线程 线程组原理及实例详解
08-25
主要介绍了Java多线程 线程组原理及实例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java多线程经典案例分享
soberw的日常分享博客
12-28 3285
汇总案例一案例二案例三案例四案例五案例六案例七 案例一 实现一个容器，提供两个方法，add()，count() 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束。 本案例我通过闭锁（也叫门栓锁）实现，实现如下： package day_12_28.zuoye; import java.util.ArrayList; import java.util.List; import java.util.concurrent.CountDownLatch;
Thread的sleep()方法
qq_37555579的博客
08-06 2309
Thread的sleep()方法
Thread类的基本用法线程中断 线程等待 线程休眠 获取线程实例
qq_64421953的博客
03-23 521
1，线程的创建五种方式(2条消息) Thread 类创建线程的五种基本写法_许七安402的博客-CSDN博客 2，线程中断 线程停下来的关键，是要让线程对应的run方法执行完~有两种方法 （还有一个特殊的，是main这个线程，对于main来说，得是main方法执行完，线程就完了） （1）可以手动的设置一个标志位（自己创建的变量，Boolean），来控制线程是否要执行结束~~ private static boolean isQuit = false; public static vo
多线程的基础编程
m0_56620669的博客
03-25 520
一. 线程的定义方法 线程的五种定义方法 第一种: 创建一个类继承Thread class thread1 extends Thread{ @Override public void run(){ System.out.println("thread1"); } } public class TestDemo { public static void main(String[] args) { //第一种方式:继承Thread
多线程基础入门学习（带示例代码）
云泽的博客
04-23 975
多线程基础入门学习概念并发与并行线程与进程创建线程的方法继承Thread类实现Runnable接口Thread与Runnable的区别线程的常用方法设置优先级(setPriority)休眠(sleep)设置让步(yield)合并(join)守护线程(setDaemon(true))线程的生命周期新建状态（New）就绪状态（Runnable）运行状态（Running）阻塞状态（Blocked）死亡状态（Dead）线程通信等待唤醒机制场景案例代码示例死锁 概念 并发与并行 并发：多个事件在同一时间段内发生；
Java多线程之基础篇（一）
热门推荐
Tomdogs的专栏
07-15 1万+
一、并发和并行 1.1 概念 并行：多个CPU实例或是多台机器同时执行一段处理逻辑，是真正的同时。 并发：通过CUP调度算法，让用户看上去同时去执行，实际上从CPU操作层面并不是真正的同时。并发往往需要公共的资源，对公共资源的处理和线程之间的协调是并发的难点。 1.2 比较   如果你想要一个程序运行的更快，那么可以将其断开为多个片段，在单独的处理器上运行每个片段。并发是用于多...
腾讯T2手把手教你！史上最全的微服务专业术语面试50问，面试心得体会
m0_56830858的博客
04-19 303
摘要 Spring框架自诞生来就备受开发者青睐，很多开发者一致认为它是目前最屌的Java项目，正是因为它的“过人之处”，市面上99%的企业都在使用Spring框架。 所以，Spring一直Java技术里的重点难点，也是Java开发者面试中的重点，重要性不言而喻。 谷歌大牛甚至直言：“对于Java开发者，学习Java就是在学Spring。” 本篇内容一定是你从所未见过的学习笔记，我将分成4个部分跟大家分享，请认真看完本文，对你工作一定大有帮助！ 本文所提供的限量版笔记无偿分享，请关注我！转发！点赞！支持一下！
java 多线程 代码题 github
最新发布
07-07
在Github上，可以找到许多关于Java多线程的代码题，这些代码题可以帮助我们更好地理解和掌握Java多线程的相关知识。 以下是一个简单的Java多线程代码题示例，通过使用Github托管代码，可以与他人分享和交流这些代码...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

算不出来没办法

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值