Java多线程

最新推荐文章于 2025-05-28 08:53:03 发布
最新推荐文章于 2025-05-28 08:53:03 发布
阅读量183 收藏
点赞数
分类专栏： Java 文章标签： 多线程 java thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_44095347/article/details/109283296
版权

概念

进程是指可执行程序并存放在计算机存储器的一个指令序列，它是一个动态执行的过程。

线程是比进程还要小的运行单位，一个进程包含多个线程

线程可以看成一个子程序

线程的创建

  • 创建一个Thread类，或者一个Thread子类的对象
  • 创建一个实现Runnable接口的类的对象
  • 两种方式
    • 通过继承Thread类创建线程（MyThread）- new MyThread().start()
    • 通过实现Runnable接口创建线程（MyRunnable）- new Thread(new MyRunnable()).start()

Thread类

是一个线程类，位于java.lang包下

构造方法和说明

  • Thread（），创建一个线程对象
  • Thread（String name），创建一个具有指定名称的线程对象
  • Thread（Runnable target），创建一个基于Runnable接口实现类的线程对象
  • Thread（Runnable terget ，String name），创建一个基于Runnable接口实现类，并且具有指定名称的线程对象
package com.dodoke.thread;
class MyThread extends Thread{
	public void run() {
		System.out.println(getName()+"该线程正在执行!");
	}
}
public class ThreadTest {
	public static void main(String[] args) {
//		System.out.println("主线程1");
		MyThread mt=new MyThread();
		mt.start();//启动线程,不是调用run方法,但是运行的还是run方法,一个线程只能启动一次
		mt.start();//编译正常，运行时抛出异常,不合逻辑的线程状态,不能多次调用,只能启动一次
//		System.out.println("主线程2");
	}
}

package com.dodoke.thread1;
class MyThread extends Thread{
	public MyThread(String name) {
		super(name);
	}
	public void run() {
		for(int i=1;i<=10;i++) {
			System.out.println(getName()+"正在运行"+i);
		}
	}
}
public class ThreadTest {
	public static void main(String[] args) {
		MyThread mt1=new MyThread("线程1");
		MyThread mt2=new MyThread("线程2");
		mt1.start();
		mt2.start();//运行结果都是随机的
		//线程获取cpu的使用权时随机的,线程运行的结果会有很多种不同的情况
	}
}

常用方法

  • public void run（）--线程相关的代码写在该方法中，一般需要重写
  • public void start（）--启动线程的方法
  • public static void sleep（long m）--线程休眠m毫秒的方法
  • public void join（）--优先执行调用join（）方法的线程

Runnable接口

  • 只有一个方法run（）
  • Runnable是Java中用以实现线程的接口
  • 任何实现线程功能的类都必须实现该接口
package com.dodoke.runnable;
class PrintRunnable implements Runnable{
	int i=1;//将i变成成员变量,运行结果少了
	@Override
//	run方法中的代码可以被多个线程共享,多个线程就是Thread类的实例
	public void run() {
//		int i=1;
		while(i<=10) {
			System.out.println(Thread.currentThread().getName()+"正在运行"+(i++));
	}
}
}
public class Test {
	public static void main(String[] args) {
		PrintRunnable pr=new PrintRunnable();//先定义runnable的实现类对象
		Thread t1=new Thread(pr);//创建线程类的对象
		t1.start();//启动线程
		
//		PrintRunnable pr1=new PrintRunnable();
//		pr1和pr2的运行结果没什么变化
//		Thread t2=new Thread(pr1);
		Thread t2=new Thread(pr);
		t2.start();
	}
}

线程创建

通过继承Thread类的方法创建该线程类，重写run（）方法

通过实现Runnable接口的方法创建

为什么实现Runnable接口--Java不支持多继承，不打算重写Thread类的其他方法

线程的状态

新建（New）、可运行（Runnable）、正在运行（Running）、阻塞（Blocked）、终止（Dead）

线程的生命周期

sleep方法的应用

  • Thread类的方法----- public static void sleep（long millis）
  • 作用：在指定的毫秒数内让正在执行的线程休眠（暂停执行）
  • 参数为休眠的时间，单位是毫秒
package com.dodoke.sleep;

class MyThread implements Runnable{

