Java中main方法、线程、进程三者的关系

最新推荐文章于 2024-07-03 22:02:15 发布
原创 最新推荐文章于 2024-07-03 22:02:15 发布 · 1.5k 阅读 · 14 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

本文揭示了多个独立main方法运行时的进程特性，强调了进程间的资源隔离与数据共享限制。理解单进程与多进程的区别，以及如何在多线程环境下处理数据共享问题。

main方法是程序的入口，执行main方法开启了一个进程，同时main线程是主线程

注意：执行main方法开启了一个进程 !!!

  • 如果同时开启多个main方法，那就是同时开启了多个进程！
  • 进程是资源分配的基本单位，线程是处理机调度的基本单位
  • 进程与进程之间是无法直接共享数据的（很难）
  • 进程和进程之间可以通信，传输数据，例如网络编程

我们平常所涉及的多线程问题、数据共享问题（例如单例模式只创建一个对象）都是针对于单进程的；也就是服务端进程中多个线程共享数据分别处理不同客户端的请求

如果同时开启多个main方法（独立的、不嵌套(不在一个main方法中调用另一个main方法)的），则这些main方法之间是无法共享数据的，单例模式也是失效的；因为每开启一个main方法，就开启了一个进程，进行资源的加载，不同的进程有不同的数据区（栈、堆、方法区等数据结构），在一个main方法中加载过的类在另一个main方法中也会重新加载。

