JAVA线程从零开始（二）——创建线程

最新推荐文章于 2024-10-13 23:27:44 发布
最新推荐文章于 2024-10-13 23:27:44 发布
阅读量269 收藏
点赞数
分类专栏： java线程从零开始 文章标签： java 线程 从零开始
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21908817/article/details/74465925
版权

创建线程有三种方法

1、继承Thread类，重写run()方法，run()方法代表线程要执行的任务。

2、实现Runnable接口，重写run()方法，run()方法代表线程要执行的任务。

3、实现callable接口，重写call()方法，call()作为线程的执行体，具有返回值，并且可以对异常进行声明和抛出



例子：

1、继承Thread类

缺点：Java只支持单继承，如果一个类已经从一个类继承，则无法再继承Thread类

package com.csdn.thread;

/**
 * 模拟龟兔赛跑
 * 1、创建多线程（方式一）：继承 Thread + 重写run方法（线程体）
 * 2、使用线程：创建子类对象  + 对象.start()方法  线程启动
 */

public class CreateThreadWay1 {
	public static void main(String[] args) {
		//创建子类对象
		Rabit rabit = new Rabit();
		Tortoise tortoise = new Tortoise();
		//调用start()方法，启动线程，不要调用run()方法，不要调用run()方法，不要调用run()方法，重要的事情说三遍
		rabit.start();
		tortoise.start();
		
		//用来观察兔子线程和乌龟线程main函数里的方法块的运行情况
		for(int i=0;i<30;i++){
			System.out.println("main-->" + i);
		}
	}
	
}

class Rabit extends Thread{
	//线程体
	@Override
	public void run(){
		for(int i=0;i<30;i++){
			System.out.println("兔子跑了" + i + "步");
		}
	}
}

class Tortoise extends Thread{
	@Override
	public void run(){
		for(int i=0;i<30;i++){
			System.out.println("乌龟跑了" + i + "步");
		}
	}
}

2、实现Runnable接口

优点：可以同时实现继承，Runnable接口方式更通用一些。

        （1）、避免单继承的局限性

        （2）、便于共享资源

package com.csdn.thread;

/**
 * 推荐使用Runnable创建线程
 * 1、避免单继承的局限性
 * 2、便于共享资源
 */
public class CreateThreadWay2_1 {
	public static void main(String[] args) {
		//1)、创建真实角色
		Programmer pro = new Programmer();
		 //2)、创建代理角色+真实角色引用
		Thread proxy = new Thread(pro);
		 //3)、调用start()方法 启动线程
		proxy.start();
		
		for(int i=0;i<100;i++){
			System.out.println("一边聊QQ");
		}
	}
}

/**
 * 使用Runnable 创建进程
 * 1、类实现Runable接口+重写run()方法
 * 2、启动多线程 使用静态代理
 *      1)、创建真实角色
 *      2)、创建代理角色
 *      3)、调用start()方法 启动线程
 */
class Programmer implements Runnable{

	@Override
	public void run() {
		
		for(int i=0;i<100;i++){
			System.out.println("一边吃苹果");
		}
	}
	
}


package com.csdn.thread;

/**
 * 抢票系统
 * 方便共享资源
 */
public class CreateThreadWay2_2 implements Runnable{

	private int num = 50;
	
	@Override
	public void run() {
		while(true){
			if(num <= 0){
				break;//跳出循环
			}
			System.out.println(Thread.currentThread().getName() + "抢到了倒数第" + num-- + "张票。");
		}
	}
	
	public static void main(String[] args) {
		CreateThreadWay2_2 web = new CreateThreadWay2_2();
		//代理
		Thread t1 = new Thread(web,"孙悟空");
		Thread t2 = new Thread(web,"比特大魔王");
		Thread t3 = new Thread(web,"撒旦");
		
		//启动线程
		t1.start();
		t2.start();
		t3.start();
	}

}

3、实现callable接口

优点：可以返回值，可以抛出异常

缺点：实现繁琐


实现步骤：

1、实现callable接口+重写call方法

2、借助执行调度服务ExecutorService获取Future对象

ExecutorService service = Executors.newFixedThreadPool(2);
Future<Integer> result = service.submit(rabit);

3、获取值result

int num = result.get();

4、停止服务

service.shutdownNow();


