求指教，如何将java程序变为可执行程序_java吧_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：635,764贴子：
求指教，如何将java程序变为可执行程序收藏
如题，在书上看到将java文件编译成类文件，然后创建清单文件，创建JAR存档文件，利用cmd可变为可执行文件，不过看不懂，大神指教一下
java-亚马逊819店庆,一站购全球,全品类齐放价,钜惠就在眼前!亚马逊819店庆,正品低价,送货上门,货到付款!
这个简单，写个批处理bat，将java启动脚本写到里面
.exe么　　　诸葛亮为杜蕾斯代言之草船借箭篇：不怕操，随便射！
这个很麻烦的，还不如同目录下放一个精简版jre，一样在没有装jre电脑运行
将java程序变成可执行的程序方法有很多的。一个是点击.jar文件启动，第二个是建立一个批处理文件，也就是.bat文件。里面写 java
文件名，写完后双击就可以运行了。不过路径要跟你的class文件在一起的。若不在一起就将路径设置在class文件那。第三种方法就是下载一个exe4j软件，专门制作可执行的exe程序。可以网上下一个，然后做成exe的程序，但是要在其他电脑上面运行要有java的环境才行。
书上说的是：先建立一个example目录将xxx.java文件复制到该目录中，然后将其编译成类文件。接下来在该目录中完成下列步骤。（1）创建清单文件打开记事本，输入下列内容并将其保存为myfest.fm文件：Mainfest-Version: 1.0Created-By: 1.6.0 (Sun Microsystem Inc.)Main-Class: ArcsDemo(2)创建JAR存档文件D:\example&jar cvfm demo.jar myfest.fm
*.class该命令将当前目录下的类文件打包成demo.jar文件，且使用myfest.fm清单文件。该命令执行后创建了demo.jar存档文件（3）使用下列命令执行存档文件D:\example&java -jar demo.jar
书上就这些，看着挺简单的，步骤搞不懂，怎么编译成类文件在哪编？
最简单的一个例子1、写个源文件2、编译3、打成jar包4、编写运行HelloWorld的bat批处理脚本5、执行bat脚本即可运行程序
8L的方法可行，相信我，如果exe，你还要考虑打包jre，有图片还要考虑打包图片
打包成jar加个bat 然后用winrar做成自解压.exe格式 自动运行bat机器要jre是必须的
首先首先新建一个文件夹，然后你有个精简版的jre，将它放在和导出来的jar同目录，大小20M左右，然后一个jar文件，然后一个bat文件，文件名无所谓，然后，在里面写上start jre/bin/javaw -jar (jar文件名).jar这样就好了，不会再问我，我在没有装java的电脑试过，没问题，
登录百度帐号推荐应用在 Java 应用程序中计划重复执行的任务
我将把 java.util.Timer和 java.util.TimerTask统称为
Java 计时器框架，它们使程序员可以很容易地计划简单的任务（注意这些类也可用于 J2ME 中）。在 Java 2 SDK,
Standard Edition, Version 1.3 中引入这个框架之前，开发人员必须编写自己的调度程序，这需要花费很大精力来处理线程和复杂的
Object.wait()方法。不过，Java 计时器框架没有足够的能力来满足许多应用程序的计划要求。甚至一项需要在每天同一时间重复执行的任务，也不能直接使用
Timer来计划，因为在夏令时开始和结束时会出现时间跳跃。本文展示了一个通用的 Timer和 TimerTask计划框架，从而允许更灵活的计划任务。这个框架非常简单
―― 它包括两个类和一个接口 ―― 并且容易掌握。如果您习惯于使用 Java 定时器框架，那么您应该可以很快地掌握这个计划框架（有关 Java
定时器框架的更多信息，请参阅 ）。计划单次任务
计划框架建立在 Java 定时器框架类的基础之上。因此，在解释如何使用计划框架以及如何实现它之前，我们将首先看看如何用这些类进行计划。想像一个煮蛋计时器，在数分钟之后（这时蛋煮好了）它会发出声音提醒您。清单 1 中的代码构成了一个简单的煮蛋计时器的基本结构，它用 Java 语言编写：清单 1. EggTimer 类 package org.tiling.scheduling.
import java.util.T
import java.util.TimerT
public class EggTimer {
private final Timer timer = new Timer();
public EggTimer(int minutes) {
this.minutes =
public void start() {
timer.schedule(new TimerTask() {
public void run() {
playSound();
timer.cancel();
private void playSound() {
System.out.println("Your egg is ready!");
// Start a new thread to play a sound...
}, minutes * 60 * 1000);
public static void main(String[] args) {
EggTimer eggTimer = new EggTimer(2);
eggTimer.start();
}EggTimer实例拥有一个 Timer实例，用于提供必要的计划。用 start()
方法启动煮蛋计时器后，它就计划了一个 TimerTask，在指定的分钟数之后执行。时间到了，Timer
就在后台调用 TimerTask的 start()方法，这会使它发出声音。在取消计时器后这个应用程序就会中止。计划重复执行的任务
通过指定一个固定的执行频率或者固定的执行时间间隔，Timer可以对重复执行的任务进行计划。不过，有许多应用程序要求更复杂的计划。例如，每天清晨在同一时间发出叫醒铃声的闹钟不能简单地使用固定的计划频率
毫秒（24 小时），因为在钟拨快或者拨慢（如果您的时区使用夏令时）的那些天里，叫醒可能过晚或者过早。解决方案是使用日历算法计算每日事件下一次计划发生的时间。而这正是计划框架所支持的。考虑清单
2 中的 AlarmClock实现（有关计划框架的源代码以及包含这个框架和例子的 JAR 文件，请参阅 ）：清单 2. AlarmClock 类 package org.tiling.scheduling.
import java.text.SimpleDateF
import java.util.D
import org.tiling.scheduling.S
import org.tiling.scheduling.SchedulerT
import org.tiling.scheduling.examples.iterators.DailyI
public class AlarmClock {
private final Scheduler scheduler = new Scheduler();
private final SimpleDateFormat dateFormat =
new SimpleDateFormat("dd MMM yyyy HH:mm:ss.SSS");
private final int hourOfDay, minute,
public AlarmClock(int hourOfDay, int minute, int second) {
this.hourOfDay = hourOfD
this.minute =
this.second =
public void start() {
scheduler.schedule(new SchedulerTask() {
public void run() {
soundAlarm();
private void soundAlarm() {
System.out.println("Wake up! " +
"It's " + dateFormat.format(new Date()));
// Start a new thread to sound an alarm...
}, new DailyIterator(hourOfDay, minute, second));
public static void main(String[] args) {
AlarmClock alarmClock = new AlarmClock(7, 0, 0);
alarmClock.start();
}注意这段代码与煮蛋计时器应用程序非常相似。AlarmClock实例拥有一个 Scheduler
（而不是 Timer）实例，用于提供必要的计划。启动后，这个闹钟对 SchedulerTask
（而不是 TimerTask）进行调度用以发出报警声。这个闹钟不是计划一个任务在固定的延迟时间后执行，而是用 DailyIterator
类描述其计划。在这里，它只是计划任务在每天上午 7:00 执行。下面是一个正常运行情况下的输出： Wake up! It's 24 Aug :00.023
Wake up! It's 25 Aug :00.001
Wake up! It's 26 Aug :00.058
Wake up! It's 27 Aug :00.015
Wake up! It's 28 Aug :00.002
...DailyIterator实现了 ScheduleIterator，这是一个将
SchedulerTask的计划执行时间指定为一系列 java.util.Date对象的接口。然后
next()方法按时间先后顺序迭代 Date对象。返回值 null
会使任务取消（即它再也不会运行）―― 这样的话，试图再次计划将会抛出一个异常。清单 3 包含 ScheduleIterator
接口：清单 3. ScheduleIterator 接口 package org.tiling.
import java.util.D
public interface ScheduleIterator {
public Date next();
}DailyIterator的 next()方法返回表示每天同一时间（上午 7:00）的
Date对象，如清单 4 所示。所以，如果对新构建的 next()类调用 next()，那么将会得到传递给构造函数的那个日期当天或者后面一天的
7:00 AM。再次调用 next()会返回后一天的 7:00 AM，如此重复。为了实现这种行为，DailyIterator
使用了 java.util.Calendar实例。构造函数会在日历中加上一天，对日历的这种设置使得第一次调用 next()
会返回正确的 Date。注意代码没有明确地提到夏令时修正，因为 Calendar实现（在本例中是
GregorianCalendar）负责对此进行处理，所以不需要这样做。清单 4. DailyIterator 类 package org.tiling.scheduling.examples.
import org.tiling.scheduling.ScheduleI
import java.util.C
import java.util.D
* A DailyIterator class returns a sequence of dates on subsequent days
* representing the same time each day.
public class DailyIterator implements ScheduleIterator {
private final int hourOfDay, minute,
private final Calendar calendar = Calendar.getInstance();
public DailyIterator(int hourOfDay, int minute, int second) {
this(hourOfDay, minute, second, new Date());
public DailyIterator(int hourOfDay, int minute, int second, Date date) {
this.hourOfDay = hourOfD
this.minute =
this.second =
calendar.setTime(date);
calendar.set(Calendar.HOUR_OF_DAY, hourOfDay);
calendar.set(Calendar.MINUTE, minute);
calendar.set(Calendar.SECOND, second);
calendar.set(Calendar.MILLISECOND, 0);
if (!calendar.getTime().before(date)) {
calendar.add(Calendar.DATE, -1);
public Date next() {
calendar.add(Calendar.DATE, 1);
return calendar.getTime();
}实现计划框架
在上一节，我们学习了如何使用计划框架，并将它与 Java 定时器框架进行了比较。下面，我将向您展示如何实现这个框架。除了 中展示的 ScheduleIterator接口，构成这个框架的还有另外两个类 ―― Scheduler
和 SchedulerTask。这些类实际上在内部使用 Timer和 SchedulerTask，因为计划其实就是一系列的单次定时器。清单
5 和 6 显示了这两个类的源代码：清单 5. Scheduler package org.tiling.
import java.util.D
import java.util.T
import java.util.TimerT
public class Scheduler {
class SchedulerTimerTask extends TimerTask {
private SchedulerTask schedulerT
private ScheduleI
public SchedulerTimerTask(SchedulerTask schedulerTask,
ScheduleIterator iterator) {
this.schedulerTask = schedulerT
this.iterator =
public void run() {
schedulerTask.run();
reschedule(schedulerTask, iterator);
private final Timer timer = new Timer();
public Scheduler() {
public void cancel() {
timer.cancel();
public void schedule(SchedulerTask schedulerTask,
ScheduleIterator iterator) {
Date time = iterator.next();
if (time == null) {
schedulerTask.cancel();
synchronized(schedulerTask.lock) {
if (schedulerTask.state != SchedulerTask.VIRGIN) {
throw new IllegalStateException("Task already
scheduled " + "or cancelled");
schedulerTask.state = SchedulerTask.SCHEDULED;
schedulerTask.timerTask =
new SchedulerTimerTask(schedulerTask, iterator);
timer.schedule(schedulerTask.timerTask, time);
private void reschedule(SchedulerTask schedulerTask,
ScheduleIterator iterator) {
Date time = iterator.next();
if (time == null) {
schedulerTask.cancel();
synchronized(schedulerTask.lock) {
if (schedulerTask.state != SchedulerTask.CANCELLED) {
schedulerTask.timerTask =
new SchedulerTimerTask(schedulerTask, iterator);
timer.schedule(schedulerTask.timerTask, time);
}清单 6 显示了 SchedulerTask类的源代码：清单 6. SchedulerTask package org.tiling.
import java.util.TimerT
public abstract class SchedulerTask implements Runnable {
final Object lock = new Object();
int state = VIRGIN;
static final int VIRGIN = 0;
static final int SCHEDULED = 1;
static final int CANCELLED = 2;
TimerTask timerT
protected SchedulerTask() {
public abstract void run();
public boolean cancel() {
synchronized(lock) {
if (timerTask != null) {
timerTask.cancel();
boolean result = (state == SCHEDULED);
state = CANCELLED;
public long scheduledExecutionTime() {
synchronized(lock) {
return timerTask == null ? 0 : timerTask.scheduledExecutionTime();
}就像煮蛋计时器，Scheduler的每一个实例都拥有 Timer的一个实例，用于提供底层计划。Scheduler
并没有像实现煮蛋计时器时那样使用一个单次定时器，它将一组单次定时器串接在一起，以便在由 ScheduleIterator
指定的各个时间执行 SchedulerTask类。考虑 Scheduler上的 public schedule()方法 ―― 这是计划的入口点，因为它是客户调用的方法（在
一节中将描述仅有的另一个 public 方法 cancel()）。通过调用
ScheduleIterator接口的 next()，发现第一次执行 SchedulerTask
的时间。然后通过调用底层 Timer类的单次 schedule()方法，启动计划在这一时刻执行。为单次执行提供的
TimerTask对象是嵌入的 SchedulerTimerTask类的一个实例，它包装了任务和迭代器（iterator）。在指定的时间，调用嵌入类的
run()方法，它使用包装的任务和迭代器引用以便重新计划任务的下一次执行。reschedule()
方法与 schedule()方法非常相似，只不过它是 private 的，并且执行一组稍有不同的 SchedulerTask
状态检查。重新计划过程反复重复，为每次计划执行构造一个新的嵌入类实例，直到任务或者调度程序被取消（或者 JVM 关闭）。类似于 TimerTask，SchedulerTask在其生命周期中要经历一系列的状态。创建后，它处于
VIRGIN状态，这表明它从没有计划过。计划以后，它就变为 SCHEDULED状态，再用下面描述的方法之一取消任务后，它就变为
CANCELLED状态。管理正确的状态转变 ―― 如保证不对一个非 VIRGIN状态的任务进行两次计划
―― 增加了 Scheduler和 SchedulerTask类的复杂性。在进行可能改变任务状态的操作时，代码必须同步任务的锁对象。取消任务
取消计划任务有三种方式。第一种是调用 SchedulerTask的 cancel()
方法。这很像调用 TimerTask的 cancel()方法：任务再也不会运行了，不过已经运行的任务 仍会运行完成。
cancel()方法的返回值是一个布尔值，表示如果没有调用 cancel()的话，计划的任务是否还会运行。更准确地说，如果任务在调用
cancel()之前是 SCHEDULED状态，那么它就返回 true。如果试图再次计划一个取消的（甚至是已计划的）任务，那么
Scheduler就会抛出一个 IllegalStateException。取消计划任务的第二种方式是让 ScheduleIterator返回 null。这只是第一种方式的简化操作，因为
Scheduler类调用 SchedulerTask类的 cancel()方法。如果您想用迭代器而不是任务来控制计划停止时间时，就用得上这种取消任务的方式了。第三种方式是通过调用其 cancel()方法取消整个 Scheduler。这会取消调试程序的所有任务，并使它不能再计划任何任务。扩展 cron 实用程序
可以将计划框架比作 UNIX 的 cron实用程序，只不过计划次数的规定是强制性而不是声明性的。例如，在 AlarmClock
实现中使用的 DailyIterator类，它的计划与 cron作业的计划相同，都是由以
0 7 * * *开始的 crontab项指定的（这些字段分别指定分钟、小时、日、月和星期）。不过，计划框架比 cron更灵活。想像一个在早晨打开热水的 HeatingController
应用程序。我想指示它“在每个工作日上午 8:00 打开热水，在周未上午 9:00 打开热水”。使用 cron，我需要两个
crontab项（0 8 * * 1,2,3,4,5和 0 9 * *
6,7）。而使用 ScheduleIterator的解决方案更简洁一些，因为我可以使用复合（composition）来定义单一迭代器。清单
7 显示了其中的一种方法：清单 7. 用复合定义单一迭代器
int[] weekdays = new int[] {
Calendar.MONDAY,
Calendar.TUESDAY,
Calendar.WEDNESDAY,
Calendar.THURSDAY,
Calendar.FRIDAY
int[] weekend = new int[] {
Calendar.SATURDAY,
Calendar.SUNDAY
ScheduleIterator i = new CompositeIterator(
new ScheduleIterator[] {
new RestrictedDailyIterator(8, 0, 0, weekdays),
new RestrictedDailyIterator(9, 0, 0, weekend)
);RestrictedDailyIterator类很像 DailyIterator，只不过它限制为只在一周的特定日子里运行，而一个
CompositeIterator类取得一组 ScheduleIterators，并将日期正确排列到单个计划中。这些类的源代码请参阅
。有许多计划是 cron无法生成的，但是 ScheduleIterator实现却可以。例如，“每个月的最后一天”描述的计划可以用标准
Java 日历算法来实现（用 Calendar类），而用 cron则无法表达它。应用程序甚至无需使用
Calendar类。在本文的源代码（请参阅 ）中，我加入了一个安全灯控制器的例子，它按“在日落之前
15 分钟开灯”这一计划运行。这个实现使用了 Calendrical Calculations Software Package （请参阅
），用于计算当地（给定经度和纬度）的日落时间。实时保证
在编写使用计划的应用程序时，一定要了解框架在时间方面有什么保证。我的任务是提前还是延迟执行？如果有提前或者延迟，偏差最大值是多少？不幸的是，对这些问题没有简单的答案。不过在实际中，它的行为对于很多应用程序已经足够了。下面的讨论假设系统时钟是正确的（有关网络时间协议 (Network
Time Protocol) 的信息，请参阅 ）。因为 Scheduler将计划委托给 Timer类，Scheduler
可以做出的实时保证与 Timer的一样。Timer用 Object.wait(long)
方法计划任务。当前线程要等待直到唤醒它，唤醒可能出于以下原因之一：另一个线程调用对象的 notify()或者 notifyAll()方法。线程被另一个线程中断。在没有通知的情况下，线程被唤醒（称为 spurious wakeup，Joshua Bloch 的 Effective
Java Programming Language Guide一书中 Item 50 对其进行了描述 ―― 请参阅 ）。规定的时间已到。对于 Timer类来说，第一种可能性是不会发生的，因为对其调用 wait()的对象是私有的。即便如此，Timer
实现仍然针对前三种提前唤醒的原因进行了保护，这样保证了线程在规定时间后才唤醒。目前，Object.wait(long)
的文档注释声明，它会在规定的时间“前后”苏醒，所以线程有可能提前唤醒。在本例中，Timer会让另一个 wait()
执行（scheduledExecutionTime - System.currentTimeMillis()）毫秒，从而保证 任务永远不会提前执行。任务是否会延迟执行呢？会的。延迟执行有两个主要原因：线程计划和垃圾收集。Java 语言规范故意没有对线程计划做严格的规定。这是因为 Java 平台是通用的，并针对于大范围的硬件及其相关的操作系统。虽然大多数 JVM 实现都有公平的线程调度程序，但是这一点没有任何保证 —— 当然，各个实现都有不同的为线程分配处理器时间的策略。因此，当 Timer线程在分配的时间后唤醒时，它实际执行其任务的时间取决于 JVM 的线程计划策略，以及有多少其他线程竞争处理器时间。因此，要减缓任务的延迟执行，应该将应用程序中可运行的线程数降至最少。为了做到这一点，可以考虑在一个单独的 JVM 中运行调度程序。对于创建大量对象的大型应用程序，JVM 花在垃圾收集（GC）上的时间会非常多。默认情况下，进行 GC 时，整个应用程序都必须等待它完成，这可能要有几秒钟甚至更长的时间（Java
应用程序启动器的命令行选项 -verbose:gc将导致向控制台报告每一次 GC 事件）。要将这些由 GC 引起的暂停（这可能会影响快速任务的执行）降至最少，应该将应用程序创建的对象的数目降至最低。同样，在单独的
JVM 中运行计划代码是有帮助的。同时，可以试用几个微调选项以尽可能地减少 GC 暂停。例如，增量 GC 会尽量将主收集的代价分散到几个小的收集上。当然这会降低
GC 的效率，但是这可能是时间计划的一个可接受的代价（有关 GC 微调的更多提示，请参阅 ）。我被计划到什么时候？
如果任务本身能监视并记录所有延迟执行的实例，那么对于确定任务是否能按时运行会很有帮助。SchedulerTask
类似于 TimerTask，有一个 scheduledExecutionTime()方法，它返回计划任务最近一次执行的时间。在任务的
run()方法开始时，对表达式 System.currentTimeMillis() - scheduledExecutionTime()
进行判断，可以让您确定任务延迟了多久执行（以毫秒为单位）。可以记录这个值，以便生成一个关于延迟执行的分布统计。可以用这个值决定任务应当采取什么动作
―― 例如，如果任务太迟了，那么它可能什么也不做。在遵循上述原则的情况下，如果应用程序需要更严格的时间保证，可参考 Java 的实时规范（更多信息请参阅
）。结束语
在本文中，我介绍了 Java 定时器框架的一个简单增强，它使得灵活的计划策略成为可能。新的框架实质上是更通用的 cron
―― 事实上，将 cron实现为一个 ScheduleIterator接口，用以替换单纯的
Java cron，这是非常有用的。虽然没有提供严格的实时保证，但是许多需要计划定期任务的通用 Java 应用程序都可以使用这一框架。
相关主题下载本文中使用的 。
“”是 Sun 的一篇非常有用的文章，它给出了关于如何最小化
GC 暂停时间的提示。要获得 developerWorks中有关 GC 的更多信息，请参阅以下文章：
（2003 年 10 月）。“”（2003 年 7 月）。“”（2003 年 1 月）。“”（2002 年 8 月）。“”（2002 年 8 月）。“”（2002 年 9 月）。在“”（developerWorks，
2002 年 11 月）中，Brian Goetz 讨论了 Doug Lea 的 util.concurrent
库，这是一个并发实用工具类的宝库。Brian Goetz 的另一篇文章“”（developerWorks，2001
年 9 月）分析了线程竞用以及如何减少它。这里是 Java SDK 1.4 中
是用 Java 语言编写的另一个调度程序，它的目标是取代 cron。(NTP) 是一个同步计算机时钟的协议。
是 Java 平台的一个扩展，它提供了实时保证。这个站点包括一个参考实现。n（Addison-Wesley，2001 年）给出了很好的建议（例如，Item
51: Don't depend on the thread scheduler）。要了解有关世界各地日历和使用它们的算法，请参阅 Nachum Dershowitz 和 Edward M. Reingold 的“”（Cambridge University Press，1997 年）。James Gosling、Bill Joy、Guy L. Steele Jr. 和 Gilad Bracha 编著的“”（Addison-Wesley，2000
年）一书，第 17 章“Threads and Locks”描述了线程调度程序的行为。Doug Lea 编著的“”（Addison-Wesley，1999
年）是一本好书，它深入探讨了 Java 平台中并发的各个方面。在 ，可以找到数百篇有关 Java 编程各方面的文章。
添加或订阅评论，请先或。
有新评论时提醒我
static.content.url=/developerworks/js/artrating/SITE_ID=10Zone=Java technologyArticleID=53456ArticleTitle=在 Java 应用程序中计划重复执行的任务publish-date=新手园地& & & 硬件问题Linux系统管理Linux网络问题Linux环境编程Linux桌面系统国产LinuxBSD& & & BSD文档中心AIX& & & 新手入门& & & AIX文档中心& & & 资源下载& & & Power高级应用& & & IBM存储AS400Solaris& & & Solaris文档中心HP-UX& & & HP文档中心SCO UNIX& & & SCO文档中心互操作专区IRIXTru64 UNIXMac OS X门户网站运维集群和高可用服务器应用监控和防护虚拟化技术架构设计行业应用和管理服务器及硬件技术& & & 服务器资源下载云计算& & & 云计算文档中心& & & 云计算业界& & & 云计算资源下载存储备份& & & 存储文档中心& & & 存储业界& & & 存储资源下载& & & Symantec技术交流区安全技术网络技术& & & 网络技术文档中心C/C++& & & GUI编程& & & Functional编程内核源码& & & 内核问题移动开发& & & 移动开发技术资料ShellPerlJava& & & Java文档中心PHP& & & php文档中心Python& & & Python文档中心RubyCPU与编译器嵌入式开发驱动开发Web开发VoIP开发技术MySQL& & & MySQL文档中心SybaseOraclePostgreSQLDB2Informix数据仓库与数据挖掘NoSQL技术IT业界新闻与评论IT职业生涯& & & 猎头招聘IT图书与评论& & & CU技术图书大系& & & Linux书友会二手交易下载共享Linux文档专区IT培训与认证& & & 培训交流& & & 认证培训清茶斋投资理财运动地带快乐数码摄影& & & 摄影器材& & & 摄影比赛专区IT爱车族旅游天下站务交流版主会议室博客SNS站务交流区CU活动专区& & & Power活动专区& & & 拍卖交流区频道交流区
白手起家, 积分 55, 距离下一级还需 145 积分
论坛徽章:0
如何让一个java程序始终保持运行? 一般程序运行完main所有代码后就会结束,有什么办法让程序一直保持运行,不会结束?
&&nbsp|&&nbsp&&nbsp|&&nbsp&&nbsp|&&nbsp&&nbsp|&&nbsp
家境小康, 积分 1096, 距离下一级还需 904 积分
论坛徽章:0
while(true) { ... }复制代码
丰衣足食, 积分 972, 距离下一级还需 28 积分
论坛徽章:0
搞个死循环不就行了么？不过这样就使main没有运行完。或者写线程
白手起家, 积分 55, 距离下一级还需 145 积分
论坛徽章:0
原帖由 kingbeg 于
09:34 发表
搞个死循环不就行了么？不过这样就使main没有运行完。或者写线程
===============
我就是想要线程的方法，请问有没有例子?
家境小康, 积分 1235, 距离下一级还需 765 积分
论坛徽章:0
& &this.wait();
家境小康, 积分 1096, 距离下一级还需 904 积分
论坛徽章:0
原帖由 hengpy 于
13:48 发表
===============
我就是想要线程的方法，请问有没有例子?
run（） 里面也能死循环