java 代码为什么会超时 java题目运行超时是怎么回事
大家好,今天小编来为大家解答以下的问题，关于java 代码为什么会超时，java题目运行超时是怎么回事这个很多人还不知道，现在让我们一起来看看吧！
java 方法 执行超时处理
java 1.5以上的Future类可以执行超时处理。
jdk1.5自带的并发库中Future类中重要方法包括get()和cancel()，get()获取数据对象，如果数据没有加载，就会阻塞直到取到数据，而 cancel()是取消数据加载。另外一个get(timeout)操作，表示如果在timeout时间内没有取到就失败返回，而不再阻塞。
代码如下：
importjava.util.concurrent.Callable;
importjava.util.concurrent.ExecutionException;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
importjava.util.concurrent.TimeUnit;
importcom.sun.corba.se.impl.orbutil.closure.Future;
importcom.sun.corba.se.impl.orbutil.threadpool.TimeoutException;
publicclassThreadTest{
publicstaticvoidmain(String[]args)throwsInterruptedException,
ExecutionException{
finalExecutorServiceexec=Executors.newFixedThreadPool(1);
Callable<String>call=newCallable<String>(){
publicStringcall()throwsException{
//开始执行耗时操作
Thread.sleep(1000*5);
return"线程执行完成.";
}
};
try{
Future<String>future=exec.submit(call);
Stringobj=future.get(1000*1,TimeUnit.MILLISECONDS);//任务处理超时时间设为1秒
System.out.println("任务成功返回:"+obj);
}catch(TimeoutExceptionex){
System.out.println("处理超时啦....");
ex.printStackTrace();
}catch(Exceptione){
System.out.println("处理失败.");
e.printStackTrace();
}
//关闭线程池
exec.shutdown();
}
}
可以提高千倍效率的Java代码小技巧
Java提高千倍效率小技巧
1、尽量指定类、方法的final修饰符
带有final修饰符的类是不可派生的。在Java核心API中，有许多应用final的例子，例如java.lang.String，整个类都是final的。为类指定final修饰符可以让类不可以被继承，为方法指定final修饰符可以让方法不可以被重写。如果指定了一个类为final，则该类所有的方法都是final的。Java编译器会寻找机会内联所有的final方法内联对干提升Java运行效率作用重大，具体参见Java运行期优化。此举能够使性能平均提高50%。
2、尽量重用对象
特别是String对象的使用，出现字符串连接时应该使用StringBuilder/StringBuffer代替。由于Java虚拟机不仅要花时间生成对象，以后可能还需要花时间对这些对象进行垃圾回收和处理，因此，生成过多的对象将会给程序的性能带来很大的影响。
3、尽可能使用局部变量
调用方法时传递的参数以及在调用中创建的临时变量都保存在栈中速度较快，其他变量，如静态变量、实例变量等，都在堆中创建，速度较慢。另外，栈中创建的变量，随着方法的运行结束，这些内容就没了，不需要额外的垃圾回收。
4、及时关闭流
Java编程过程中，进行数据库连接、I/O流操作时务必小心，在使用完毕后，及时关闭以释放资源。因为对这些大对象的操作会造成系统大的开销，稍有不慎，将会导致严重的后果。
5、慎用异常
异常对性能不利。抛出异常首先要创建一个新的对象Throwable接口的构造函数调用名为filllnStackTrace(的本地同步方法，filllnStackTrace()方法检查堆栈，收集调用跟踪信息。只要有异常被抛出，Java虚拟机就必须调整调用堆栈，因为在处理过程中创建了一个新的对象。异常只能用于错误处理，不应该用来控制程序流程。
6、不要在循环中使用try...catch··，应该把其放在最外层。
除非不得已。如果毫无理由地这么写了，只要你的领导资深一点、有强迫症一点，八成就要骂你为什么写出这种垃圾代码来了。
7、不要将数组声明为public static final
因为这毫无意义，这样只是定义了引用为static final，数组的内容还是可以随意改变的，将数组声明为public更是一个安全漏洞，这意味着这个数组可以被外部类所改变。
8、尽量在合适的场合使用单例。
使用单例可以减轻加载的负担、缩短加载的时间、提高加载的效率，但并不是所有地方都适用于单例，简单来说，单例主要适用于以下三个方面:
(1)控制资源的使用，通过线程同步来控制资源的并发访问;
(2)控制实例的产生，以达到节约资源的目的;
(3)控制数据的共享，在不建立直接关联的条件下，让多个不相关的进程或线程之间实现通信。
9、及时清除不再需要的会话
为了清除不再活动的会话，许多应用服务器都有默认的会话超时时间，一般为30分钟。当应用服务器需要保存更多的会话时，如果内存不足，那么操作系统会把部分数据转移到磁盘，应用服务器也可能根据MRU(最近最频繁使用)算法把部分不活跃的会话转储到磁盘，甚至可能抛出内存不足的异常。
如果会话要被转储到磁盘那么必须要先被序列化，在大规模集群中，对对象进行序列化的代价是很昂贵的。因此，当会话不再需要时应当及时调用HttpSession的invalidate()方法清除会话
10、使用同步代码块替代同步方法
这点在多线程模块中的synchronized锁方法块一文中已经讲得很清楚了，除非能确定一整个方法都是需要进行同步的，否则尽量使用同步代码块，避免对那些不需要进行同步的代码也进行了同步，影响了代码执行效率。
11、将常量声明为static final，并以大写命名。
这样在编译期间就可以把这些内容放入常量池中，避免运行期间计算生成常量的值。另外，将常量的名字以大写命名，也可以方便区分出常量与变量。
java题目运行超时是怎么回事
首先确保没有加package，类名称为Main。
为了运行效率，请使用
[java]view plaincopy
因为pat系统对scanner支持不友好且运行时间长。
BufferedReaderbf=newBufferedReader(newInputStreamReader(System.in));
请在使用完bufferedreader之后立刻使用close()；方法关闭，否则可能会发生内存泄漏（关闭的越早越好）。
【重要】请不要随便import没有用到的包，亲测若是导入了java.util.Scanner可是你没有用到scanner，就会返回非零。
二、对于运行超时
一般对于100ms时间限制的题目，基本ac不了，哪怕优化得再好。因为很多乙级题目运行时长（该死的jvm启动）在100ms上下，运气好ac的多，运气差全超时！
200ms以上的题目，若是运行超时，那就请不要用暴力破解。
还是超时的话，建议换语言。官方说明：选择合适的语言也是一种技巧，所以不给你java放宽时间限制！
java有内存溢出吗如果有是什么情况
内存溢出是指应用系统中存在无法回收的内存或使用的内存过多，最终使得程序运行要用到的内存大于虚拟机能提供的最大内存。
所以我们应该明确：存在内存溢出的因不一定导致内存溢出的果。。。
1。JAVA操作文本文件为什么超过3万行就内存益处啊？
PrintWriter out= new PrintWriter(new BufferedWriter(new FileWriter(fileName)));
//PrintWriter out= new PrintWriter(fileName);
//FileOutputStream out= new FileOutputStream(fileName);
while(rs.next()){
for(int j= 1; j<= totalColumn; j++){
out.write(rs.getObject(j).toString());
out.write("\t");
}
out.write("\n");
out.flush();
}
}
我在代码中写了 out.flush()用来刷新该流的缓冲;可是当我的记录数超过3W时就报了内存益处的问题了，难道JAVA不能边读边写吗？还是out这个对象随着指向的fileName文件的边大占用内存也大了吗？？到底怎么来实现用JAVA写更多的数据而不内存益处呢
答案是：就在while(rs.next())当rs.next()时内存不断增大，而不是写流的问题，JAVA的ResultSet真是麻烦，而且ResultSet还不能clone();所以记得在做项目的时候，经常要设置：jdbc.setMaxRows(100*10000);//设置能容纳100万行记录-----这个就是防止内存泄露的哈-------------------内存中加载的数据量过于庞大，如一次从数据库取出过多数据；
jdbc.setQueryTimeout(60*30);//设置超时时间是30分钟
2。java中的内存泄露的情况：长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露，尽管短生命周期对象已经不再需要，但是因为长生命周期对象持有它的引用而导致不能被回收，这就是java中内存泄露的发生场景，通俗地说，就是程序员可能创建了一个对象，以后一直不再使用这个对象，这个对象却一直被引用，即这个对象无用但是却无法被垃圾回收器回收的，这就是java中可能出现内存泄露的情况，例如，缓存系统，我们加载了一个对象放在缓存中(例如放在一个全局map对象中)，然后一直不再使用它，这个对象一直被缓存引用，但却不再被使用。
public class Stack{//长生命周期
private Object[] elements=new Object[10];//当数组容器中没有东西时是无用的，但是无法回收~~elements是短生命周期
private int size= 0;
public void push(Object e){
ensureCapacity();
elements[size++]= e;
}
public Object pop(){
if( size== 0)
throw new EmptyStackException();
//这里还是引用了，只是指针变位置变化而已，他确实返回了那个对象，但是他却没有断开那个对象的引用，也就是说有两个地方会持有这个对象的引用，调用pop的地方，和elements中
return elements[--size];
}
private void ensureCapacity(){
if(elements.length== size){
Object[] oldElements= elements;
elements= new Object[2* elements.length+1];
System.arraycopy(oldElements,0, elements, 0, size);
}
}
}
上面的原理应该很简单，假如堆栈加了10个元素，然后全部弹出来，虽然堆栈是空的，没有我们要的东西，但是这是个对象是无法回收的，这个才符合了内存泄露的两个条件(必要条件)：无用，无法回收。
例子1
public class Bad{
public static Stack s=Stack();
static{
s.push(new Object());
s.pop();//这里有一个对象发生内存泄露
s.push(new Object());//上面的对象可以被回收了，等于是自愈了，因为引用被覆盖了
}
}
因为是static，就一直存在到程序退出，但是我们也可以看到它有自愈功能，就是说如果你的Stack最多有100个对象，那么最多也就只有100个对象无法被回收其实这个应该很容易理解，Stack内部持有100个引用，最坏的情况就是他们都是无用的，因为我们一旦放新的进取，以前的引用自然消失！
内存泄露的另外一种情况：当一个对象被存储进HashSet集合中以后，就不能修改这个对象中的那些参与计算哈希值的字段了，否则，对象修改后的哈希值与最初存储进HashSet集合中时的哈希值就不同了，在这种情况下，即使在contains方法使用该对象的当前引用作为的参数去HashSet集合中检索对象，也将返回找不到对象的结果，这也会导致无法从HashSet集合中单独删除当前对象，造成内存泄露。
这是属于：集合类中有对对象的引用，使用完后未清空，使得JVM不能回收；
3。代码中存在死循环或循环产生过多重复的对象实体；
4。启动参数内存值设定的过小；
文章到此结束，如果本次分享的java 代码为什么会超时和java题目运行超时是怎么回事的问题解决了您的问题，那么我们由衷的感到高兴！