Java应用编程_多线程（基本知识&同步与死锁&生产者消费者模型&守护进程...）

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量198 收藏 1
点赞数
分类专栏： Java SE（持续更新） 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_17852541/article/details/106602255
版权

总览

在这里插入图片描述

其他文章链接

【Java编程基础_注解与命名规则&数据类型&运算符&修饰符&流程控制】
【Java面向对象编程_方法&类与对象&数组&String类】
【Java面向对象编程_抽象类&接口&包装类&泛型】
【Java面向对象编程_包&访问控制权限&构造方法私有化&枚举】
【Java面向对象编程_异常的捕获与处理】
【Java面向对象编程_内部类】

本文目录

1，进程与线程，与多线程有关的类

在这里插入图片描述

demo_多线程接口使用

package cn.thread.demo;
import java.util.concurrent.*;
//版本1：利用Thread类定义多线程主体类
//class MyThread extends Thread{
//	private String title;
//	public MyThread(String title){
//		this.title=title;
//	}
//	@Override
//	public void run() {
//		for (int i = 0; i < 10; i++) {
//			System.out.println(this.title+",x="+i);
//		}
//	}
//}
//版本2.0：利用Runnable函数式接口定义多线程主体类
//class MyRunnable implements Runnable{
//	private String name;
//	
//	public MyRunnable(String name) {
//		super();
//		this.name = name;
//	}
//
//	@Override
//	public void run() {
//		for (int i = 0; i < 10; i++) {
//			System.out.println(name+",x="+i);
//		}
//	}
//}
//版本3：利用Callable接口来定义线程主体类
class MyMath implements Callable<String>{
	@Override
	public String call() throws Exception {
		for (int j = 0; j < 10; j++) {
			System.out.println("x="+j);
		}
		return "线程结束";
	}
}


public class ThreadDemo {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
//版本1：客户端启动多线程对象
//		new MyThread("线程1").start();
//		new MyThread("线程2").start();
//		new MyThread("程序3").start();
//版本2.0：客户端利用Thread构造方法接收Runnable类的特性启动多线程对象
//		new Thread(new MyRunnable("线程1")).start();
//		new Thread(new MyRunnable("线程2")).start();
//		new Thread(new MyRunnable("线程3")).start();
//		new Thread(new MyRunnable("线程4")).start();
//版本2.1：Runnable函数式接口可以用Lambda来简化定义
//		for(int i=1;i<4;i++){
//			String title="线程"+i;
//			Runnable ru=()->{
//				for (int j = 0; j < 10; j++) {
//					System.out.println(title+",x="+j);
//				}
//			};	
//			new Thread(ru).start();
//		}
//版本2.2：进一步用Lambda简化定义，public Thread(Runnable run)
//		for (int i = 1; i < 4; i++) {
//			String title="线程"+i;
//			new Thread(()->{
//				for (int j = 0; j < 10; j++) {
//					System.out.println(title+",x="+j);
//				}				
//			}).start();
//		}
//版本3：Callable
		FutureTask<String> task =new FutureTask<>(new MyMath());
		new Thread(task).start();
		System.out.println("返回信息："+task.get());
	}

}

2，多线程运行状态，Thread类中多线程常用操作方法

在这里插入图片描述

demo_线程常用操作1

package cn.thread.demo;

public class 线程常用操作 {

	public static void main(String[] args) {
		System.out.println("程序开始执行");
//		long data=0;
//		for (int i = 0; i < Integer.MAX_VALUE; i++) {
//			data+=i;
//		}
//通过子线程来运行运算时间长的代码块，主线程运行整体代码块来实现程序不延迟的效果
		new Thread(()->{
			long data=0;
			for (int i = 0; i < Integer.MAX_VALUE; i++) {
				data+=i;
			}
			System.out.println(Thread.currentThread().getName());
			try {
				Thread.sleep(1000);
			} catch (Exception e) {
				e.printStackTrace();
			}
			System.out.println("线程执行结束");
		},"线程1").start();

		System.out.println("程序结束执行");

	}
}

