所以，我有一个Gui的问题我正在设计一个java应用程序，它将给定目录中的所有文件重命名为垃圾（只是为了好玩）。这是它背后的主要代码块：
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
/**
* Class for renaming files to garbage names.
* All methods are static, hence private constructor.
* @author The Shadow Hacker
*/
public class RenameFiles {
private static int renamedFiles = 0;
private static int renamedFolders = 0;
public static char theChar = '#';
public static ArrayList<File> fileWhitelist = new ArrayList<>();
public static HashMap<File, File> revert = new HashMap<>();
public static int getRenamedFiles() {
return renamedFiles;
}
public static int getRenamedFolders() {
return renamedFolders;
}
/**
* All methods are static, hence private constructor.
*/
private RenameFiles() {
// Private constructor, nothing to do.
}
/**
* @param file The file to rename.
* @param renameTo The current value of the name to rename it to.
* @return A new value for renameTo.
*/
private static String renameFile(File file, String renameTo) {
for (File whitelistedFile : fileWhitelist) {
if (whitelistedFile.getAbsolutePath().equals(file.getAbsolutePath())) {
return renameTo;
}
}
if (new File(file.getParentFile().getAbsolutePath() + "/" + renameTo).exists()) {
renameTo += theChar;
renameFile(file, renameTo);
} else {
revert.put(new File(file.getParent() + "/" + renameTo), file);
file.renameTo(new File(file.getParent() + "/" + renameTo));
if (new File(file.getParent() + "/" + renameTo).isDirectory()) {
renamedFolders++;
} else {
renamedFiles++;
}
}
return renameTo;
}
/**
* TODO Add exception handling.
* @param dir The root directory.
* @throws NullPointerException if it can't open the dir
*/
public static void renameAllFiles(File dir) {
String hashtags = Character.toString(theChar);
for (File file : dir.listFiles()) {
if (file.isDirectory()) {
renameAllFiles(file);
hashtags = renameFile(file, hashtags);
} else {
hashtags = renameFile(file, hashtags);
}
}
}
public static void renameAllFiles(String dir) {
renameAllFiles(new File(dir));
}
/**
* This uses the revert HashMap to change the files back to their orignal names,
* if the user decides he didn't want to change the names of the files later.
* @param dir The directory in which to search.
*/
public static void revert(File dir) {
for (File file : dir.listFiles()) {
if (file.isDirectory()) {
revert(file);
}
revert.forEach((name, renameTo) -> {
if (file.getName().equals(name.getName())) {
file.renameTo(renameTo);
}
});
}
}
public static void revert(String dir) {
revert(new File(dir));
}
/**
* Saves the revert configs to a JSON file; can't use obj.writeJSONString(out)
* because a File's toString() method just calls getName(), and we want full
* paths.
* @param whereToSave The file to save the config to.
* @throws IOException
*/
@SuppressWarnings("unchecked")
public static void saveRevertConfigs(String whereToSave) throws IOException {
PrintWriter out = new PrintWriter(whereToSave);
JSONObject obj = new JSONObject();
revert.forEach((k, v) -> {
obj.put(k.getAbsolutePath(), v.getAbsolutePath());
});
out.write(obj.toJSONString());
out.close();
}
/**
* Warning - clears revert.
* Can't use obj.putAll(revert) because that puts the strings
* into revert, and we want Files.
* TODO Add exception handling.
* @param whereToLoad The path to the file to load.
* @throws ParseException If the file can't be read.
*/
@SuppressWarnings("unchecked")
public static void loadRevertConfigs(String whereToLoad) throws ParseException {
revert.clear();
((JSONObject) new JSONParser().parse(whereToLoad)).forEach((k, v) -> {
revert.put(new File((String) k), new File((String) v));
});
}
/**
* This static block is here because the program uses forEach
* loops, and we don't want the methods that call them to
* return errors.
*/
static {
if (!(System.getProperty("java.version").startsWith("1.8") || System.getProperty("java.version").startsWith("1.9"))) {
System.err.println("Must use java version 1.8 or above.");
System.exit(1);
}
}
/**
* Even though I made a gui for this, it still has a complete command-line interface
* because Reasons.
* @param argv[0] The folder to rename files in; defaults to the current directory.
* @throws IOException
*/
public static void main(String[] argv) throws IOException {
Scanner scanner = new Scanner(System.in);
String accept;
if (argv.length == 0) {
System.out.print("Are you sure you want to proceed? This could potentially damage your system! (y/n) : ");
accept = scanner.nextLine();
scanner.close();
if (!(accept.equalsIgnoreCase("y") || accept.equalsIgnoreCase("yes"))) {
System.exit(1);
}
renameAllFiles(System.getProperty("user.dir"));
} else if (argv.length == 1 && new File(argv[0]).exists()) {
System.out.print("Are you sure you want to proceed? This could potentially damage your system! (y/n) : ");
accept = scanner.nextLine();
scanner.close();
if (!(accept.equalsIgnoreCase("y") || accept.equalsIgnoreCase("yes"))) {
System.exit(1);
}
renameAllFiles(argv[0]);
} else {
System.out.println("Usage: renameAllFiles [\033[3mpath\033[0m]");
scanner.close();
System.exit(1);
}
System.out.println("Renamed " + (renamedFiles != 0 ? renamedFiles : "no") + " file" + (renamedFiles == 1 ? "" : "s")
+ " and " + (renamedFolders != 0 ? renamedFolders : "no") + " folder" + (renamedFolders == 1 ? "." : "s."));
}
}
如您所见，它的所有方法都是静态的。现在这是我的（仅部分完成的）事件处理程序类：
import java.io.File;
/**
* Seperate class for the gui event handlers.
* Mostly just calls methods from RenameFiles.
* Like RenameFiles, all methods are static.
* @author The Shadow Hacker
*/
public class EventHandlers {
private static Thread t;
/**
* The reason this is in a new thread is so we can check
* if it is done or not (For the 'cancel' option).
* @param dir The root directory used by RenameFiles.renameAllFiles.
*/
public static void start(File dir) {
t = new Thread(() -> {
RenameFiles.renameAllFiles(dir);
});
t.start();
}
/**
* @param dir The root directory used by RenameFiles.revert(dir).
* @throws InterruptedException
*/
public static void cancel(File dir) throws InterruptedException {
new Thread(() -> {
while (t.isAlive()) {
// Nothing to do; simply waiting for t to end.
}
RenameFiles.revert(dir);
}).start();
}
public static void main(String[] args) throws InterruptedException {
start(new File("rename"));
cancel(new File("rename"));
}
}
我遇到的问题是，当我从RenameFiles类运行revert时，它工作正常，但是从多线程运行它时（我们不希望处理程序必须等待为了在对另一个按钮做出反应之前完成的方法按下）EventHandlers类，恢复dosn工作。这是否与RenameFiles是一个包含所有静态方法的类或其他东西有关？请帮忙！
编辑：@Douglas，当我跑：
import java.io.File;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* Seperate class for the gui event handlers.
* Mostly just calls methods from RenameFiles.
* Like RenameFiles, all methods are static.
* @author The Shadow Hacker
*/
public class EventHandlers {
private static ExecutorService service = Executors.newSingleThreadExecutor();
private static volatile CountDownLatch latch;
/**
* The reason this is in a new thread is so we can check
* if it is done or not (For the 'cancel' option).
* @param dir The root directory used by RenameFiles.renameAllFiles.
*/
public static void start(File dir) {
latch = new CountDownLatch(1);
service.submit(() -> {
RenameFiles.renameAllFiles(dir);
latch.countDown();
});
}
/**
* @param dir The root directory used by RenameFiles.revert(dir).
* @throws InterruptedException
*/
public static void cancel(File dir) throws InterruptedException {
service.submit(() -> {
try {
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
RenameFiles.revert(dir);
});
}
程序只会永远运行，而不会终止。
答案 0 :(得分：3)
这里有两个主要问题。
首先，您在线程之间共享变量。 Java中的默认变量处理无法保证两个线程将就任何给定变量的值达成一致。您可以通过为每个变量赋予volatile修饰符来修复此问题（注意：这可能会降低性能，这就是为什么它不是默认值）。
其次，您没有任何机制来保证线程执行顺序。如上所述，EventHandlers.main完全可以在cancel调用开始之前运行renameAllFiles完成。重命名也可以开始，由线程调度程序暂停，从头到尾取消运行，然后重命名完成，或任何一堆其他组合。您尝试使用t.isAlive()检查对此做了一些事情，但您在Thread中多余创建了另一个main表示无法保证t甚至已初始化在主线程到达之前。根据规范，你可以从该行获得NullPointerException，这是不太可能但有效的。
第二个问题是一般来说难以解决的问题，并且使用线程的主要原因是臭名昭着。幸运的是，这个特殊问题是一个相当简单的案例。不是在isAlive()检查上永远循环，而是在启动线程时创建CountDownLatch，在线程完成时将其计算下来，并在await()中简单地cancel。这也可以同时解决第一个问题，而不需要volatile，因为除了调度协调之外，CountDownLatch保证等待它的任何线程都能看到完成的所有结果在计算它的任何线程中。
所以，长话短说，解决这个问题的步骤：
new Thread中的main，然后直接致电start。 start本身会创建一个Thread，无需将其嵌套在另一个Thread内。Thread t替换为CountDownLatch。start中，将CountDownLatch初始化为1。start后，通过调用Executors.newSingleThreadExecutor()获取CountDownLatch，然后ExecutorService { {1}}打电话给它。这样做而不是直接使用submit。除此之外，规范保证在此之前完成的任何事情都会在新主题中按预期显示，我在renameAllFiles的文档中看不到任何此类保证。它还有更多的便利和实用方法。Thread的内容中，重命名后，请在锁定屏幕上调用Thread.start()。ExecutorService之后，请致电countDown()上的submit。这将阻止您重复使用同一个，但会阻止它无限期地等待再也不会发生。shutdown()中，通过调用锁存器上的ExecutorService来替换cancel循环。除了内存一致性保证之外，这还可以通过让系统线程调度程序处理等待而不是花费CPU时间进行循环来提高性能。如果您想在同一批程序中考虑多个重命名操作，则需要进行其他更改。