	@Override
	public void run() {
		for(int i=1;i<=30;i++) {
			System.out.println(Thread.currentThread().getName()+"执行第"+i+"次!");
			try {
				Thread.sleep(1000);//1000毫秒
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	
}
public class SleepDemo {
	public static void main(String[] args) {
		MyThread mt=new MyThread();
		Thread t=new Thread(mt);
		t.start();
		Thread t1=new Thread(mt);
		t1.start();
	}
}

join方法的应用

  • Thread类的方法----- public final void join（）
  • 作用：等待调用该方法的线程结束后才能执行
  • Thread类的方法----- public final void join（long millis）
  • 作用：等待该线程终止的最长时间为millis毫秒
package com.dodoke.join;
class MyThread extends Thread{
	public void run() {
		for(int i=1;i<=500;i++) {
			System.out.println(getName()+"正在执行"+i+"次!");
		}
	}
}
public class JoinDemo {
	public static void main(String[] args) {
		MyThread mt=new MyThread();
		mt.start();
		try {
			mt.join(1);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		for(int i=1;i<=20;i++) {
			System.out.println("主线程运行第"+i+"次!");
		}
	}
}

线程优先级

  • Java为线程类提供了10个优先级
  • 优先级可以用整数1-10表示，超出范围会抛出异常
  • 主线程默认优先级为5
  • 优先级常量
    • MAX_PRIORITY：线程的最高优先级10
    • MIN_PRIORITY：线程的最低优先级1
    • NORM_PRIORITY：线程的默认优先级5
  • 优先级的方法
    • public int getPriority（）-- 获取线程优先级的方法
    • public void setPriority（int newPriority）-- 设置线程优先级的方法
package com.dodoke.priority;

class MyThread extends Thread{
	private String name;
	public MyThread(String name) {
		this.name=name;
	}
	public void run() {
		for(int i=1;i<=50;i++) {
			System.out.println("线程"+name+"正在运行"+i);
		}
	}
}
public class PriorityDemo {
	public static void main(String[] args) {
		//获取主线程的优先级
		int mainPriority=Thread.currentThread().getPriority();
//		System.out.println("主线程的优先级为:"+mainPriority);
		MyThread mt1=new MyThread("线程1");
		MyThread mt2=new MyThread("线程2");
//		mt1.setPriority(10);
		mt1.setPriority(Thread.MAX_PRIORITY);
		mt2.setPriority(Thread.MIN_PRIORITY);
		mt2.start();
		mt1.start();
//		System.out.println("线程1的优先级为："+mt1.getPriority());
	}
}

多线程运行问题

  • 各个线程是通过竞争CPU时间而获得运行机会的
  • 各线程什么时候得到CPU时间，占用多久，是不可预测的
  • 一个正在运行着的线程在什么地方被暂停是不确定的

同步

synchronized关键字用在成员方法，静态方法，语句块

public synchronized void saveAccount(){}

public static synchronized void saveAccount(){}

synchronized (obj){......}

线程间通信

  • wait()方法：中断方法的执行，使线程等待
  • notify()方法：唤醒处于等待的某一个线程，使其结束等待
  • notifyAll()方法：唤醒所有处于等待的线程，使它们结束等待

银行存取款问题

package com.dodoke.bank;

public class Bank {
	private String account;//账号
	private int balance;//账户余额
	public Bank(String account, int balance) {
		this.account = account;
		this.balance = balance;
	}
	public String getAccount() {
		return account;
	}
	public void setAccount(String account) {
		this.account = account;
	}
	public int getBalance() {
		return balance;
	}
	public void setBalance(int balance) {
		this.balance = balance;
	}
	@Override
	public String toString() {
		return "Bank [账号:" + account + ", 余额:" + balance + "]";
	}
	//存款
	public synchronized void saveAccount() {
		//可以在不同的位置处添加sleep方法
		//获取当前的账号余额
		int balance=getBalance();
		try {
			Thread.sleep(1000);
		}catch(InterruptedException e) {
			e.printStackTrace();
		}
		//修改余额,存100元
		balance+=100;
		//修改账户余额
		setBalance(balance);
		//输出存款后的账户余额
		System.out.println("存款后的账户余额为:"+balance);
	}
	public void drawAccount() {
		synchronized(this) {
		//可以在不同的位置处添加sleep方法
		//获得当前的账户余额
		int balance=getBalance();
		//修改余额,取200
		balance=balance-200;
		try {
			Thread.sleep(1000);
		}catch(InterruptedException e){
			e.printStackTrace();
		}
		//修改账户余额
		setBalance(balance);
		System.out.println("取款后的账户余额为:"+balance);
		}
	}
}

package com.dodoke.bank;
//取款
public class DrawAccount implements Runnable{
	Bank bank;
	public DrawAccount(Bank bank) {
		this.bank=bank;
	}
	public void run() {
		bank.drawAccount();
	}
}

package com.dodoke.bank;
//存款
public class SaveAccount implements Runnable{
	Bank bank;
	public SaveAccount(Bank bank) {
		this.bank=bank;
	}
	public void run() {
		bank.saveAccount();
	}

}

package com.dodoke.bank;

public class Test {
	public static void main(String[] args) {
		//创建账户,给定余额为1000
		Bank bank=new Bank("1001",1000);
		//创建线程对象
		SaveAccount sa=new SaveAccount(bank);
		DrawAccount da=new DrawAccount(bank);
		Thread save=new Thread(sa);
		Thread draw=new Thread(da);
		save.start();
		draw.start();
		try {
			save.join();
			draw.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(bank);
	}
}

生产和消费的问题（生产一个消费一个）

package com.dodoke.queue;

public class Consumer implements Runnable{
	Queue queue;
	public Consumer(Queue queue) {
		this.queue = queue;
	}

	@Override
	public void run() {
		while(true) {
			queue.get();
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

}

package com.dodoke.queue;

public class Producer implements Runnable{
	Queue queue;
	public Producer(Queue queue){
		this.queue=queue;
	}
	public void run() {
		int i=0;
		while(true) {
			queue.set(i++);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

}

package com.dodoke.queue;

public class Queue {
	private int n;
	boolean flag=false;
	
	public synchronized int get() {
		if(flag==false) {
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		System.out.println("消费："+n);
		flag=false;//消费完毕，容器中没有数据
		notifyAll();
		return n;
	}

	public synchronized void set(int n) {
		if(flag) {
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		System.out.println("生产："+n);
		this.n = n;
		flag=true;//生产完毕，容器中已经有数据
		notifyAll();
	}
	
}

package com.dodoke.queue;

public class Test {
	public static void main(String[] args) {
		Queue queue=new Queue();
		new Thread(new Producer(queue)).start();
		new Thread(new Consumer(queue)).start();
		
	}
}

 

Java 多线程
d18631089566的博客
08-15 3923
一，线程概述一，线程概述进程在一个操作系统中，每个独立执行的程序都可称为一个进程，也就是“正在运行的程序”。目前大部分计算机上安装的都是多任务操作系统，即能够同时执行多个应用程序。在计算机中，所有的应用程序都是由CPU执行的，对于一个CPU而言，在某个时间点只能运行一个程序，也就是说只能执行一个进程。线程每个运行的程序都是一个进程，一个进程中还可以有多个执行单元同时运行，这些执行单元可以看做程序执行的一条条线索，称为线程。操作系统中的每一个进程中都至少存在一个线程。当一个Java。
Java多线程面试题
tq02的博客
07-10 2718
线程的面试点问题
线程基础1
Myair_AC的博客
08-17 245
1 .给线程赋名字的两种方式: 通过调用父类的构造方法也可以给 线程赋值名字, 也可以this调用set方法 2 .自己写的类继承Thread的时候要注意,Thread 类中 setName 和 getName 是final修饰的只能被继承 ,不能被重写.继承类中name属性不用写. 3 . package com.qf.demo4;public class Test3
学习Java第二十四天
weixin_44962131的博客
07-12 277
Java多线程 线程的概念 进程的概念 进程是指可执行程序并存放在计算机存储器的一个指令序列，它是一个动态执行的过程（任务管理器中有一个进程，大家可以看到） 线程的概念 线程是比进程还要小的运行单位，一个进程包含多个线程，线程可以看做一个子程序 程序的运行依靠CPU 时间片的轮转概念 （3个软件轮流运行，由于时间很短，人感知不到，认为三个软件在同时运行） 线程的创建 创建一个 Thread 类，或者一个 Thread 子类的对象 创建一个实现 Runnable 接口的类的对象 Thread类 Th
多线程_获取和设置线程对象名称
辐_射的博客
03-08 2467
package cn.itcast_03; /* * 如何获取线程对象的名称呢? * public final String getName():获取线程名称。 * 如何设置线程对象的名称呢? * public final void setName(String name):设置线程的名称。 * * 针对不是继承Thread类的子类该如何获取线程名称呢? * publ
java语法基础之多线程
qq_50319351的博客
08-13 156
多线程的介绍 首先呢 我们介绍一下 进程： 一个正在运行的程序，有一定的独立功能 线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程 列入 在迅雷中下载任务，迅雷运行时属于进程，下载任务属于线程 程序的运行原理 分时调度 所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。 抢占式调度 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。 我们主要来看看抢占式 ...
java多线程
m0_46702681的博客
06-19 2477
javajava。
Java多线程并发编程技术详解
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-20 3万+
Java多线程并发编程是一项需要深入理解和熟练掌握的技术，只有合理地设计和使用多线程，才能真正发挥其在提升系统性能方面的巨大潜力。随着对Java并发机制及工具类库的深入学习和应用，开发者可以更好地构建高效、稳定的并发系统。
Java多线程实战-从零手搓一个简易线程池(二)线程池实现与拒绝策略接口定义
热门推荐
qq_35716689的博客
03-27 24万+
在前面的文章中，我们讲解了任务堵塞队列的实现，这篇文章会基于任务堵塞队列实现一个简易的线程池，在后续的文章中，还会继续对本章编写的线程池进行功能扩展和优化。
Java 多线程练习
qq_57570052的博客
07-28 2894
1.定时器操作（实现电脑定时关机）。2.每个月的月末(02:00:00)执行一次代码3.模拟售票模拟了多个线程同时售票的场景，保证了并发环境下的票的售卖过程的正确性和一致性。4.用15个线程实现，求123456789之间放+-和为100的表达式（11结果），如果一个线程求出结果， 立即告诉其它停止。
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
Java多线程Executors批量执行数据实现限流
05-20
Java多线程实现数据切割批量执行，实现限流操作。 java线程池Executors实现数据批量操作。 批量异步Executors处理数据，实现限流操作，QPS限流。 线程池调用第三方接口限流实现逻辑。 案例适合： 1.批量处理大数据。...
实战指南：理解 ThreadLocal 原理并用于Java 多线程上下文管理
张彦峰的博客
12-01 10万+
探讨如何基于实现一个高效的上下文管理组件，以解决多线程环境下的数据共享和上下文管理这些问题。通过具体的代码示例和实战展示如何为多线程编程提供一种简洁而高效的上下文管理方案。
【Netty系列】Netty 框架介绍
最新发布
技术改变世界
05-28 417
Netty是一个基于 Java NIO（Non-blocking I/O）的异步事件驱动网络应用框架，旨在快速开发高性能、高可靠性的网络服务器和客户端。它简化了 TCP/UDP 等协议的编程，并提供了高度可定制的组件，适用于高并发场景（如游戏服务器、即时通讯、分布式系统等）。
springboot--实战--大事件--用户接口开发
m0_73856804的博客
05-27 1745
定义了一种简洁的、自包含的格式，用于通信双方以JSON数据格式安全的传输信息。组成：第一部分：Header（头），记录令牌类型、签名算法等。例如,算法用于防篡改第二部分：Payload（有效载荷），携带一些自定义信息，默认信息。例如。而外在表示为一段无规律的64个可打印字符原因：借助base64编码方式（Base64：是一种基于64个可打印字符（A-Z a-z 0-9 + /）来表示二进制数据的编码方式）来完成，将json字符串变为64个可打印字符，
计算机组成原理——cache
Yan_ks的博客
05-27 812
本文介绍了cache的工作原理及优化策略。主要内容包括：1)局部性原理(时间/空间局部性)，以程序示例说明访问顺序对性能的影响；2)cache组成与访问流程，包括命中率计算和地址映射关系；3)三种映射方式(直接、全相联、组相联)的实现原理；4)替换算法(LRU、随机、FIFO)的选择标准；5)两种写策略组合(全写+非写分配、回写+写分配)的特点及应用场景。通过cache设计有效利用局部性原理，可显著提升CPU访存效率。
LangChain4j 项目实战——idea快捷键搜索
modelmd的博客
05-25 628
LangChain4j 项目实战
Java多线程编程详解
Java多线程机制提供了强大的并发能力，允许开发者编写高效的并发程序。理解和掌握这些知识点对于Java开发人员来说至关重要，有助于在实际项目中处理复杂的并发问题，提升程序的性能和用户体验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值