运行结果（不唯一）

程序开始执行
程序结束执行
线程1
线程执行结束

demo_线程常用操作2

package cn.thread.demo;

public class 线程相关操作 {

	public static void main(String[] args)throws Exception {
		Thread main=Thread.currentThread();
		Thread thread=new Thread(()->{
			for (int i = 0; i <50; i++) {
				if(i<=7){
					Thread.yield();//子线程礼让主线程
					System.out.println("子线程礼让");
				}
				if(i>=10){
					try {
						main.join();//main线程强制执行
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
					System.out.println("子线程x="+i);
				
			}
		});
		thread.setPriority(Thread.MAX_PRIORITY);
		thread.start();
		
		for(int x=0;x<50;x++){
			System.out.println("主线程执行：主线程x="+x);
		}

	}

}

运行结果（不唯一）

子线程礼让
主线程执行：主线程x=0
子线程x=0
子线程礼让
主线程执行：主线程x=1
子线程x=1
子线程礼让
主线程执行：主线程x=2
子线程x=2
子线程礼让
主线程执行：主线程x=3
子线程x=3
子线程礼让
主线程执行：主线程x=4
子线程x=4
子线程礼让
主线程执行：主线程x=5
子线程x=5
子线程礼让
主线程执行：主线程x=6
子线程x=6
子线程礼让
主线程执行：主线程x=7
子线程x=7
主线程执行：主线程x=8
子线程x=8
主线程执行：主线程x=9
子线程x=9
主线程执行：主线程x=10
主线程执行：主线程x=11
主线程执行：主线程x=12
主线程执行：主线程x=13
主线程执行：主线程x=14
主线程执行：主线程x=15
主线程执行：主线程x=16
主线程执行：主线程x=17
主线程执行：主线程x=18
主线程执行：主线程x=19
主线程执行：主线程x=20
主线程执行：主线程x=21
主线程执行：主线程x=22
主线程执行：主线程x=23
主线程执行：主线程x=24
主线程执行：主线程x=25
主线程执行：主线程x=26
主线程执行：主线程x=27
主线程执行：主线程x=28
主线程执行：主线程x=29
主线程执行：主线程x=30
主线程执行：主线程x=31
主线程执行：主线程x=32
主线程执行：主线程x=33
主线程执行：主线程x=34
主线程执行：主线程x=35
主线程执行：主线程x=36
主线程执行：主线程x=37
主线程执行：主线程x=38
主线程执行：主线程x=39
主线程执行：主线程x=40
主线程执行：主线程x=41
主线程执行：主线程x=42
主线程执行：主线程x=43
主线程执行：主线程x=44
主线程执行：主线程x=45
主线程执行：主线程x=46
主线程执行：主线程x=47
主线程执行：主线程x=48
主线程执行：主线程x=49
子线程x=10
子线程x=11
子线程x=12
子线程x=13
子线程x=14
子线程x=15
子线程x=16
子线程x=17
子线程x=18
子线程x=19
子线程x=20
子线程x=21
子线程x=22
子线程x=23
子线程x=24
子线程x=25
子线程x=26
子线程x=27
子线程x=28
子线程x=29
子线程x=30
子线程x=31
子线程x=32
子线程x=33
子线程x=34
子线程x=35
子线程x=36
子线程x=37
子线程x=38
子线程x=39
子线程x=40
子线程x=41
子线程x=42
子线程x=43
子线程x=44
子线程x=45
子线程x=46
子线程x=47
子线程x=48
子线程x=49

Process finished with exit code 0

3，线程的同步与死锁

在这里插入图片描述

demo_线程同步

package cn.thread.demo;
class MyThread implements Runnable{
	private int ticket=10;
	@Override
	public void run() {
		for (int i=0;i<5;i++){//假设每个票贩子有买5次票的能力
			synchronized(this){
				while (true) {
					if(this.ticket>0){
						try {
							Thread.sleep(100);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						System.out.println(Thread.currentThread().getName()+",卖票,ticket="+this.ticket--);
						break;
					}else{
						System.out.println(Thread.currentThread().getName()+"票卖完了");
						break;
					}
				}
			}
		}
	}
}
	
public class 线程同步操作 {

	public static void main(String[] args) {
		MyThread mt=new MyThread();
		new Thread(mt,"票贩子1").start();
		new Thread(mt,"票贩子2").start();
		new Thread(mt,"票贩子3").start();
	}

}

demo_线程死锁

package cn.thread.demo;
public class 死锁案例 {
    private static String resource_a = "A";
    private static String resource_b = "B";

    public static void main(String[] args) {
        deadLock();
    }

    public static void deadLock() {
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (resource_a) {
                    System.out.println(Thread.currentThread().getName()+"get resource a");
                    try {
                        Thread.sleep(3000);
                        synchronized (resource_b) {
                            System.out.println(Thread.currentThread().getName()+"get resource b");
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        },"线程1");
        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (resource_b) {
                    System.out.println(Thread.currentThread().getName()+"get resource b");
                    synchronized (resource_a) {
                        System.out.println(Thread.currentThread().getName()+"get resource a");
                    }
                }
            }
        },"线程2");
        threadA.start();
        threadB.start();

    }
}

运行结果

线程2get resource b
线程1get resource a
（程序停滞）

4，案例：生产者消费者模型

在这里插入图片描述

demo_生产者消费者模型

//数据不匹配问题：同步方法解决，数据重复操作问题：线程等待与唤醒解决
package cn.thread.demo;
public class 生产者消费者模型 {
	public static void main(String[] args) {
		Message msg=new Message();
		new Thread(new Producer(msg)).start();
		new Thread(new Consumer(msg)).start();
	}
}
class Message{
	private String title;
	private String content;
	private boolean flag=true;
	//true=生产者生产，false=消费者消费
	public synchronized String get() {
		if(flag==true){
			try {
				super.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		flag=true;
		super.notify();
		return this.title+"--"+this.content;
	}
	public synchronized void set(String title,String content) {
		if(flag==false){
			try {
				super.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.title = title;
		this.content=content;
		flag=false;
		super.notify();
	}
}
class Producer implements Runnable{
	private Message msg;
	
	public Producer(Message msg) {
		super();
		this.msg = msg;
	}

	@Override
	public void run() {
		for (int i = 0; i < 50; i++) {
			if(i%2==0){
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				msg.set("偶数标题","偶数内容");
			}else{
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				msg.set("奇数标题","奇数内容");
			}
		}
	}
}
class Consumer implements Runnable{
	private Message msg;
	public Consumer(Message msg) {
		super();
		this.msg = msg;
	}
	@Override
	public void run() {
		for(int i=0;i<50;i++){
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(msg.get());
		}
	}	
}

运行结果

偶数标题--偶数内容
奇数标题--奇数内容
偶数标题--偶数内容
奇数标题--奇数内容
偶数标题--偶数内容
奇数标题--奇数内容
偶数标题--偶数内容
奇数标题--奇数内容
（重复以上内容50次）

5，优雅地停止线程

在这里插入图片描述

demo_优雅地停止线程

package cn.thread.demo;
public class 优雅地停止线程 {
	private static boolean flag=true;
	public static int count=0;
	public static void main(String[] args) {
		new Thread(()->{
			while(flag){
				System.out.println("线程运行"+(++count));
			}
		}).start();
		try {
			Thread.sleep(12);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		flag=false;
	}

}

运行结果（不唯一）

线程运行1
线程运行2
线程运行3
线程运行4
线程运行5
（重复内容...）
线程运行63

Process finished with exit code 0

6，后台守护线程

在这里插入图片描述

demo_守护线程

package cn.thread.demo;

public class 守护线程 {

	public static void main(String[] args) {
		Thread thread= new Thread(()->{
			for (int i = 0; i < 2; i++) {
				try {
					Thread.sleep(100);
				} catch (Exception e) {
					e.printStackTrace();
				}
				System.out.println("用户线程");
			}
		});
		Thread daemonthread=new Thread(()->{
			for (int i = 0; i < Integer.MAX_VALUE; i++) {
				try {
					Thread.sleep(100);
				} catch (Exception e) {
					e.printStackTrace();
				}
				System.out.println("守护线程");
			}
		});
		daemonthread.setDaemon(true);
		thread.start();
		daemonthread.start();
	}

}

运行结果

守护线程
用户线程
用户线程
守护线程

Process finished with exit code 0

7，volatile关键字

在这里插入图片描述

demo_volatile关键字

package cn.thread.demo;
class MyThreadB implements Runnable{
	private volatile int ticket=5;
	@Override
	public void run() {
		synchronized (this){
			while(true){
				if(ticket>0){
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()+",ticket="+this.ticket--);
				}else{
					System.out.println(Thread.currentThread().getName()+"票卖完了");
					break;
				}
			}
		}
	}
}
public class Volatile关键字 {
	public static void main(String[] args)throws Exception {
		MyThreadB mt=new MyThreadB();
		new Thread(mt,"票贩子1").start();
		new Thread(mt,"票贩子2").start();
		new Thread(mt,"票贩子3").start();
	}

}

运行结果

票贩子1,ticket=5
票贩子1,ticket=4
票贩子1,ticket=3
票贩子1,ticket=2
票贩子1,ticket=1
票贩子1票卖完了
票贩子3票卖完了
票贩子2票卖完了

Process finished with exit code 0
泥煤少年的博客
关注
专栏目录
【Java学习】第29节：多线程（异步、同步、生产者&消费者）
m0_46013789的博客
05-23 1400
Java是一种广泛使用的编程语言，由Sun Microsystems（现在是Oracle Corporation）首次推出。它是一种跨平台的编程语言，意味着您可以编写一次代码，然后在多个不同的计算机系统上运行，而无需对其进行修改。Java被广泛用于开发各种类型的应用程序，包括企业级应用、移动应用、Web应用、游戏等。
java多线程编程总结.pdf
10-03
Java多线程编程是Java开发中的重要组成部分，尤其在Java5之后，其并发包的引入极大地增强了多线程处理能力。以下是对Java多线程编程关键知识点的详细概述： 1. **线程概念与原理**： - **线程与进程**：线程是进程...
12.多线程的实现方式、线程安全问题的产生与解决以及生产者与消费者问题
zhaozhiwei314的博客
07-10 204
一、实现多线程 1.1 了解多线程 多线程是指从软件或者硬件上实现多个线程并发执行的技术，具有多线程能力的计算机因有硬件支持而能够在同一时间执行多个线程，从而提升性能。 1.2 并发与并行 并行是指同一时刻，有多个指令在多个CPU上同时执行。 并发是指同一时刻，有多个指令在单个CPU上交替执行。 1.3 进程和线程 **进程：**是指正在运行的程序，比如说360杀毒软件这个程序 **独立性：**进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位。 **动态性：**进程的实质是程序的一
Java中多线程同步问题、生产者与消费者、守护线程和volatile关键字（附带相关面试题）
Alphamilk的博客
07-24 219
1.多线程同步问题(关键字Synchronized)，2. Object线程的等待与唤醒方法，3.模拟生产者与消费者，4.守护线程，5.volatile关键字
Java多线程（实现多线程、线程同步、生产者消费者）
yqqの博客
03-12 514
概述生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。所谓生产者消费者问题，实际上主要是包含了两类线程：​ 一类是生产者线程用于生产数据​ 一类是消费者线程用于消费数据为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为Object类的等待和唤醒方法方法名说明。
Java多线程（线程，线程安全，生产者与消费者模型，定时器）
文帝的博客
11-26 248
学习线程之前我们先了解一下其中的基本概念： (1)什么是串行和并行？ 串行是指多个任务时，各个任务按顺序执行，完成一个之后才能进行下一个 ； 并行指的是多个任务可以同时执行。异步是多个任务并行的前提条件。 (2)什么是并行和并发？ 并行：多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时。 并发：通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。 (...
第三十讲 - Java多线程与线程同步、生产者与消费者
智潮先锋聚集地
04-27 804
深入探索Java世界，领略编程之美。从基础语法到高级特性，从实战案例到性能优化，《Java后端学习路线》专栏带你领略编程的无穷魅力。无论你是初学者还是资深开发者，这里都有适合你的精彩内容。让我们一起在Java的世界里，书写代码的传奇！ 欢迎大家支持订阅本专栏，后续内容更加精彩。
Java--多线程之生产者消费者模式；线程池ExecutorService（五）
MinggeQingchun的博客
10-12 2027
生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的。纵观大多数设计模式，都会找一个第三者出来进行解耦，如工厂模式的第三者是工厂类，模板模式的第三者是模板类在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。
java进程，线程，守护线程，线程同步，死锁，生产者消费者模型，创建线程池4种方法
xy294636185的博客
09-26 202
1.进程与线程 程序：是指令和数据的有序集合，是一个静态的概念 进程：是程序在处理机上的一次执行过程，是一个动态的概念，有自己的地址空间 进程的状态：执行时有间断性，决定进程可能有多种状态： 1.就绪态 2.运行态 3.阻塞态 就绪->(进程调度算法)->运行->(IO事件执行)->阻塞->(事件结束)->...
第十章_多线程(1)_多线程&线程安全问题&生产消费&阻塞队列
qq23001186的博客
04-10 516
目录一、多线程概述二、多线程的实现方式1 - 继承Thread类2 - 实现Runnable接口3 - 实现Callable接口4 - 三种实现方式的对比三、Thread方法1 - 设置和获取线程名称2 - 获得线程对象3 - 线程休眠4 - 线程优先级5 - 守护线程四、线程安全问题1 - 同步代码块2 - 同步方法3 - lock锁4 - 死锁五、生产者和消费者六、阻塞队列 一、多线程概述 简单了解多线程：是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时
Java互联网架构多线程并发编程原理及实战 视频教程 下载.zip
06-18
Java互联网架构多线程并发编程原理及实战 视频教程 下载 1-1 课程简介.mp4 1-2 什么是并发编程.mp4 1-3 并发编程的挑战之频繁的上下文切换.mp4 1-4 并发编程的挑战之死锁.mp4 1-5 并发编程的挑战之线程安全....
Java互联网架构多线程并发编程原理及实战 视频教程 下载3.zip
06-18
Java互联网架构多线程并发编程原理及实战 视频教程 下载 1-1 课程简介.mp4 1-2 什么是并发编程.mp4 1-3 并发编程的挑战之频繁的上下文切换.mp4 1-4 并发编程的挑战之死锁.mp4 1-5 并发编程的挑战之线程安全....
Java互联网架构多线程并发编程原理及实战 视频教程 下载4.zip
06-18
Java互联网架构多线程并发编程原理及实战 视频教程 下载 1-1 课程简介.mp4 1-2 什么是并发编程.mp4 1-3 并发编程的挑战之频繁的上下文切换.mp4 1-4 并发编程的挑战之死锁.mp4 1-5 并发编程的挑战之线程安全....
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 927
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1216
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 359
JDK1.0主要特性。
Spring依赖注入和注解驱动详解和案例示范
J老熊
10-01 1018
在 Spring 框架中，依赖注入（Dependency Injection, DI）和注解驱动（Annotation-Driven）是其核心机制，它们为 Spring 应用提供了灵活性和可扩展性。依赖注入简化了对象间的依赖管理，而注解驱动则通过简洁的注解配置取代了繁琐的 XML 配置。本文将详细分析这两个机制，并通过示例加深理解。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 522
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
JAVA多线程编程深度解析：概念、同步与新特性
- 生产者消费者模型展示了线程间协作处理任务的常见场景，死锁是并发编程中需要特别注意的问题。 11. **Java新特性**: - 包括线程池（ThreadPoolExecutor）提高了线程管理效率，有返回值的线程，更精细的锁机制，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值