Java创建线程的七种方法，全网最全面总结~
CYK_byte的博客
02-03 2万+
属于基础的面试问题，一定要能够回答全哦~
多线程编程全攻略：提升性能与线程安全的必备知识
热门推荐
张彦峰的博客
10-14 10万+
介绍多线程编程的相关概念、同步机制以及无锁编程。从线程的基础概念出发，包括逻辑线程和硬件线程的比较，以及线程、核心和函数的关系。随后，我们探讨了多线程编程的基本原则，包括时间分片、上下文切换、线程安全函数和可重入函数等。接着，我们讨论了为什么需要多线程同步、什么情况需要进行同步以及多线程同步的方式，包括串行化、原子操作和锁等。我们还深入研究了非阻塞的无锁同步机制，如CAS循环和无锁数据结构。最后，我们解释了程序序、内存序、乱序执行、存储缓冲区和失效队列等概念，以帮助更好地理解多线程编程。
main函数到底是一个线程还是进程？
qq_46464421的博客
10-19 1596
main函数是线程还是进程？
Java中main方法启动的是一个进程还是一个线程
jiahanghacker的博客
05-28 9497
Java中main方法启动的是一个线程也是一个进程，一个java程序启动后它就是一个进程，进程相当于一个空盒，它只提供资源装载的空间，具体的调度并不是由进程来完成的，而是由线程来完成的。一个java程序从main开始之后，进程启动，为整个程序提供各种资源，而此时将启动一个线程，这个线程就是主线程，它将调度资源，进行具体的操作。Thread、Runnable的开启的线程是主线程下的子线...
进程与线程（八股文）
u014136435的博客
10-21 457
进程是计算资源（CPU，内存）分配的基本单位线程是计算机CPU调度和分配的基本单位，也就是程序执行的最小单位1、运行一个程序时，系统首先创建一个进程，同时分配地址空间和其他资源，随后将进程加入就绪队列，指导分配到CPU时间就可以正式运行了。2、线程是进程的一个执行流。代码其实真正运行的是进程里面的线程。3、main()函数本质上属于一个进程业属于一个线程，我们既可以在main函数里面创建子进程，也可以同时创建子线程。
Main线程与main()方法的关系
kking_edc的博客
08-24 779
当JVM启动的时候，会启动一个名为“Main”的线程。程序就会在这个线程上运行，除非用户自己创建了其他线程。 Main线程首先就会寻找"static void main(String[] args)"方法，并且调用这个方法。这个就是程序的进入点。 如果我们希望程序可以并发，那么我们可以创建多线程，并且给予每个线程一些操作。接下来这些线程就会并发的执行这些操作。JVM同时也会创建一些其他的内部线程在“幕后”工作（比如垃圾回收）。 ...
Java 进程与main方法
hhx_xiaopeng的博客
09-04 745
main方法，被JAVA虚拟机调用就是入口函数，生成一个主线程。被别的方法调用，那就只是一个普通的静态方法，就是说不生成新线程，而只是调用它的线程的一部分而已（main方法内具体什么功能，生成不生成新线程那是另外一回事）。  然后再说一下进程的事，main方法即便被当成入口函数被JAVA虚拟机调用，它也不会生成什么进程，或者说main方法跟进程就没半毛钱的关系，八竿子打不着。把这个搞混的只能说是把
Java高级篇--进程和线程
m0_74194490的博客
07-03 619
正在进行的程序。是系统分配资源的基本单元。线程轻量级线程）是进程中的一条执行路径，也就是CPU的基本调度单位。多线程：一个程序同一时间执行多个线程。一个进程由一个或多个线程组成，彼此之间完成的工作不同（任务），同时执行，成为多线程。--我们写的代码就是单线程的。
Java中的进程和线程（*）
weixin_42408447的博客
11-30 788
1.前言 我们都知道计算机的核心是CPU，它承担了所有的计算任务，而操作系统是计算机的管理者，它负责任务的调度，资源的分配和管理，统领整个计算机硬件；应用程序是具有某种功能的程序，程序是运行在操作系统之上的。 2.进程的理解 （1）什么是进程 一个在内存中运行的应用程序。每个进程都有自己独立的一块内存空间，一个进程可以有多个线程，比如在Windows系统中，一个运行的xx.exe就是一个进程。 由图可知，谷歌浏览器正在运行16个进程，IDEA正在运行9个进程，每一个.exe文件就是一个进程，每个进程对应
Java线程监听,意外退出线程后自动重启的实现方法
08-31
在本文中，我们将介绍Java线程监听的实现方法，包括使用观察者模式来监听线程的生命周期，并在线程死亡后自动重启。 一、问题描述 在开发过程中，我们经常会遇到线程意外退出的情况，例如网络异常、资源不足等原因...
关于多线程中主线程与其他线程的关系
weixin_52026588的博客
11-27 920
在主方法，也就是main方法中，首先一定存在主线程，也包括在主方法的代码块中有其他线程。下面看一段代码： import javax.print.attribute.PrintServiceAttribute; public class TwoThreads { public static void main(String[] args) { for(int i = 0;i<10;i++) { Thread print = new Print(); Thread downlo.
什么线程什么是进程！main方法与线程和进程它们三个的区别
weixin_45786455的博客
03-21 962
什么线程什么是进程！main方法与线程和进程它们三个的区别进程线程main方法区别 进程 进程：进程是并发执行程序在执行过程中资源分配和管理的基本单位。进程可以理解为一个应用程序的执行过程，应用程序一旦执行，就是一个进程。每个进程都有自己独立的地址空间，每启动一个进程，系统就会为它分配地址空间，建立数据表来维护代码段、堆栈段和数据段。 线程 线程：程序执行的最小单位。 main方法 main：在个...
main方法是一个新的线程吗
qq_35082776的博客
10-17 865
线程顺序
一个普通main方法的执行，是单线程模式还是多线程模式？为什么？
一个搬砖工人
02-26 433
因为java有个重要的特性，叫垃圾自动回收机制，所以答案是多线程，这里面有两部分，主线程（用户线程），垃圾回收线程GC（守护线程）同时存在。
Java中main方法是单线程还是多线程？启动后有多少个线程会被创建？
MaYuKang的博客
12-14 4957
先说结论：main方法启动后，jvm会开启多个守护线程，但main方法中的代码是被单线程执行的。 上代码： 下面这段代码通过java提供的线程管理类ThreadMXBean中的dumpAllThreads方法返回所有活动线程的线程信息，并打印线程id和名称： public class Test { public static void main(String[] args) throws InterruptedException { ThreadMXBean threadMXBean
关于main函数与进程、线程退出的关系
weixin_43352468的博客
07-04 3595
关于main函数与进程、线程退出的关系 在学习嵌入式系统的进程和线程时，有以下的疑问： 讲师说进程退出时，进程中的所有线程都会退出；但是主线程退出时，子线程是不会退出的。当时觉得主线程=主进程main函数，那主线程退出了，子线程还会继续执行呢？ 在网上查阅资料之后，弄明白了三者的关系就理解了开头的两句话，下面写一下总结，方便以后复习。 理解进程与线程 进程 是系统分配资源的最小单位。 线程 是系统调度的最小单位。 线程是程序最基本的运行单位，而进程是不能运行的，运行的是进程中的线程。创建进程时，系统会自动创
Java的Main方法与Java进程之间的关系
chenkai619的专栏
04-26 2932
转摘自：http://hi.baidu.com/huahua035/blog/item/51bbb13749f3d4200a55a9eb.html Java应用程序的入口就是main方法（）！ 启动一个Java应用程序，就是要运用它的main方法，这时候就启动了一个Java虚拟机------在Windows下查看任务管理器，就会发现多出了一个javaw.exe的进程，这个就是java虚
【Java并发编程 四】Java的进程与线程
MaoLin Tian's Blog
02-28 501
什么是进程？进程是程序的⼀次执⾏过程，是系统运⾏程序的基本单位，因此进程是动态的。系统运行和关闭⼀个程序即是⼀个进程从创建，运⾏到消亡的过程。在 Java 中，当我们启动 main 函数时其实就是启动了⼀个 JVM 的进程，⽽ main 函数所在的线程就是这个进程中的⼀个线程，也称主线程 什么是线程？线程与进程相似，但线程是⼀个⽐进程更⼩的执⾏单位。⼀个进程在其执⾏的过程中可以产⽣多个线程。与进程不同的是同类的多个线程共享进程的堆和⽅法区资源，但每个线程有⾃⼰的程序计数器、虚拟机栈和本地⽅法栈，所以系统在产
main线程比用户线程执行快
最新发布
07-15
<think>我们正在讨论Java多线程中main线程比用户线程执行快的原因及控制方法。根据用户的问题，我们需要解释为什么main线程通常比用户创建的线程执行得更快，以及如何控制线程的执行顺序。 原因分析： 1. **启动开销**：用户线程需要经过创建、初始化、调度等过程，而main线程是JVM启动时立即创建的，因此main线程的代码可以立即执行。 2. **调度延迟**：用户线程创建后，需要等待操作系统的线程调度器分配CPU时间片，而main线程已经在运行。 3. **资源竞争**：如果有多个用户线程同时启动，它们可能会竞争系统资源（如CPU），而main线程此时已经在运行，因此可能先执行完。 控制线程执行顺序的方法： 1. **使用Thread.join()**：在main线程中调用用户线程的join方法，使main线程等待用户线程执行完毕。 2. **使用同步工具**：如CountDownLatch、CyclicBarrier、Semaphore等。 3. **使用线程池和Future**：通过Future.get()方法等待线程执行结果。 下面我们结合示例来说明。 示例1：使用Thread.join()控制顺序 ```java public class JoinExample { public static void main(String[] args) throws InterruptedException { Thread userThread = new Thread(() -> { // 模拟用户线程执行的任务 System.out.println("用户线程开始执行"); try { Thread.sleep(1000); // 模拟耗时操作 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("用户线程执行完毕"); }); userThread.start(); // 启动用户线程 userThread.join(); // main线程等待userThread执行完毕 System.out.println("main线程执行完毕"); } } ``` 输出： ``` 用户线程开始执行 用户线程执行完毕 main线程执行完毕 ``` 示例2：使用CountDownLatch ```java import java.util.concurrent.CountDownLatch; public class CountDownLatchExample { public static void main(String[] args) throws InterruptedException { CountDownLatch latch = new CountDownLatch(1); // 初始化计数器为1 Thread userThread = new Thread(() -> { System.out.println("用户线程开始执行"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("用户线程执行完毕"); latch.countDown(); // 计数器减1 }); userThread.start(); latch.await(); // main线程等待计数器归零 System.out.println("main线程执行完毕"); } } ``` 示例3：使用Future（通过线程池） ```java import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; public class FutureExample { public static void main(String[] args) throws Exception { ExecutorService executor = Executors.newSingleThreadExecutor(); Future<?> future = executor.submit(() -> { System.out.println("用户线程开始执行"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("用户线程执行完毕"); }); future.get(); // 阻塞直到用户线程执行完毕 System.out.println("main线程执行完毕"); executor.shutdown(); } } ``` 总结： - main线程执行快于用户线程主要是因为用户线程的创建和启动需要时间，以及操作系统的调度延迟。 - 通过同步机制（如join、CountDownLatch、Future等）可以控制线程的执行顺序，确保main线程在用户线程完成后执行。 相关问题： 1. Java中还有哪些同步工具可以控制线程执行顺序？ 2. 线程的优先级设置能否有效控制执行顺序？ 3. 如何避免多线程环境下的资源竞争问题？</think>### Java main线程执行速度快于用户线程的原因及解决方法 #### **根本原因分析** 1. **启动顺序差异** - JVM启动时自动创建`main`线程执行主方法，而用户线程需手动创建并启动 - 用户线程创建需经过：实例化Thread对象 → 分配栈空间 → 注册到线程调度器 ```java Thread t = new Thread(() -> {...}); // 创建成本 t.start(); // 启动延迟 ≈ 1ms~10ms[^1] ``` 2. **调度器优先级** - 操作系统线程调度器可能优先调度已运行的`main`线程 - 用户线程需等待CPU时间片分配（尤其在高负载时） 3. **资源初始化开销** - 用户线程首次运行时需加载类/初始化线程局部存储(TLS) - `main`线程在JVM启动时已完成初始化 4. **内存可见性问题** 用户线程可能因缓存未及时同步主内存，导致延迟感知状态变化（如未用`volatile`的共享变量）[^3] #### **控制线程执行顺序的解决方案** ##### 方法1：显式等待（阻塞main线程） ```java public static void main(String[] args) throws InterruptedException { Thread userThread = new Thread(() -> { System.out.println("用户线程执行"); }); userThread.start(); userThread.join(); // 阻塞main线程直至userThread终止 System.out.println("main线程继续执行"); } ``` **原理**：`join()`内部调用`wait()`，释放main线程持有的锁[^3] ##### 方法2：同步工具（CountDownLatch） ```java public static void main(String[] args) throws InterruptedException { CountDownLatch latch = new CountDownLatch(1); // 同步计数器 new Thread(() -> { System.out.println("用户线程工作"); latch.countDown(); // 计数器减1 }).start(); latch.await(); // main线程阻塞直到计数器归零 System.out.println("main线程继续"); } ``` ##### 方法3：线程池控制（推荐生产环境） ```java ExecutorService executor = Executors.newFixedThreadPool(2); Future<?> future = executor.submit(() -> { System.out.println("用户线程任务"); }); future.get(); // 阻塞直到任务完成 System.out.println("main线程继续"); executor.shutdown(); ``` **优势**：避免线程创建开销，复用线程资源[^1] ##### 方法4：条件变量（精确控制） ```java private static volatile boolean flag = false; // volatile保证可见性[^3] public static void main(String[] args) { new Thread(() -> { // ... 用户线程工作 flag = true; // 设置完成标志 }).start(); while (!flag) { Thread.yield(); // 让出CPU避免忙等待 } System.out.println("main线程继续"); } ``` #### **关键机制对比** | 方法 | 适用场景 | 性能影响 | 复杂度 | |---------------------|--------------------------|----------------|--------| | `thread.join()` | 简单单线程依赖 | 低开销 | ★☆☆ | | `CountDownLatch` | 多阶段任务同步 | 中等开销 | ★★☆ | | 线程池+`Future.get` | 需要资源复用/任务管理 | 最优（长耗时） | ★★★ | | 条件变量 | 精细控制执行逻辑 | 需防忙等待 | ★★★☆ | > 💡 **最佳实践**：在**高并发场景优先使用线程池**，通过`Future`或`CompletableFuture`控制顺序；**简单场景**可用`join()`或`CountDownLatch`[^1][^3] --- ### 相关问题 1. 如何通过`CompletableFuture`实现多线程任务的串行与并行调度？ 2. `Thread.yield()`和`Thread.sleep()`在控制线程执行顺序时有何区别？ 3. Java内存模型(JMM)如何影响多线程的执行可见性？[^3]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我待Java如初恋

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值