package com.csdn.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CreateThreadWay3 {
	public static void main(String[] args) {
		//1、创建线程
		ExecutorService service = Executors.newFixedThreadPool(2);//开两个线程
		
		Race tortoise = new Race("老乌龟",1000);
		Race rabbit = new Race("小兔子",500);
		
		//2、获取Future对象
		Future
   
   
    
     result1 = service.submit(tortoise);
		Future
    
    
     
      result2 = service.submit(rabbit);
		
		try {
			Thread.sleep(2000);
			tortoise.setFlag(false);
			rabbit.setFlag(false);
			
			//3、获取值
			int num1 = result1.get();
			int num2 = result2.get();
			
			System.out.println("乌龟跑了-->" + num1 + "步");
			System.out.println("兔子跑了-->" + num2 + "步");
			
			//4、停止服务
			service.shutdown();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
	}
}

class Race implements Callable
     
     
      
      {
	private String name;//名称
	private long time;//延时时间
	private boolean flag = true;
	private int step = 0;//步
	
	public Race(){
		
	}
	public Race(String  name,int time){
		super();
		this.name = name;
		this.time = time;
	}
	@Override
	public Integer call() throws Exception {
		while(flag){
			Thread.sleep(time);
			step++;
		}
		return step;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public long getTime() {
		return time;
	}
	public void setTime(long time) {
		this.time = time;
	}
	public boolean isFlag() {
		return flag;
	}
	public void setFlag(boolean flag) {
		this.flag = flag;
	}
	public int getStep() {
		return step;
	}
	public void setStep(int step) {
		this.step = step;
	}
	
	
}
运行结果： 

乌龟跑了-->3步
兔子跑了-->5步

callable实例代码个人理解与分析：

1、启动了兔子线程和乌龟线程，于此同时main函数也是一个线程，共有3个线程同时在运行

2、乌龟线程休眠1s，兔子线程休眠0.5s，main线程休眠2s；

      1）兔子线程在程序运行0.5s（三个线程均休眠了0.5s后）后进入运行中状态；step由0变为1后再次进入睡眠0.5s

      2）程序运行1s时，乌龟线程和兔子线程均进入就绪状态，无论是乌龟线程先运行，还是兔子线程先运行，线程都会使step在原有基础上+1并再次进入休眠状态，此时乌龟的step变为1，并再次休眠1s，兔子的step变为2，并再次休眠0.5s

      3）程序运行1.5s时，main线程和乌龟线程均在休眠中，兔子线程进入运行状态，step再次+1变为3，并再次进入休眠

      4）程序运行2s时，main线程、乌龟线程、兔子线程均进入就绪状态，这时


若执行顺序为：tortoise.setFlag(false)；乌龟线程；兔子线程；rabit.setFlag(false)；则将乌龟线程的结束标识改变，意味着乌龟线程的step只能再+1就会跳出循环，乌龟线程的step为2，并退出循环，兔子线程step变为4，并再次进入休眠，main线程执行rabit的结束标识，再0.5s后兔子线程step+1并退出循环，此时兔子线程step为5，最终输出结果

乌龟跑了-->2步

兔子跑了-->5步


若执行顺序为tortoise.setFlag(false);rabit.setFlag(false)；乌龟线程；兔子线程；原理同上，乌龟step变为2，兔子step变为4，均跳出循环，输出结果为

乌龟跑了-->2步

兔子跑了-->4步


若执行顺序为乌龟线程；tortoise.setFlag(false);rabit.setFlag(false);兔子线程；则乌龟step为3，兔子step为4，输出结果为

乌龟跑了-->3步

兔子跑了-->4步


若执行顺序为乌龟线程；兔子线程；tortoise.setFlat(false);rabit.setFlag(false);则乌龟step为3，兔子step为5，输出结果为

乌龟跑了-->3步

兔子跑了-->5步


--代码分析over



Callable和Runnable的区别：

1、callable定义的方法是call，而runnable定义的方法是run

2、callable的call方法可以有返回值，而runnable的run方法不能有返回值

3、callable的call方法可以抛出异常，而runnable的run方法不能抛出异常

4、运行Callable任务可拿到一个Future对象，Future表示异步计算的结果。它提供了检查计算是否完成的方法，以

等待计算的完成，并检索计算的结果。通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行

的结果。

單曲
关注
专栏目录
Java多线程从0到1之线程创建（一）
行走江湖的文艺猿 的专栏
10-12 508
我们开发中经常会用到多线程，尤其是在Android中，由于主线程的诸多限制，像网络请求，文件读取等一些耗时的操作都会用多线程来写，多线程说简单也简单，就是new Thread()，然后在start()；说复杂也复杂，线程数太多会造成OOM，由此引入线程池，死锁，同步(synchronized)，生产者/消费者，原子操作，Java并发集合等。所以深思之后打算写一个系列，记录从学校到工作自己对多线程的
Java多线程 线程ID 是从0开始吗?
Java持续实践
08-30 1219
文章目录线程ID 线程ID 线程Id : 线程的id 是每一个往上累加的,注意是从1开始的, id是无法修改的. 类似于mysql数据库中自增的id , 如下的代码, 演示了线程id的打印. 首先打印出主线程. 再打印子线程的id /** * 类名称:Id * 类描述: ID从1开始，JVM运行起来后，我们自己创建的线程的ID早已不是2. * * @author: https://javaweixin6.blog.csdn.net/ * 创建时间:2020/8/30 15:59 * Versi
JAVA多线程实现和应用总结
weixin_34405354的博客
01-09 469
最近在做代码优化时学习和研究了下JAVA多线程的使用，看了菜鸟们的见解后做了下总结。1.JAVA多线程实现方式JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。 2.继承Thread类实现多线程继承T...
Java多线程实战-从零手搓一个简易线程池(二)线程池实现与拒绝策略接口定义
热门推荐
qq_35716689的博客
03-27 24万+
在前面的文章中，我们讲解了任务堵塞队列的实现，这篇文章会基于任务堵塞队列实现一个简易的线程池，在后续的文章中，还会继续对本章编写的线程池进行功能扩展和优化。
【多线程-从零开始-壹】线程的五种创建方法
Yeeear的博客
08-03 2024
可以理解成更轻量的进程，也能解决[[01 计算机是如何工作的#^87b85a|并发编程]]的问题，但是创建/销毁的开销，要比进程更低。一旦某个线程抛出异常，这个时候，如果不能妥善处理，就可能导致整个进程都崩溃，因此其他线程就会随之崩溃。如果线程数目太多，比如超出了 CPU 核心数目，此时就无法在微观上完成所有线程的“），当滑稽老铁数目达到一定程度后，有些人就够不到桌子了，就吃不到了。如果只是“微观并发”，速度是没有提升的，真正能提升速度的是“后续执行这个任务的载体可以是线程，也可以是其他的东西。
【并发基础】一篇文章带你彻底搞懂Java线程中断的底层原理——interrupt()、interrupted()、isInterrupted()
小七的博客
04-23 4772
一篇文章带你彻底搞懂Java中断机制，从底层源码带你分析interrupt()的机制与用法。学习Java中断看这一篇就够了。
Java 多线程 —— 同步代码块（解决线程安全问题)
一纸春秋的博客
10-23 1万+
目录火车站抢票问题同步代码块同步方法（this锁）同步方法，在public的后面加上synchronized关键字this锁静态同步方法 火车站抢票问题 由于现实中买票也不会是零延迟的，为了真实性加入了延迟机制，也就是线程休眠语句 package test.MyThread.ticketDemo; public class RunnableThread implements Runnable{ private int ticket = 100; @Override public v
Java技术整理（3）—— 多线程并发篇
Zain_horse的博客
08-08 1014
多线程并发知识
Java并发多线程编程——FutureTask
2401_83330354的博客
05-05 833
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
【多线程-从零开始-叁】线程的核心操作
Yeeear的博客
08-04 1288
线程的核心操作详解
Java从零开始学多线程——1.Java线程的几种状态
JAVA求生之路——博主406766467
12-27 125
线程的状态： 1.初始状态 NEW 线程刚被new出来，没有调用start()方法 2.运行状态 Runnable 处于可运行状态，在jvm里执行，可能在等待来自操作系统的其他资源 //Runnable状态 Thread thread = new Thread(()->{ try { System.in.read(); } catch (IOException e) { e.printStackTrace();
Java从零开始学多线程——4.线程的优先级
JAVA求生之路——博主406766467
12-28 157
线程的优先级告诉程序该线程的重要程度有多大。如果有大量线程都被堵塞，都在等候运行，程序会尽可能地先运行优先级的那个线程。 但是，这并不表示优先级较低的线程不会运行。若线程的优先级较低，只不过表示它被准许运行的机会小一些而已。 线程的优先级设置可以为1-10的任一数值 Thread类中定义了三个线程优先级，分别是： MIN_PRIORITY（1）、NORM_PRIORITY（5）、MAX_PRIORITY（10） 一般情况下推荐使用这几个常量，不要自行设置数值。 不同平台，对线程的优先级的支持不同。 编程的时
Java从零开始学多线程——9.容器
JAVA求生之路——博主406766467
01-05 143
同步容器与并发容器简介 同步容器 Vector、HashTable -- JDK提供的同步容器类​ Collections.synchronizedXXX 本质是对相应的容器进行包装 同步容器类的缺点 在单独使用里面的方法的时候，可以保证线程安全，但是，复合操作需要额外加锁来保证线程安全​ 使用Iterator迭代容器或使用使用for-each遍历容器，在迭代过程中修改容器会抛出ConcurrentModificationException异常。想要避免出现ConcurrentModificationE
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1398
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
spring task的使用场景
qq_40603125的博客
10-13 70
spring任务调度框架约定的时间。
Backend - Java 基础
是萝卜干呀的博客
10-11 552
知识量决定了未来能走多远
Netty 相比原生IO模型的优势
lssffy的博客
10-09 624
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
Hex编码
最新发布
weixin_74305514的博客
10-13 86
emps;是一种将数据转换为十六进制表示的方法。Hex编码使用16个字符来表示数据。&emps;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值