[Java多线程编程之五] 线程通信

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

  在多线程环境中，多个线程之间互相协作，以达到高效实现程序功能的目的，比如某些多线程程序要求线程执行有先后顺序、获取某个线程的执行结果，要想实现多个线程之间的协同，就需要线程之间互相通信，线程通信主要分为一下四类：

  • 1）文件共享
  • 2）网络共享
  • 3）共享变量
  • 4）JDK提供的线程协调API（主要有：suspend/resume、wait/notify、park/unpark）

一、文件共享

  一个线程将数据写入到文件中，另一个线程再去读取文件，实现数据的共享，最终达到线程通信的目的。

代码示例：

public class FileShareComm {
	public static void main(String[] args) {
		// 线程1 - 写入数据
		new Thread(() -> {
			System.out.println("线程1启动");
			try {
				while (true) {
					Files.write(Paths.get("data.log"), 
								("当前时间" + String.valueOf(System.currentTimeMillis())).getBytes());
					Thread.sleep(1000L);
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}).start(); 
		
		// 线程2 - 读取数据
		new Thread(() -> {
			System.out.println("线程2启动");
			try {
				while (true) {
					Thread.sleep(1000L);
					byte[] allBytes = Files.readAllBytes(Paths.get("data.log"));
					System.out.println(new String(allBytes));
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}).start();
	}
}

程序运行结果：

线程1启动
线程2启动
当前时间1570711321681
当前时间1570711322768
当前时间1570711323768
当前时间1570711324775

二、网络共享

  通俗地说就是网络上不同计算机之间通过套接字（Socket）进行通信，一个Socket一般由IP和Port组成。


三、共享变量

  多个线程对某个内存中数据进去读取和写入，实现线程通信。

代码示例：

public class VariableShareComm {
	// 共享变量
	public static String content = "空";
	
	public static void main(String[] args) {
		// 线程1 - 写入数据
		new Thread(() -> {
			System.out.println("线程1启动!");
			try {
				while (true) {
					content = "当前时间" + String.valueOf(System.currentTimeMillis());
					Thread.sleep(1000L);
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}).start();
		
		// 线程2 - 读取数据
		new Thread(() -> {
			System.out.println("线程2启动!");
			try {
				while (true) {
					Thread.sleep(1000L);
					System.out.println(content);
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}).start();
	}
}

程序运行结果：

线程1启动!
线程2启动!
当前时间1570712442853
当前时间1570712443859
当前时间1570712444868
当前时间1570712445883

四、线程协作 — JDK API

  JDK中对于需要多线程协作完成某一任务的场景，提供了对应API支持，主要有suspend/resume、wait/notify、park/unpark。
  关于多线程协作有个经典的场景：生产者 - 消费者模型（线程阻塞、线程唤醒）
示例：线程1去买包子，没有包子，则暂停执行，等待通知；线程2生产出包子，通知线程1继续执行。
生产者-消费者模型
  下面演示如何用各个JDK API实现生产者-消费者模型。

1、被弃用的suspend和resume

  调用suspend挂起目标线程，通过resume可以恢复线程执行，由于supend/resume即要求resume在suspend之后调用，并且suspend被调用后不会释放锁，因此容易写出死锁的代码，所以被弃用。

（1）死锁的场景1：suspend不释放锁，resume需要获取锁

代码示例：

public class Demo6 {
	public static Object baozidian = null;   // 包子店

	/** 死锁的suspend/resume: suspend并不会像wait一样释放锁，因此容易写出死锁代码 */
	public void suspendResumeDeadLockTest() throws Exception {
		// 启动线程
		Thread consumerThread = new Thread(() -> {
			if (baozidian == null) {    // 如果没包子，则进入等待
				System.out.println("1、进入等待");
				// 当前线程拿到锁，然后挂起(还是RUNNABLE状态)
				synchronized (this) {
					Thread.currentThread().suspend();
				}
			}
			System.out.println("2、买到包子，回家");
		});
		consumerThread.start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		//System.out.println("consumerThread's status " + consumerThread.getState().toString());
		baozidian = new Object();
		synchronized (this) {
			consumerThread.resume();
		}
		System.out.println("3、通知消费者");
	}

	public static void main(String[] args) throws Exception {
		Demo6 demo6 = new Demo6();
		demo6.suspendResumeDeadLockTest();
	}
}

执行结果：

【代码解析】
  由于resume会在休眠3秒之后被调用，所以保证了resume在suspend之后执行，consumerThread的run方法体内执行suspend之前要先拿到demo6对象锁，3秒后创建baozidian对象，主线程要调用resume方法通知consumerThread线程，但是由于执行suspend时没有释放demo5对象锁，所以这里主线程没办法拿到锁，导致没法执行resume，结果是consumerThread永远处于挂起状态。

（2）死锁的场景2：resume在suspend之前执行

代码示例：

	/** 导致永久挂起的suspend/resume */
	public void suspendResumeDeadLockTest2() throws Exception {
		// 启动线程
		Thread consumerThread = new Thread(() -> {
			if (baozidian == null) {    // 如果没包子，则进入等待
				System.out.println("1、进入等待");
				try {
					Thread.sleep(5000L);  // 为这个线程加上一点延时	
				} catch (Exception e) {
					e.printStackTrace();
				}	
				// 这里的挂起执行在resume后面
				Thread.currentThread().suspend();
			}
			System.out.println("2、买到包子，回家");
		});
		consumerThread.start();		
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		consumerThread.resume();
		System.out.println("3、通知消费者");
		consumerThread.join();
	}

执行结果：

【代码解析】
  由于consumerThread的run方法体内执行suspend之前会先休眠5秒，所以导致resume会先执行，suspend后执行，后面的程序不会再次resume，同样会导致consumerThread永远处于挂起状态。

（3）正常的suspend/resume

代码示例：

	/** 正常的suspend/resume */
	public void suspendResumeTest() throws Exception {
		// 启动线程
		Thread consumerThread = new Thread(() -> {
			if (baozidian == null) {    // 如果没包子，则进入等待
				System.out.println("1、进入等待");
				Thread.currentThread().suspend();
			}
			System.out.println("2、买到包子，回家");
		});
		consumerThread.start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);    // 延迟3秒，保证调用resume()之前已经调用suspend()完毕
		baozidian = new Object();
		consumerThread.resume();
		System.out.println("3、通知消费者");
	}

执行结果：


2、wait/notify机制

  wait/notify依赖于Java对象监视器锁，而监视器锁又是跟sychronized配合使用的，因此wait/notify必须写在同步块中，并且wait/notify方法只能由统一对象锁的持有者线程调用。否则会抛出IllegalMonitorStateException异常。
  特别注意，使用sychronized时，用到的监视器锁是监视对象obj对应的监视器锁，所以调用wait方法时，必须调用obj.wait()，这样obj的对象监视器才会去释放对应的监视器锁。

synchronized (obj) {					
	try {
		System.out.println("1、进入等待");
		obj.wait();
	} catch (InterruptedException e) {						
		e.printStackTrace();
	}
}

######（1）正常的wait/notify
  wait和notify方法都必须在sychronized块中被调用，且sychronized和调用方法时必须使用相同的锁对象，notify必须在wait被调用之后再调用，代码如下：

public class Demo6 {
	public static Object baozidian = null;   // 包子店
	/** 正常的wait/notify */
	public void waitNotifyTest() throws Exception {
		// 启动线程
		new Thread(() -> {
			if (baozidian == null) {
				synchronized (this) {
					try {
						System.out.println("1、进入等待");
						this.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
			System.out.println("2、买到包子，回家");
		}).start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		synchronized (this) {
			this.notifyAll();
			System.out.println("3、通知消费者");
		}
	}
    public static void main(String[] args) throws Exception {
		Demo6 demo6 = new Demo6();
	
		// 2、wait/notify
		demo6.waitNotifyTest();
	}
}

执行结果：
在这里插入图片描述

######（2）死锁的wait/notify
  wait方法会导致当前线程等待，加入对应的对象的监视器等待集合中，并且释放当前持有的对象锁，notify/notifyAll方法会唤醒一个或者所有正在等待该对象锁的线程。
  虽然wait会自动解锁，但是对调用顺序有要求，如果在notify被调用之后，才开始wait方法的调用，线程会永远处于WAITING状态；如果调用notify/notifyAll时对象锁的等待集合中没有等待的线程，自然通知不到任一个线程，只有在通知前有线程调用了wait进入等待集合中，才能真正通知到等待的线程。

代码示例：

public class Demo6 {
	public static Object baozidian = null;   // 包子店
	/** 会导致程序永久等待的wait/notify */
	public void waitNotifyDeadLockTest() throws Exception {
		// 启动线程
		new Thread(() -> {
			if (baozidian == null) {
				try {
					Thread.sleep(5000L);
				} catch (InterruptedException e) {					
					e.printStackTrace();
				}
				synchronized (this) {					
					try {
						System.out.println("1、进入等待");
						this.wait();
					} catch (InterruptedException e) {						
						e.printStackTrace();
					}
				}
			}
			System.out.println("2、买到包子，回家");
		}).start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		synchronized (this) {
			this.notifyAll();
			System.out.println("3、通知消费者");
		}
	}
	public static void main(String[] args) throws Exception {
		Demo6 demo6 = new Demo6();
		
		// 2、wait/notify		
		demo6.waitNotifyDeadLockTest();
	}
}

执行结果：
在这里插入图片描述


####3、park/unpark机制
  park/unpark是JDK API的另一种线程通信机制，一个线程调用了park则等待颁发一个“许可”，如果当前存在未被使用的许可，则线程可以直接获取许可直接运行；如果当前许可数为0，则需要等待其他线程调用unpark颁发许可。
  需要许可和颁发许可的线程没有强依赖关系，任何一个线程颁发的许可都可以被任意需要许可的线程使用，任何一个线程都可以颁发许可。因此，park和unpark对调用顺序没有要求，同时由于park/unpark不像wait/notify那样是基于锁监视器的，所以park/unpark不会释放当前线程持有的锁。
  一个线程多次调用park时，只有第一次调用生效，不会因为多次park而去获取多个许可证，因为底层是基于一个布尔值的CAS原子操作。

######（1）正常的park/unpark
代码示例：

public class Demo6 {
	public static Object baozidian = null;   // 包子店
	/** 正常的park/unpark */
	public void parkUnparkTest() throws Exception {
		// 启动线程
		Thread consumerThread = new Thread(() -> {
			if (baozidian == null) {
				System.out.println("1、进入等待");
				LockSupport.park();				
			}
			System.out.println("2、买到包子，回家");
		});
		consumerThread.start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		System.out.println();
		LockSupport.unpark(consumerThread);
		System.out.println("3、通知消费者");
	}
	public static void main(String[] args) throws Exception {
		Demo6 demo6 = new Demo6();
		
		// 3、park/unpark
		demo6.parkUnparkTest();
	}
}

执行结果：
在这里插入图片描述

######（2）死锁的park/unpark
  由于park时不会释放锁，所以如果执行park所在的代码块是需要先获取锁的同步代码块，并且unpark()需要获取相同的锁时，会触发死锁。
代码示例：

public class Demo6 {
	public static Object baozidian = null;   // 包子店
	/** 死锁的park/unpark */
	public void parkUnparkDeadLockTest() throws Exception {
		// 启动线程
		Thread consumerThread = new Thread(() ->{
			if (baozidian == null) {
				System.out.println("1、进入等待");
				synchronized (this) {
					LockSupport.park();
				}
			}
			System.out.println("2、买到包子，回家");
		});
		consumerThread.start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		synchronized (this) {
			LockSupport.unpark(consumerThread);
		}
		System.out.println("3、通知消费者");
	}
	public static void main(String[] args) throws Exception {
		Demo6 demo6 = new Demo6();
		
		// 3、park/unpark
		demo6.parkUnparkDeadLockTest();
	}
}

4、总结
通讯方式等待通知时状态死锁场景优点缺点
suspend/resumeRUNNABLE1、resume在suspend之前被调用
2、suspend和resume所在的同步代码块使用相同的锁导致死锁		~很容易触发死锁
wait/notifyWAITINGnotify在wait之前使用基于对象监视器锁，调用wait时会释放锁执行顺序有要求
park/unparkWAITINGpark和unpark所在同步代码块使用相同的锁导致死锁对执行顺序没要求park不会释放锁，可能导致死锁

五、伪唤醒

  一般情况下，当线程运行需要的等待某个条件还不具备是，线程会调用上述的suspend、wait、park方法将线程挂起，然后等待另一个线程满足这个条件后再通知挂起线程，如果使用if语句来判断是否进入等待状态，可能会引起伪唤醒问题，问题代码模板示例：

sychronized(lock) {
    if (<条件判断>) {
        lock.wait();
    }
    // 执行后续操作
}

######1、什么是伪唤醒？
  伪唤醒是指线程并非因为notify、notifyAll、unpark等api调用而唤醒，是更底层的原因导致的，此时条件判断还不满足，但是却因为伪唤醒运行后续的代码，导致程序运行异常或错误。


######2、如何解决伪唤醒问题？
  不用if语句来判断，而是在循环中检查等待条件，这样确保程序在伪唤醒的条件下依然不会在条件没满足的情况下去执行后续操作，而是再次将线程挂起，如下所示：

// wait
sychronized(obj) {
    while (<条件判断>) {
        obj.wait();
    }
    // 执行后续操作
}
// park
while(<条件判断>) {
    LockSupport.park();
    // 执行后续操作
}

实例代码演示：

	/** 正常的wait/notify */
	public void waitNotifyTest() throws Exception {
		// 启动线程
		Thread consumerThread = new Thread(() -> {
			while (baozidian == null) {
				synchronized (this) {
					try {
						System.out.println("1、进入等待");
						this.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
			System.out.println("2、买到包子，回家");
		});
		consumerThread.start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		System.out.println("consumerThread's status " + consumerThread.getState().toString());
		baozidian = new Object();
		synchronized (this) {
			this.notifyAll();
			System.out.println("3、通知消费者");
		}
	}

	/** 正常的park/unpark */
	public void parkUnparkTest() throws Exception {
		// 启动线程
		Thread consumerThread = new Thread(() -> {
			while (baozidian == null) {
				System.out.println("1、进入等待");
				LockSupport.park();				
			}
			System.out.println("2、买到包子，回家");
		});
		consumerThread.start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		//System.out.println(consumerThread.getState().toString());
		LockSupport.unpark(consumerThread);
		System.out.println("3、通知消费者");
	}
scau-codeman
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
socket传输文件java_Java通过Socket传输文件以及判断文件传输完成的方法
weixin_33550394的博客
02-12 1224
絮叨本人学生，往前一年左右的时间用在了Java上都说写博客、随笔是百利一害的事情-->一害是费时间近期也是在此申请开通了博客此篇也算是开博第一篇，所以絮叨一下——————————————————————————————————————————————————————问题发现与解决今天在写Socket的文件传输程序涉及到Socket、线程、文件操作、流等目标是Client可以向Server提交...
多线程 java实验心得_java多线程编程体会
weixin_39998521的博客
02-28 1800
在 Java 程序中使用多线程要比在 C 或 C++ 中容易得多，这是因为 Java 编程语言提供了语言级的支持。本文通过简单的编程示例来说明 Java 程序中的多线程是多么直观。读完本文以后，用户应该能够编写简单的多线程程序。为什么会排队等待？下面的这个简单的 Java 程序完成四项不相关的任务。这样的程序有单个控制线程，控制在这四个任务之间线性地移动。此外，因为所需的资源 ? 打印机、磁盘、数...
编程必备：JAVA多线程详解
拾一二的博客
06-14 7865
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
万字图解Java多线程
qq_35598736的博客
09-06 5万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
java多线程编程实例
热门推荐
延陵缥缈的博客
05-25 8万+
        这篇文章主要介绍了java多线程编程实例，分享了几则多线程的实例代码，具有一定参考价值，加深多线程编程的理解还是很有帮助的，需要的朋友可以参考下。1.相关知识：Java多线程程序设计到的知识：（1）对同一个数量进行操作（2）对同一个对象进行操作（3）回调方法使用（4）线程同步，死锁问题（5）线程通信等等2．示例2.1三个售票窗口同时出售20张票程序分析：    (1)票数要使用同一...
Java多线程并发编程技术详解
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-20 1万+
Java多线程并发编程是一项需要深入理解和熟练掌握的技术，只有合理地设计和使用多线程，才能真正发挥其在提升系统性能方面的巨大潜力。随着对Java并发机制及工具类库的深入学习和应用，开发者可以更好地构建高效、稳定的并发系统。
Java多线程及通信方式详解
EverythingAtOnce的博客
01-01 1200
在讨论这个问题之前，首先要知道什么是Java多线程，我们拿个生活中的例子来说，例如在手机上使用软件，你可以同时运行多个应用程序或功能。你可以同时打开浏览器、音乐播放器和社交媒体应用。每个应用程序都在后台独立运行，就像多线程能够同时执行多个任务一样。但是有时候你需要等待某些操作完成才能继续进行。比如当你在等待一个应用加载数据时，你可以同时切换到另一个应用。但是直到数据加载完成，你才能够进行下一步操作。这种等待和切换类似于多线程中的线程间同步和等待操作。
java多线程使用教程
鹏鹏2077
04-25 5326
本教程介绍了Java多线程的基本知识和使用方法，包括创建线程、实现Runnable接口、继承Thread类、线程同步、线程间通信和线程池等。多线程技术可以提高程序的并发处理能力和响应速度，但同时也带来了线程安全和同步等问题，需要合理使用同步机制来保证线程安全。使用Java提供的Lock接口可以实现更加灵活和精细的线程同步。线程间通信可以使用wait()、notify()和notifyAll()方法来实现。线程池机制可以重用线程，提高了线程的利用率和效率。掌握了这些知识，可以使用Java实现高效、安全、可靠的
Java多线程面试题（面试必备）
LIUZEYU12A
05-26 6万+
文章目录一、多线程基础基础知识1. 并发编程1.1 并发编程的优缺点1.2 并发编程的三要素1.3 并发和并行有和区别1.4 什么是多线程，多线程的优劣？2. 线程与进程2.1 什么是线程与进程2.2 线程与进程的区别2.3 用户线程与守护线程2.4 什么是线程死锁2.5 形成死锁的四个必要条件2.6 如何避免死锁3. 创建线程的四种方式4. 线程状态和基本操作 一、多线程基础基础知识 1. 并发编程 1.1 并发编程的优缺点 优点： 充分利用多核CPU的计算能力，通过并发编程的形式将多核CPU的计算.
Java中的多线程编程与并发控制
AOMGyz的博客
04-26 1069
随着计算机硬件技术的不断发展，多核处理器已经成为现代计算机系统的标配。在这样的背景下，多线程编程与并发控制成为了Java开发中不可或缺的一部分。多线程编程能够充分利用多核处理器的并行计算能力，提高程序的执行效率；而并发控制则能够确保多个线程在共享资源时的正确性和安全性。本文将深入探讨Java中的多线程编程与并发控制。
java多线程编程之管道通信详解
08-29
Java多线程编程中的管道通信（Pipe Communication）是一种在不同线程之间传递数据的有效方式，无需借助临时文件或共享变量。这种通信机制依赖于Java提供的`PipeInputStream`和`PipedOutputStream`（对于字节流）或者...
java多线程编程之java线程简介
09-04
Java多线程编程是开发高并发、高性能应用的关键技术之一。Java线程是程序执行的最小单位，它在Java中是通过`Thread`类或实现`Runnable`接口来创建和管理的。线程允许程序在同一进程中并发执行多个任务，提高了程序的...
Java多线程编程的优点和缺点
10-16
Java多线程编程是开发高效率、高性能应用的关键技术之一，尤其在当今多核处理器普及的时代。通过创建多个线程，程序能够同时处理多个任务，从而显著提高响应速度和资源利用率。然而，多线程也带来了一系列挑战和潜在...
JAVA多线程编程技术PDF
08-28
总结起来，“JAVA多线程编程技术PDF”涵盖了多线程的基本概念、同步机制、线程通信、死锁避免、线程池以及线程安全的集合类等内容。通过深入学习这份资料，开发者可以全面掌握Java多线程编程技术，提升程序的并发...
java多线程编程之线程的生命周期
09-04
Java多线程编程中，线程的生命周期包括四个主要阶段：新建、运行、阻塞和终止。理解这些状态以及如何通过Thread类中的方法控制它们至关重要。 1. **新建**： 当通过`new Thread()`创建一个新的线程对象时，线程...
配置Java开发环境
Broken_x的博客
07-10 1463
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
最新发布
baina666的博客
07-12 357
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 428
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 2335
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
Java多线程编程深入详解.docx
10-24
"Java多线程编程深入详解文档包含了如何创建线程、线程的状态、资源锁、线程间通信、线程组、线程池、单例模式以及生产者消费者模式等多个关键知识点。提供了多进程多线程的定义和Java对其支持的介绍。" 在Java编程...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值