【教你如何开发一个OnlineJudge网站】第一章 如何实现OnlineJudge判题
【教你如何开发一个OnlineJudge网站】系列文章目录
第一章 如何实现OnlineJudge判题
第二章 实现OnlineJudge的后端
第三章 实现OnlineJudge的前端
文章目录
- 【教你如何开发一个OnlineJudge网站】系列文章目录
- 前言
- 一、OnlineJudge是什么？
- 二、OnlineJudge判题端涉及到的技术
-
- 1.提交的代码封装成可执行文件
- 2.使用反射
- 3.使用线程池，消息队列
- 4.关于线程的计时
- 三、测试
- 总结
前言
本文章是使用Java实现的OnlineJudge判题端，疫情一直在家，家里的网也上不了github，也不知道开源的是怎么做的，在这里实现的是我的想法，有更好的想法欢迎大家和我交流。
一、OnlineJudge是什么？
大家对OnlineJudge的实现多多少少是有点了解的。OnlineJudge就是一个判题系统，用户提交代码，服务器执行代码，然后和结果进行判定。
现在网上也有很多开源的OnlineJudge系统，大家可以去github搜一下，相应的项目成百上千五花八门。
其实99.9%的系统，实现上并不复杂，你可以搬砖，我也可以搬砖。
二、OnlineJudge判题端涉及到的技术
由于人手不够（<=1），我只实现了Java在线的判题。
我的做法是：把代码写成文件，执行此文件获得它的结果。
如果以后想支持C++了，加一个ifelseif就好了。
涉及到多个提交时，每个线程都要去写本地的开销是有点大的，所以将会用到线程池和消息队列。
在返回状态上，将会涉及到多种状态的判定：
Accept 通过
Wrong Answer 答案错误
Compile Error 编译错误
Runtime Error 运行错误
Time Limit Exceeded 时间超限
至于OOM内存超限，我能力有限，暂时还没想到好的做法，希望有董哥可以分享一下
1.提交的代码封装成可执行文件
如果像牛客一样，那么封装成可执行文件比较简单，直接当文件写下来，java拿Runtime.getRuntime().exec(command)编译和执行就完事了。
像leetcode则比较复杂，leetcode的 70.爬楼梯 提供这样一段代码：
class Solution {
public int climbStairs(int n) {
}
}
这时给他添加代码，得到如下
import java.util.*;
import java.math.*;
class Solution {
public int climbStairs(int n) {
//solution
}
}
public class HelloWorld{
public static void main(String[] args){
Solution solution;
for(int i = 0; i < args.length(); i++){
int arg = Integer.parseInt(args[i]);
System.out.println(solution.climbStairs(arg));
}
}
}
我们这时候就可以使用java中的Runtime.getRuntime().exec(command)编译和执行，但是这样去添加代码，实现会相比牛客那种更复杂（我估计leetcode用的反射，有没有董哥？）。所以，大部分的OnlineJudge系统，都不会做得像leetcode一样，而是像牛客一样，让你自己写输入输出。大家刚学编程的时候，都是做的学校OJ，学校OJ也是像牛客一样，因为这样的实现简单。（差一个空格换行就AC不了，听我说谢谢你），以下是用Runtime.getRuntime().exec(command)的实现：
编译，不是所有语言都需要编译，所以分开了编译和执行，这里实现了java的编译：
package handler;
public class CompileFileHandler{
public static boolean compileJava(String id){
try{
Process process = Runtime.getRuntime().exec("javac " + FileHandler.idToFilePath(id));
process.waitFor();
process.destroy();
if(!FileHandler.isClassFileExists(id)){
return false;
}
}catch(Exception e) {
e.printStackTrace();
return false;
}
return true;
}
}
执行文件，实现执行java文件：
package handler;
import java.io.*;
import java.util.concurrent.TimeUnit;
public class ExecuteFileHandler {
public static String executeJava(String id, String input){
StringBuilder result = new StringBuilder();
try{
//如果不设置classpath属性的话会导致运行a.class时报找不到类文件的错误，按自己的修改
Process process = Runtime.getRuntime().exec("cmd /c set CLASSPATH=C:/Users/admin/task_consumer/temp_execute_files/ && java a" + id);
//这里可能需要修改编码GB2312、GBK、UTF-8
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(process.getOutputStream()));
writer.write(input);
writer.close();
boolean isTimeLimitNoExceeded = process.waitFor(1, TimeUnit.SECONDS);
if(!isTimeLimitNoExceeded){
process.destroy();
return "Time Limit Exceeded";
}
BufferedReader errorReader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
//获得错误信息
String errorMessage = errorReader.readLine();
errorReader.close();
if (errorMessage != null) {
process.destroy();
return "Runtime Error";
}
BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
String line;
//获得执行结果，即执行文件System.out的内容
while ((line = reader.readLine()) != null) {
result.append(line + '\n');
}
reader.close();
process.destroy();
}catch(Exception e) {
e.printStackTrace();
return "Runtime Error";
}
return result.toString();
}
}
获得的结果，与正确值对比，正确报Accept，错误报Wrong Answer。所以前面说在返回状态上，Accept、Wrong Answer、Compile Error、Runtime Error是比较简单的。如果想使用更详细的执行错误的信息，可以使用Process.getErrorStream()获得Error流信息。
关于process类的使用，这篇文章写的非常详细[https://zhuanlan.zhihu.com/p/44957705]
一些文件相关的函数
package handler;
import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
public class FileHandler {
public static String dirPath = "temp_execute_files";
public static void makeFile(String id, String content){
File dir = new File(dirPath);
if (!dir.exists()) {
dir.mkdirs();
}
File sourceFile = new File(idToFilePath(id));
try {
if(!sourceFile.exists()){
sourceFile.createNewFile();
}
Files.write(sourceFile.toPath(), content.getBytes(StandardCharsets.UTF_8));
} catch (IOException e) {
e.printStackTrace();
}
}
public static String idToFilePath(String id){
return dirPath + "/a"+ id + ".java";
}
public static String idToSourceFilePath(String id){
return dirPath + "/a" + id;
}
public static boolean isClassFileExists(String id){
File file = new File(dirPath + "/a"+ id + ".class");
return file.exists();
}
}
2.使用反射
浅谈一下反射，反射也可以实现上面的流程，反射可以执行一个文件并且返回它的结果。如果只是想完成Java的编译和执行，Java自带反射，实现比runtime.exec方法简单。但是TLE的判断需要自己做。
代码示例：
package util;
import javax.tools.JavaCompiler;
import javax.tools.ToolProvider;
public class CompileFileHandler{
public boolean compileJava(String filePath) {
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
if (compiler == null) {
return false;
}
int compilationResult = compiler.run(null, null, null, filePath);
if (compilationResult != 0) {
return false;
}
return true;
}
}
package util;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
public class ExecuteFileHandler {
public String executeJava(URL url, String filePath, String input) {
try {
URLClassLoader classLoader = URLClassLoader.newInstance(new URL[]{url});
Class<?> cls = Class.forName(filePath, true, classLoader);
Object instance = cls.newInstance();
Method method = cls.getDeclaredMethod("solution", String.class);
String result = (String) method.invoke(instance, input);
return result;
} catch (Exception e) {
e.printStackTrace();
return "Runtime Error";
}
}
}
3.使用线程池，消息队列
首先我们的网站在获得提交代码的请求后，Controller->Service会将提交的代码封装成一个消息，发送到对应判题端的socket中，判题端接收到消息，会放入消息队列中，线程池中的工作线程只要空闲就会消费消息队列中的内容。
Java已经实现好了各种线程池+消息队列了，拿来用就行。
主线程代码如下：
import runnable.TaskRunnable;
import java.io.IOException;
import java.net.ServerSocket;
import java.util.concurrent.*;
public class MainFunction {
public static void main(String[] argc){
if(argc.length != 1){
System.out.println("Invalid parameter!(java filename {listen-port})");
}
int lestenPort = Integer.parseInt(argc[0]);
//初始化线程池，对于线程池的使用可百度
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(4, 8, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
try {
//监听一个端口，网站后端会发封装好的任务过来。
ServerSocket serverSocket = new ServerSocket(lestenPort);
while(true){
//测试阶段，
/*
Socket socket = serverSocket.accept();
DataInputStream in = new DataInputStream(socket.getInputStream());
String content = in.readUTF();
System.out.println(in.readUTF());
socket.close();*/
//测试用，模仿用户提交它的代码
String content = "01234567890123456789012345678901\n" +
"import java.util.Scanner;\n" +
"import java.io.IOException;\n" +
"\n" +
"public class a01234567890123456789012345678901{\n" +
" public static void main(String[] args) throws IOException{\n" +
" Scanner input = new Scanner(System.in);\n" +
" int len = Integer.parseInt(input.nextLine());\n" +
" for(int i = 0; i < len; i++){\n" +
" System.out.println(input.nextLine());\n" +
" }\n" +
" input.close();\n" +
" }\n" +
"}";
TaskRunnable taskRunnable = new TaskRunnable();
taskRunnable.setParam(content);
threadPoolExecutor.execute(taskRunnable);
break;
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
我们的工作线程，实现了Runnable接口：
package runnable;
import handler.CompileFileHandler;
import handler.DatabaseHandler;
import handler.ExecuteFileHandler;
import handler.FileHandler;
import vo.QuesionVO;
public class TaskRunnable implements Runnable{
String id;
String code;
public void setParam(String content){
id = content.substring(0, 32);
code = content.substring(32);
}
@Override
public void run() {
try{
FileHandler.makeFile(id, code);
DatabaseHandler databaseHandler = new DatabaseHandler();
if(!CompileFileHandler.compileJava(id)){
databaseHandler.writeDatabase(id, "Compile Error");
return;
}
QuesionVO quesionVO = databaseHandler.readDatabaseQuesion(id);
String result = ExecuteFileHandler.executeJava(id, quesionVO.getInput());
if(result.equals("Time Limit Exceeded")){
databaseHandler.writeDatabase(id, result);
}else if(result.equals("Runtime Error")){
databaseHandler.writeDatabase(id, result);
}else{
if(result.equals(quesionVO.getOutput())){
databaseHandler.writeDatabase(id, "Accept");
}else{
databaseHandler.writeDatabase(id, "Wrong Answer");
}
}
}catch (Exception e){
e.printStackTrace();
}
}
}
4.关于线程的计时
前面也说到了，反射的计时需要自己做，但是runtime.exec方法则不需要，注意到Process.waitFor的另一个方法waitFor(long timeout, TimeUnit unit)的源码：
public boolean waitFor(long timeout, TimeUnit unit)
throws InterruptedException
{
long startTime = System.nanoTime();
long rem = unit.toNanos(timeout);
do {
try {
exitValue();
return true;
} catch(IllegalThreadStateException ex) {
if (rem > 0)
Thread.sleep(
Math.min(TimeUnit.NANOSECONDS.toMillis(rem) + 1, 100));
}
rem = unit.toNanos(timeout) - (System.nanoTime() - startTime);
} while (rem > 0);
return false;
}
大概这个意思就是，看看执行完了没有，执行完了就返回true，没执行完会过min(timeout, 100毫秒)的时间会再来看看，要是timeout过了还没执行完，那就返回false。
写的非常好，这样写计时线程，精度会更高，很多地方都可以用到这种思想（要是我来写直接sleep(1000)）。所以在我们的ExecuteFileHandler 中有以下判断：
boolean isTimeLimitNoExceeded = process.waitFor(1, TimeUnit.SECONDS);
if(!isTimeLimitNoExceeded){
process.destroy();
return "Time Limit Exceeded";
}
注意这里waitFor是不会去处理线程的状态，只是对于状态的一种判断。所以记得要destroy线程。
三、测试
我建议拿这个题目做测试，上楼梯（斐波那契数列）
楼梯有n阶台阶，上楼可以一步上1阶，也可以一步上2阶，走完n阶台阶共有多少种不同的走法？
实际上，这是一个斐波那契数列，f(n) = f(n-1) + f(n-2)
f(0) = 1、f(1) = 1、f(2) = 2、f(3) = 3、 f(4) = 5、f(5) = 8、f(6) = 13、f(7) = 21、f(8) = 34…
解法：
1.递归
时间复杂度O(2 ^ N)，空间复杂度O(2 ^ N)
2.动态规划
时间复杂度O(N)，空间复杂度O(N)可降至O(1)
3.快速幂
时间复杂度O(logN) 空间复杂度O(1)
这里的目标是递归不给通过（报Time Limit Exceeded），动态规划和快速幂可以通过。
这里没有还没有实现相应的函数，只是方便我们测试：
package handler;
import vo.QuesionVO;
public class DatabaseHandler {
//实现根据提交记录uuid写结果到数据库
public void writeDatabase(String id, String result){
System.out.println(id + " : " + result);
}
//实现根据提交纪录uuid读出相对应问题的测试案例
public QuesionVO readDatabaseQuesion(String id){
return new QuesionVO("1\n1\n", "1\n");
}
}
package vo;
public class QuesionVO{
String input;
String output;
public QuesionVO(String a, String b){
input = a;
output = b;
}
public String getInput(){
return input;
}
public String getOutput(){
return output;
}
}
总结
最后，task consumer整个项目结构：
这样就简单地完成了我们的判题端~
但像是内存超限，我暂时还没想到解决方法，希望有董哥能够指点指点。
还需要注意的是恶意代码，需要做一下输入的检查，这个可以放到网站前后端去实现。