多线程实现的方法

最新推荐文章于 2022-10-27 19:00:42 发布
最新推荐文章于 2022-10-27 19:00:42 发布
阅读量228 收藏 1
点赞数
分类专栏： Java 文章标签： 多线程 java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ting1king/article/details/105264963
版权

文章目录


在这里插入图片描述

方式1：继承Thread类

步骤：

A：自定义一个类继承Thread类。
B：在自定义类中重写run()方法
C：创建对象
D：启动线程

在这里插入图片描述


public class MyThread extends Thread{
	//重写run方法
	public void run(){
		//一般来说，这是比较耗时的代码，比如循环
		for(int i=0;i<10000;i++){
			System.out.println(i);
		}
	}
}


//创建对象
//		MyThread mt=new MyThread();
//		//启动线程
//		mt.run();
//		mt.run();
		//调用run()方法为什么是单线程呢？
		//因为run()方法直接调用其实就相当于普通的方法调用，所以我们看到的是单线程的效果
		//如果想要看到多线程效果，就必须说说另外一个方法：start()方法
		//run()和start()区别：
		//run():仅仅是封装被线程执行的代码，直接调用是普通方法
		//start():首先启动了线程，然后再调用jvm去调用该线程的run()方法。
//		MyThread mt=new MyThread();
//		//java.lang.IllegalThreadStateException
		//相当于mt线程调用了两次，而不是两个线程启动
//		mt.start();
//		mt.start();
		//创建多线程不是这样调用两次start()方法就行的，需要创建多个线程对象来调用start（）方法
		MyThread mt=new MyThread();
		MyThread mt1=new MyThread();
		mt.start();
		mt1.start();

获取和设置线程对象的名称：

public final String getName():获取线程的名称

public class MyThread extends Thread{
	//重写run方法
	public void run(){
		//一般来说，这是比较耗时的代码，比如循环
		for(int i=0;i<10;i++){
			System.out.println(getName()+":"+i);
		}
	}
}

public class MyThreadDemo {
	public static void main(String[] args) {
		MyThread mt=new MyThread();
		MyThread mt1=new MyThread();
		mt.start();
		mt1.start();
	}

}

自己设置线程对象的名称：

public final void setName(String name):设置线程的名称
方式1：无参方法

public class MyThreadDemo {
	public static void main(String[] args) {

		MyThread mt=new MyThread();
		MyThread mt1=new MyThread();
		
		//设置线程的名称
		mt.setName("hello");
		mt1.setName("world");
		
		mt.start();
		mt1.start();
	}

}
方式2：有参方法
public class MyThread extends Thread{
	//无参构造
	public MyThread() {
		// TODO Auto-generated constructor stub
	}
	//有参构造
	public MyThread(String name){
		super(name);
	}
	//重写run方法
	public void run(){
		//一般来说，这是比较耗时的代码，比如循环
		for(int i=0;i<10;i++){
			System.out.println(getName()+":"+i);
		}
	}
}

public class MyThreadDemo {
	public static void main(String[] args) {

		
		//第二种方式：有参构造
		MyThread mt=new MyThread("hello");
		MyThread mt1=new MyThread("world");
		mt.start();
		mt1.start();
	}

}

感觉无参方法更加简单
结果：

hello:0
hello:1
world:0
world:1
world:2
world:3
world:4
world:5
world:6
world:7
world:8
world:9
hello:2
hello:3
hello:4
hello:5
hello:6
hello:7
hello:8
hello:9

获取main方法所在的线程对象的名称：

public static Thread currentThread():返回当前正在执行的线程对象

public class MyThreadDemo {
	public static void main(String[] args) {
	//获取线程的名称
	System.out.println(Thread.currentThread().getName());
	}

}

线程调度

java使用的是抢占式模型
在这里插入图片描述

我们线程没有设置优先级，那么就肯定有默认优先级，默认为5

获取线程对象优先级方法

public final int getPriority():返回线程对象的优先级

public class MyThreadDemo {
	public static void main(String[] args) {
		MyThread m1=new MyThread();
		MyThread m2=new MyThread();
		MyThread m3=new MyThread();
		
		//设置线程对象名字
		m1.setName("牛顿");
		m2.setName("爱因斯坦");
		m3.setName("伽利略");
		
		//获取线程对象默认优先级
		System.out.println(m1.getPriority());//5
		System.out.println(m2.getPriority());//5
		System.out.println(m3.getPriority());//5
	}

}

