Java学习之路（十六）多线程

最新推荐文章于 2024-03-25 20:22:10 发布
最新推荐文章于 2024-03-25 20:22:10 发布
阅读量136 收藏
点赞数
分类专栏： Java 文章标签： Java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LionMain/article/details/97296985
版权

一、进程与线程

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

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

二、新建线程

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

public class TestMain extends Thread{
	public TestMain() {
		
	}
	
	public TestMain(String name) {
		super(name);
	}

	@Override
	public void run() {
		for(int i=1; i<=5; i++) {
			System.out.println(getName() + "正在执行第" + i +"次！");
		}
	}
	
	public static void main(String[] args) {
		TestMain testMain = new TestMain("线程1");
		TestMain testMain2 = new TestMain("线程2");
		
		testMain.start();
		testMain2.start();

	}

}
/* 运行结果：
线程2正在执行第1次！
线程1正在执行第1次！
线程1正在执行第2次！
线程2正在执行第2次！
线程1正在执行第3次！
线程2正在执行第3次！
线程2正在执行第4次！
线程2正在执行第5次！
线程1正在执行第4次！
线程1正在执行第5次！
*/
构造方法说明
Thread()创建一个线程对象
Thread(String name)创建一个具有指定名称的线程对象
Thread(Runnable target)创建一个基于Runnable接口实现类的线程对象
Thread(Runnable target, String name)创建一个基于Runnable接口实现类，并且具有指定名称的线程对象
常用方法说明
public void run()线程功能的实现
public void start()启动线程
public static void sleep(long m)线程休眠毫秒
public void join()优先执行调用join()方法的线程

方法二：实现Runnable接口重写run()方法。

public class TestMain2 implements Runnable {
	private String name;
	
	public TestMain2() {
		
	}
	
	public TestMain2(String name) {
		this.setName(name);
	}
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public void run() {
		for(int i=1; i<=5; i++) {
			System.out.println(this.getName() + "该线程正在执行！");
		}

	}

	public static void main(String[] args) {
		TestMain2 testMain = new TestMain2("线程1");
		TestMain2 testMain2 = new TestMain2("线程2");
		
		Thread thread = new Thread(testMain);
		Thread thread2 = new Thread(testMain2);
		
		thread.start();
		thread2.start();
		
	}

}
/* 运行结果：
线程2该线程正在执行！
线程2该线程正在执行！
线程2该线程正在执行！
线程1该线程正在执行！
线程2该线程正在执行！
线程1该线程正在执行！
线程1该线程正在执行！
线程1该线程正在执行！
线程1该线程正在执行！
线程2该线程正在执行！
*/

为什么推荐实现Runnale接口？

  • Java不支持多继承
  • 不需要重写Thread类的其他方法

方法三：实现callable接口，重写call()方法，call()作为线程的执行体，具有返回值，并且可以对异常进行声明和抛出；使用start()方法来启动线程。

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

public class TestMain3 implements Callable<String> {
	private String name;
	
	public TestMain3() {
		
	}
	
	public TestMain3(String name) {
		this.setName(name);
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public static void main(String[] args) {
		Callable<String> callable = new TestMain3("线程1");
		Callable<String> callable2 = new TestMain3("线程2");
		
		FutureTask<String> futureTask = new FutureTask<>(callable);
		FutureTask<String> futureTask2 = new FutureTask<>(callable2);
		
		Thread thread = new Thread(futureTask);
		Thread thread2 = new Thread(futureTask2);
		
		// 启动线程
		thread.start();
		thread2.start();
		
		// 获取call方法的返回值，先启动线程才可以获取到call的返值
		try {
			futureTask.get();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
		
		try {
			futureTask2.get();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}

	}

	@Override
	public String call() throws Exception {
		for(int i=1; i<=5; i++) {
			System.out.println(this.getName() + "该线程正在执行！");
		}
		return null;
	}

}
/* 运行结果
线程2该线程正在执行！
线程2该线程正在执行！
线程2该线程正在执行！
线程2该线程正在执行！
线程1该线程正在执行！
线程1该线程正在执行！
线程1该线程正在执行！
线程1该线程正在执行！
线程1该线程正在执行！
线程2该线程正在执行！
*/

三、线程状态

  • 新建（New）
    • 进入可运行状态：调用start()方法
    • 进行终止状态：调用stop()方法
  • 可运行（Runnable）
    • 进入正在运行状态：获取cpu使用权
    • 进入终止状态：调用stop()方法
  • 正在运行（Running）
    • 进入可运行状态
      • 时间片用完
      • 调用yield()方法
    • 进入阻塞状态
      • 调用join()方法
      • 调用wait()方法
      • 调用sleep()方法
      • 进行I/O请求
    • 进入终止状态
      • 终程执行完毕
      • 异常终止
      • 调用stop()方法
  • 阻塞（Blocked）
    • 进入可运行状态
      • 等待调用join()的线程执行完毕
      • 调用notify()或notifyAll()方法
      • sleep超时
      • I/O请求完成
    • 进入终止状态：调用stop()方法
  • 终止（Dead）

e006Zn.png

四、线程常用方法

方法：public static void sleep(long millis)

参数：休眠的时间，单位是毫秒

作用：在指定毫秒数内让正在执行的线程休眠（暂停执行）

public class TestMain2 implements Runnable {
	private String name;
	
	public TestMain2() {
		
	}
	
	public TestMain2(String name) {
		this.setName(name);
	}
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public void run() {
		for(int i=1; i<=5; i++) {
			System.out.println(this.getName() + "该线程正在执行！");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}

	public static void main(String[] args) {
		TestMain2 testMain = new TestMain2("线程1");
		TestMain2 testMain2 = new TestMain2("线程2");
		
		Thread thread = new Thread(testMain);
		Thread thread2 = new Thread(testMain2);
		
		thread.start();
		thread2.start();
		
	}

}

方法：public final void join()

作用：等待调用该方法的线程结束后才能执行

public class TestJoin {
	
	public void myTest() {
		for(int i=1; i<5; i++) {
			System.out.println("方法线程运行！");
		}
	}

	public static void main(String[] args) {
		TestJoin testJoin = new TestJoin();
		// TestMain类请看新建线程方法一
		TestMain testMain = new TestMain();
		testMain.start();
		
		try {
			testMain.join(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		testJoin.myTest();
		
	}

}

/*运行结果：
Thread-0正在执行第1次！
方法线程运行！
方法线程运行！
方法线程运行！
方法线程运行！
Thread-0正在执行第2次！
Thread-0正在执行第3次！
Thread-0正在执行第4次！
Thread-0正在执行第5次！
*/

五、线程优先级

Java为线程类提供了 10 个优先级，优先级可以用整数 1~10 表示，超过范围会抛出异常，主线程默认优先级为 5。

  • MAX_PRIORITY：线程的最高优先级10
  • ：线程的最低优先级1
  • NORM_PRIORITY：线程的默认优先级5
常用方法说明
public int getPriority()获取线程优先级的方法
public void setPriority(int newPriority)设置线程优先级的方法
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class TestMain3 implements Callable<String> {
	private String name;
	
	public TestMain3() {
		
	}
	
	public TestMain3(String name) {
		this.setName(name);
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public static void main(String[] args) {
		Callable<String> callable = new TestMain3("线程1");
		Callable<String> callable2 = new TestMain3("线程2");
		
		FutureTask<String> futureTask = new FutureTask<>(callable);
		FutureTask<String> futureTask2 = new FutureTask<>(callable2);
		
		Thread thread = new Thread(futureTask);
		Thread thread2 = new Thread(futureTask2);
		
		// 修改优先级
		thread.setPriority(Thread.MIN_PRIORITY);
		thread2.setPriority(Thread.MAX_PRIORITY);
		
		// 启动线程
		thread.start();
		thread2.start();
		
		// 获取call方法的返回值，先启动线程才可以获取到call的返值
		try {
			futureTask.get();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
		
		try {
			futureTask2.get();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
		
		System.out.println("主线程的优选级" + Thread.currentThread().getPriority());
	}

	@Override
	public String call() throws Exception {
		//String string = this.getName() + "正在运行";
		for(int i=1; i<=5; i++) {
			System.out.println(this.getName() + "该线程正在执行！");
		}
		return null;
	}

}

/*运行结果
线程2该线程正在执行！
线程2该线程正在执行！
线程2该线程正在执行！
线程2该线程正在执行！
线程1该线程正在执行！
线程2该线程正在执行！
线程1该线程正在执行！
线程1该线程正在执行！
线程1该线程正在执行！
线程1该线程正在执行！
主线程的优选级5
*/

六、多线程运行问题

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

public class Bank {
	private String account;
	private int money;
	
	public Bank(String account, int money) {
		this.setAccount(account);
		this.setMoney(money);
	}

	public int getMoney() {
		return money;
	}

	public void setMoney(int money) {
		this.money = money;
	}

	public String getAccount() {
		return account;
	}

	public void setAccount(String account) {
		this.account = account;
	}

	@Override
	public String toString() {
		return "Bank [帐户：" + getAccount()  + ", 金钱：" + getMoney()+ "]";
	}
	
	public void save() {
		int balance = getMoney();
		
		
//		try {
//			Thread.sleep(1000);
//		} catch (InterruptedException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
        
		balance += 1;
		setMoney(balance);
		
		System.out.println("存款+1");
	}
	
	public void load() {
		int balance = getMoney();
		balance -= 1;
		
//		try {
//			Thread.sleep(1000);
//		} catch (InterruptedException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
		
		setMoney(balance);
		
		System.out.println("取款-1");
	}
	
}

public class Save implements Runnable {
	
	Bank bank;
	
	public Save(Bank bank) {
		this.bank = bank;
	}
	

	@Override
	public void run() {
		bank.save();
		
	}

}

public class Load implements Runnable {
	Bank bank;
	
	public Load(Bank bank) {
		this.bank = bank;
	}
	

	@Override
	public void run() {
		bank.load();

	}

}

public class TestMain4 {

	public static void main(String[] args) {
		// 创建测试对象，给定金额10
		Bank bank = new Bank("001", 10);
		
		// 创建线程对象
		Thread save = new Thread(new Save(bank));
		Thread load = new Thread(new Load(bank));
		
		// 开启线程
		save.start();
		load.start();
		
		// 保证存取款的线程先执行
		try {
			save.join();
			load.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		System.out.println("原金额：10，" + bank);
		
	}

}
/* 运行结果：
取款-1
存款+1
原金额：10，Bank [帐户：001, 金钱：10]

当将sleep(1000)方法反注释后，得到运行结果
取款-1
存款+1
原金额：10，Bank [帐户：001, 金钱：11]
*/

为什么会出现这种情况呢？其实，这就涉及到了一个同步的问题，我们可以假设，存款的线程可能执行到balance += 1 = 11 处就被暂停，转而先去执行取款线程，这时候因为存的钱还没同步到帐户上，此时的balance -= 1 = 9，钱是算上来了，也同步去了，但是没有任意，当Bank回到存款操作时，因为原先的balance += 1 = 11己经运算完成，当同步到帐号时，你的金额就变成了11。

当然，这也只是其中的一种猜测而己，但是，从上面的猜测中我们可以得出一个结论：没有同步的线程很不可靠。

那么，如何解决这个问题呢？很简单，我们要对Bank对象进行锁定，保证在取款或存款的时候，不允许其它的线程对帐户余额进行操作。

如何实现呢？使用synchronized关键字。

synchronized关键字用在：

  • 成员方法
  • 静态方法
  • 语句块

比如说，我们给存取款方法加上synchronized关键字：

public synchronized void save() {
    int balance = getMoney();
    balance += 1;

    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    setMoney(balance);

    System.out.println("存款+1");
}

public synchronized void load() {
    int balance = getMoney();
    balance -= 1;

    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    setMoney(balance);

    System.out.println("取款-1");
}

/*
存款+1
取款-1
原金额：10，Bank [帐户：001, 金钱：10]
*/

嗯，结果正常了！

七、线程通信

常用方法说明
wait()中断方法的执行，使线程等待
notify()唤醒处于等待的某一个线程
notityAll()唤醒全部处于等待的线程

有两个线程，一个打印数字，从1-52，另一个打印字母，从A-Z，使用线程通信，按12A34B……5152Z的格式进行印。

public class TestMain {
	
	public synchronized void printEng() {
		int count = 0;
		for (char c='A'; c<='Z'; c++) {
			if (count == 1) {
				try {
					wait();
					count = 0;
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.print(c);
			count += 1;
			notifyAll();
		}
	}
	
	public synchronized void printNum() {
		int count = 0;
		for (int i=1; i<=52; i++) {
			if (count == 2) {
				try {
					wait();
					count = 0;
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.print(i);
			count += 1;
			notifyAll();

		}
	}
	

	public static void main(String[] args) {
		TestMain testMain = new TestMain();
		Thread thread = new Thread(new Print1(testMain));
		Thread thread2 = new Thread(new Print2(testMain));
		
		thread.start();
		thread2.start();
		
		try {
			thread2.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

	}

}

public class Print1 implements Runnable{
	
	TestMain testMain;
	
	public Print1(TestMain testMain) {
		this.testMain = testMain;
	}

	@Override
	public void run() {
		testMain.printNum();
		
	}

}

public class Print2 implements Runnable {
	TestMain testMain;
	
	public Print2(TestMain testMain) {
		this.testMain = testMain;
	}

	@Override
	public void run() {
		testMain.printEng();
		
	}

}

运行结果：

12A34B56C78D910E1112F1314G1516H1718I1920J2122K2324L2526M2728N2930O3132P3334Q3536R3738S3940T4142U4344V4546W4748X4950Y5152Z

首先，这个题目很明显，就是按照2个数字打印1个字母的顺序进行打印，那么，解法也就很明显了。

  1. 编写printEng和printNum方法，实现打印字母和数字的功能。
  2. 实现Runnable接口创建两个类，分别为printEng和printNum方法实现多线程。
  3. 修改printEng和printNum方法，实现同步，暂停和激活功能。
LionMain
关注
专栏目录
Java多线程学习Java多线程学习Java多线程学习Java多线程学习.txt
05-15
Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java...
Java-学习多线程总结上
12-22
所以在进程之上的进一步划分就变得非常的重要，而且性能也会有所提高，所有的线程一定要依附进程才能够存在，那么进程一旦消失，线程也一定会消失，但反过来不一定，而Java是支持多线程的开发语言之一。 2. 多线程的...
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 42万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
qq_35716689的博客
03-10 25万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java多线程（超详细！）
一只小菜鸡
05-13 13万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
Java多线程超详解
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
Java多线程实战-异步操作日志记录解决方案(AOP+注解+多线程)
qq_35716689的博客
03-16 25万+
异步日志记录是一种提升系统性能和可维护性的有效手段。牵着猫散步的鼠鼠。通过将日志记录操作异步化，不仅可以减少对业务处理流程的影响，还可以提高日志处理的灵活性和扩展性。然而，实现异步日志记录机制也伴随着一定的挑战，如日志的实时性、顺序性和丢失风险等问题。
编程必备：JAVA多线程详解
拾一二的博客
06-14 8601
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
Java多线程实战-从零手搓一个简易线程池(一)定义任务等待队列
qq_35716689的博客
03-25 24万+
开个新坑-手搓简易线程池。本系列文章将从零开始,一步步手工编码实现一个简单但功能完备的线程池。我们将逐步介绍线程池的各个核心组件,并分析它们的作用和实现思路。通过这个过程,我们可以更好地掌握多线程编程的技巧,并培养编码能力和系统性思维。
【Java系列】深入解析Java多线程
颜淡慕潇
05-09 2万+
Java多线程是提高程序并发性和响应能力的重要手段，需要掌握多线程的实现方式、同步机制、线程之间的通信机制等，以确保多线程程序的正确性和稳定性。
Java学习路线总结，搬砖工逆袭Java架构师
学Java，找哪吒
09-07 25万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
Java多线程并发编程技术详解
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-20 3万+
Java多线程并发编程是一项需要深入理解和熟练掌握的技术，只有合理地设计和使用多线程，才能真正发挥其在提升系统性能方面的巨大潜力。随着对Java并发机制及工具类库的深入学习和应用，开发者可以更好地构建高效、稳定的并发系统。
java多线程设计模式_java_设计模式_多线程_多线程课题_
09-29
Java多线程设计模式是Java开发中的核心概念，它涉及到如何高效、安全地在多个执行线程之间共享资源和协调任务。...通过阅读《java多线程设计模式》这本书，你可以深入理解这些概念，并学习到更多实际应用的案例。
Java之多线程学习代码
05-06
这个“Java之多线程学习代码”压缩包很可能是包含了一系列用于教学和实践的示例代码，帮助开发者深入理解Java多线程的概念、机制以及实际应用。 Java中的多线程允许程序同时执行多个任务，这极大地提高了应用程序的...
Java多线程学习总结
09-14
Java多线程是编程中的重要概念，尤其在开发高并发、高性能的应用时不可或缺。本文将深入探讨Java中的线程和进程，以及如何在Java中实现多线程。 首先，理解线程和进程的概念至关重要。线程是操作系统分配CPU时间片...
numcodecs-0.10.0-cp39-cp39-win_amd64.whl
10-19
numcodecs-0.10.0-cp39-cp39-win_amd64.whl
【BP时序预测】基于雾凇优化算法RIME-BP实现负荷数据预测单输入单输出附matlab代码.rar
10-20
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
【JCR一区级】Matlab实现北方苍鹰优化算法NGO-CNN-BiLSTM-Attention的故障诊断算法研究.rar
最新发布
10-20
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
双碳数字化平台及场景应用解决方案（28页 PPT）.pptx
10-19
双碳数字化平台及场景应用解决方案（28页 PPT）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值