设置线程对象优先级

public final void setPriority(int newPriority):更改线程优先级

注意：

线程默认优先级是5
线程优先级的范围是：[1-10]
线程优先级高仅仅表示线程获取CPU时间几率高。但是要在次数比较多，或者多次运行的时候才可以看到比较好的效果。

public class MyThreadDemo {
	public static void main(String[] args) {
		MyThread m1=new MyThread();
		MyThread m2=new MyThread();
		MyThread m3=new MyThread();
		
		//设置线程对象名字
		m1.setName("牛顿");
		m2.setName("爱因斯坦");
		m3.setName("伽利略");
		
		//获取线程对象默认优先级
//		System.out.println(m1.getPriority());//5
//		System.out.println(m2.getPriority());//5
//		System.out.println(m3.getPriority());//5
		
		//设置线程优先级
		m1.setPriority(10);
		m2.setPriority(1);
		
		m1.start();
		m2.start();
		m3.start();
	}

}

线程控制

线程休眠

public static void sleep(long millis)：线程休眠

public class MyThread extends Thread{
	
	//重写run方法
	public void run(){
		//一般来说，这是比较耗时的代码，比如循环
		for(int i=0;i<10;i++){
			System.out.println(getName()+":"+i+",日期："+new Date());
		}
		//睡眠
		try {
			Thread.sleep(1000);//单位毫秒
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

public class MyThreadDemo {
	public static void main(String[] args) {
		MyThread m1=new MyThread();
		MyThread m2=new MyThread();
		MyThread m3=new MyThread();
		
		//设置线程对象名字
		m1.setName("牛顿");
		m2.setName("爱因斯坦");
		m3.setName("伽利略");
		
		m1.start();
		m2.start();
		m3.start();
	}

}

线程加入

public final void join():等待线程加入


public class MyThread extends Thread{
	
	//重写run方法
	public void run(){
		//一般来说，这是比较耗时的代码，比如循环
		for(int i=0;i<10;i++){
			System.out.println(getName()+":"+i+",日期："+new Date());
		}
		
	}
}


public class MyThreadDemo {
	public static void main(String[] args) {
		MyThread m1=new MyThread();
		MyThread m2=new MyThread();
		MyThread m3=new MyThread();
		
		//设置线程对象名字
		m1.setName("牛顿");
		m2.setName("爱因斯坦");
		m3.setName("伽利略");
		
		m1.start();
		try {
			m1.join();//只有m1走完了，m2和m3才可以走
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		m2.start();
		m3.start();
	}

}

礼让线程

public static void yield():暂停当前正在执行的线程对象，并执行其他线程

让线程执行更加和谐，但是不能保证一人一次

public class MyThread extends Thread{
	
	//重写run方法
	public void run(){
		//一般来说，这是比较耗时的代码，比如循环
		for(int i=0;i<10;i++){
			System.out.println(getName()+":"+i+",日期："+new Date());
		}
		//礼让
		Thread.yield();
	}
}

public class MyThreadDemo {
	public static void main(String[] args) {
		MyThread m1=new MyThread();
		MyThread m2=new MyThread();
		MyThread m3=new MyThread();
		
		//设置线程对象名字
		m1.setName("牛顿");
		m2.setName("爱因斯坦");
		m3.setName("伽利略");
		
		m1.start();
		m2.start();
		m3.start();
	}

}

结果：

牛顿:0,日期：Thu Apr 02 15:30:04 CST 2020
爱因斯坦:0,日期：Thu Apr 02 15:30:04 CST 2020
伽利略:0,日期：Thu Apr 02 15:30:04 CST 2020
爱因斯坦:1,日期：Thu Apr 02 15:30:04 CST 2020
牛顿:1,日期：Thu Apr 02 15:30:04 CST 2020
牛顿:2,日期：Thu Apr 02 15:30:04 CST 2020
牛顿:3,日期：Thu Apr 02 15:30:04 CST 2020
爱因斯坦:2,日期：Thu Apr 02 15:30:04 CST 2020
爱因斯坦:3,日期：Thu Apr 02 15:30:04 CST 2020
伽利略:1,日期：Thu Apr 02 15:30:04 CST 2020
伽利略:2,日期：Thu Apr 02 15:30:04 CST 2020
爱因斯坦:4,日期：Thu Apr 02 15:30:04 CST 2020
牛顿:4,日期：Thu Apr 02 15:30:04 CST 2020
爱因斯坦:5,日期：Thu Apr 02 15:30:04 CST 2020
爱因斯坦:6,日期：Thu Apr 02 15:30:04 CST 2020
伽利略:3,日期：Thu Apr 02 15:30:04 CST 2020
爱因斯坦:7,日期：Thu Apr 02 15:30:04 CST 2020
牛顿:5,日期：Thu Apr 02 15:30:04 CST 2020
牛顿:6,日期：Thu Apr 02 15:30:04 CST 2020
爱因斯坦:8,日期：Thu Apr 02 15:30:04 CST 2020
伽利略:4,日期：Thu Apr 02 15:30:04 CST 2020
爱因斯坦:9,日期：Thu Apr 02 15:30:04 CST 2020
伽利略:5,日期：Thu Apr 02 15:30:04 CST 2020
牛顿:7,日期：Thu Apr 02 15:30:04 CST 2020
伽利略:6,日期：Thu Apr 02 15:30:04 CST 2020
伽利略:7,日期：Thu Apr 02 15:30:04 CST 2020
牛顿:8,日期：Thu Apr 02 15:30:04 CST 2020
伽利略:8,日期：Thu Apr 02 15:30:04 CST 2020
伽利略:9,日期：Thu Apr 02 15:30:04 CST 2020
牛顿:9,日期：Thu Apr 02 15:30:04 CST 2020

后台线程

public final void setDaemon(boolean on):将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。 
该方法必须在启动线程前调用。 

public class MyThread extends Thread{
	
	//重写run方法
	public void run(){
		//一般来说，这是比较耗时的代码，比如循环
		for(int i=0;i<10;i++){
			System.out.println(getName()+":"+i);
		}
		
	}
}


public class MyThreadDemo {
	public static void main(String[] args) {
		MyThread m1=new MyThread();
		MyThread m2=new MyThread();
		
		//设置线程对象名字
		m1.setName("关羽");
		m2.setName("张飞");
		
		//设置守护线程,属于用户线程,需要设置在启动线程之前
		m1.setDaemon(true);
		m2.setDaemon(true);
		
		m1.start();
		m2.start();
		
		//关羽和张飞应该是死在刘备前面的
		Thread.currentThread().setName("刘备");
		for(int i=0;i<20;i++){
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}

}

结果：

刘备:0
刘备:1
刘备:2
刘备:3
刘备:4
刘备:5
刘备:6
张飞:0
关羽:0
关羽:1
关羽:2
张飞:1
张飞:2
张飞:3
张飞:4
张飞:5
张飞:6
张飞:7
刘备:7
刘备:8
刘备:9
张飞:8
关羽:3
关羽:4
关羽:5
关羽:6
关羽:7
关羽:8
张飞:9
刘备:10
刘备:11
刘备:12
关羽:9
刘备:13
刘备:14
刘备:15
刘备:16
刘备:17
刘备:18
刘备:19

终断线程

	public void interrupt():中断线程。把线程状态终止，并抛出一个异常

public class MyThread extends Thread{
	
	//重写run方法
	public void run(){
		System.out.println("开始执行："+new Date());
		
		//休息10秒
		try {
			Thread.sleep(10000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			System.out.println("线程终止了");
		}
		System.out.println("结束执行："+new Date());
	}
}


public class MyThreadDemo {
	public static void main(String[] args) {
		MyThread m1=new MyThread();
		
		m1.setName("关羽");

		m1.start();
		
		//超过3秒不醒，就终止
		try {
			Thread.sleep(3000);
			m1.interrupt();//终止线程
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

结果：

开始执行：Thu Apr 02 16:09:16 CST 2020
线程终止了
结束执行：Thu Apr 02 16:09:19 CST 2020

方式2：实现Runnable接口

步骤：

A：自定义类实现Runnable接口
B：重写run()方法
C：创建自定义类的对象
D：创建Thread类的对象，并把C步骤的对象作为构造参数传递

构造方法：

public Thread(Runnable target):这个参数其实是Runnable的子类对象
public Thread(Runnable target,String name):第一个是子类对象，第二种是设置名字

public class MyRunnable implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<100;i++){
			//由于实现接口的方式就不能直接使用Thread类的方法，但是可以间接的使用
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}

}

public class MyRunnableDemo {
	public static void main(String[] args) {
		//创建自定义类的对象
		MyRunnable mr=new MyRunnable();
		
		//创建Thread类的对象，并把C步骤的对象作为构造参数传递
		//方式1：
		//public Thread(Runnable target):这个参数其实是Runnable的子类对象
//		Thread t1=new Thread(mr);
//		Thread t2=new Thread(mr);
//		
//		//设置名字
//		t1.setName("张三");
//		t2.setName("李四");
		//方式2：
		//public Thread(Runnable target,String name):第一个是子类对象，第二种是设置名字
		Thread t1=new Thread(mr,"张三");
		Thread t2=new Thread(mr,"李四");
		
		t1.start();
		t2.start();
	}
}

两种方式对比：

后面这种方法的好处是：

A：避免了由于java单继承带来的局限性（假如有一个子类继承了一个父类，但是子类想要实现多线程，这时候这种方法就可以适用）
B：适合多个相同程序的代码去处理同一个资源的情况，把线程同程序的代码，数据有效分离，较好的体现了面向对象设计的思想。

大部分情况用方式2
在这里插入图片描述

java后端指南
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
多线程的代码究竟怎么写
weixin_34319111的博客
09-01 215
    多线程这个名词在计算机理论和软件开发中经常用到，而且在java面向对象程序设计中经常将多线程编程作为高级编程部分，多线程都放到了高级部分，恐怕在校计算机专业的大学生就要悲剧了，要知道很多时候我们将要面对一个知识领域的入门槛的时候，大概也就考试到了，画个重点，勾几个题，刷刷，一本书就噢啦。此情此景相比很多童鞋和我都有相同的感受。     怎么解释线程是很没有必要的。看看这一篇博文就大概知道...
三分钟学会多线程的三种实现方式
qq_44654974的博客
05-01 1040
学Java的核心所在就是多线程，也是面试之中必定问到的题。。所以说对多线程的掌握至关重要。下面来总结一下多线程的实现方式方式。 1.Thread 可以通过继承Thread继承；； Thread 唯一启动多线程的方式； 版本：jdk1.5之后 具体实现方式如下： 继承Thread 构造函数->run()实现->使用start()启动 2.runnable (1)interface (...
Java -- 多线程技术基础(1) 方法详解
always_my_fault的专栏
11-24 572
一、run()和start()这两个方法应该都比较熟悉，把需要并行处理的代码放在run()方法中，start()方法启动线程将自动调用 run()方法，这是由Java的内存机制规定的。并且run()方法必须是public访问权限，返回值类型为void。二、关键字Synchronized这个关键字用于保护共享数据，当然前提是要分清哪些数据是共享数据。每个对象都有一个锁标志，当一个线程访问该对象时，被
黑马程序员 多线程
魏亮的专栏
07-27 326
进程：是一个正在执行中的程序。 每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。 线程：就是进程中的一个独立的控制单元。 线程在控制着进程的执行。 一个进程中至少有一个线程。 　 Java VM  启动的时候会有一个进程java.exe. 该进程中至少一个线程负责java程序的执行。 而且这个线程运行的代码存在于main方法中。
Vue多线程vue-worker
书读百遍，其义自见
08-03 3778
https://github.com/israelss/vue-worker
JavaScript多线程的实现方法
12-11
注：以下内容基于IE中GIF的onload事件的基础上，故所有测试IE only 需要用到的几个图片 先看一个简单的事实： 代码如下:[removed] var img=new Image();... 原因很简单：IE对多帧GIF的onload事件重复执行，即每播放完
PHP+shell实现多线程的方法
12-18
本文实例讲述了PHP+shell实现多线程的方法。分享给大家供大家参考。具体如下： 这里介绍如何借助shell脚本实现多线程。 先写个简单的php代码，这里为了让脚本执行时间更长，方便看效果，sleep一下，呵呵！先看下test...
php多线程实现方法及用法实例详解
10-23
主要介绍了php多线程实现方法及用法实例，PHP多线程实现方法和fsockopen函数有关，需要的朋友可以参考下
python线程安全及多进程多线程实现方法详解
01-20
一个操作可以在多线程环境中使用，并且获得正确的结果。 线程安全的操作线程是顺序执行的而不是并发执行的。 一般涉及到写操作需要考虑如何让多个线程安全访问数据。 线程同步的方式 互斥量（锁）： 通过互斥...
Mandelbrot集的java多线程实现方法.pdf
09-30
《Mandelbrot集的Java多线程实现方法》 Mandelbrot集是一个在复数平面上由特定迭代过程定义的点集，其特点在于通过反复应用一个数学函数，某些点的序列会保持在有限区域内，而其他点则会发散到无穷大。这一集合在...
java创建线程的三种方式
weixin_45135517的博客
06-07 277
java线程 创建和运行线程 方法一，直接使用 Thread // 创建线程对象 Thread t = new Thread() { public void run() { // 要执行的任务 } }; // 启动线程 t.start(); 例如： // 构造方法的参数是给线程指定名字，推荐 Thread t1 = new Thread("t1") { @Override // run 方法内实现了要执行的任务 public void run() { log.debug("hello");
初识java多线程 （java多线程基础知识汇总）
无名氏灬的博客
07-26 550
线程Thread 首先明确： 1.了解进程与线程之间的概念 2.线程的好处 3.创建线程 4.线程的操作 5.线程的缺点，如何防范。 =========================================== 一、概念    1. 进程与线程       a. 进程---就是正在进行的程序。          CPU在某一时间段只处理一个程序。 程序
多线程的方法总结
DoSamba的博客
01-15 646
/* 1.多线程的实现方法 A：通过继承自Thread类 a.把要使用多线程实现的代码封装在一个继承Thread的类中。 b.重写run方法，把代码放在run方法中。 c.创建该类的实例，使用start方法开启线程。 匿名内部类的实现方法： new Thread(){
SpringBoot+Vue 后端异步多线程加前端实时更新的实现
静心园
04-17 4111
SpringBoot+Vue 后端异步多线程加前端实时更新的实现 Spring Boot在一些场景下需要用户发起请求服务器执行耗时任务（例如批量发送邮件），此时如果让用户一直等待任务执行，明显不合理，而且会很容易超时，这个时候正确的做法是后端采取异步多线程的方式执行任务，并保持任务执行的进度状态，前端使用定时器获取任务执行状态进行持续更新直到任务完成。具体的实现方法 1、后端异步多线程实现 一、springboot开启异步支持 在application入口类添加@EnableAsync注解 使用配置
Vue 进阶系列丨webWorker 多线程
HFunTeam的博客
10-27 3061
Vue 进阶系列教程将在本号持续发布，一起查漏补缺学个痛快！若您有遇到其它相关问题，非常欢迎在评论中留言讨论，达到帮助更多人的目的。若感本文对您有所帮助请点个赞吧！2013年7月28日，尤雨溪第一次在 GItHub 上为 Vue.js 提交代码；2015年10月26日，Vue.js 1.0.0版本发布；2016年10月1日，Vue.js 2.0发布。最早的 Vue.js 只做视图层，没有路由，没...
JVM中的栈和局部变量（转）
先相信你自己，然后别人才会相信你。
04-06 287
Java开发中，每当我们在程序中使用new生成一个对象，对象的引用存放在栈里，而对象是存放在堆里的。可以看出栈在Java核心的重要位置。今天我们就继续深入Java核心这个系列，为您介绍Java中的栈、局部变量及其之间的关系。 Java中的栈 每当启用一个线程时，JVM就为他分配一个Java栈，栈是以帧为单位保存当前线程的运行状态。某个线程正在执行的方法称为当前方法，当前方法使用的栈帧称为当前帧，当...
多线程几种常用方法代码
code_mzh的博客
06-27 820
线程只能start一次 1.sleep，休眠 //增加事故发生问题 public class TestSleep implements Runnable{ //票 private int ticketNum=10; @Override public void run() { while(true){ if(ticketNum<=0){ break; }
多线程run()中经常写while(true)的作用
热门推荐
谁的寂寞覆我华裳的博客
09-20 1万+
线程基础一直不太好，也没怎么用过，最近看到了一些线程的代码，发现一个现象，run()方法中基本都会写while(true)的循环，如下： public class XXXThread implements Runnable { public void run(){ while(true) { …… } } } 使用while(true)的作用： run方法中的代码
Android支持三种多线程实现方法：继承Thread类、实现Runnable接口和使用AsyncTask类。他们的区别简述使用场景
最新发布
08-05
Android支持三种多线程实现方法的区别在于：继承Thread类提供了更多的灵活性，可以更容易地实现一个完整的多线程模型；实现Runnable接口更加简单，可以在新线程中执行任务；使用AsyncTask类可以在UI线程中执行任务，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

java后端指南

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

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

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

打赏作者

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

抵扣说明：

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

余额充值