这个代码在统计方面是有缺陷的.(线程嵌套)的不良一面
package experiment10.exp1;
/*用多线程的方法实现目录拷贝*/
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.Scanner;
public class ThreadsCopy {
static int count = 0;
public static void main(String[] args) throws Exception {
Scanner scanner = new Scanner(System.in);
//todo read
System.out.println("输入被复制源目录名:");
String sourceDirectory = scanner.nextLine();
System.out.println("输入副本目标目录名");
String destinationDirectory = scanner.nextLine();
/*调用多线程复制函数*/
long startTime = System.currentTimeMillis();
Thread thread = new Thread(new Runnable() {
public void run() {
try {
copyDir(sourceDirectory, destinationDirectory);
// System.out.println(count+"---");
} catch (IOException e) {
e.printStackTrace();
}
//System.out.println(count+"!!!");
}
});
thread.start();
thread.join();
//System.out.println("共启用了"+count+"个线程");
//todo 这种做法主线程和次线程之间的相对执行顺序还是不明确的(比如主线程对静态变量的打印时机还是不受控的,尽管监视到的累加的最终值是不受影响的.
// 很可能是我对线程嵌套的完整执行的理解不够深刻.;对join的理解不够深刻.
// 目前我认为,线程嵌套的话,新开辟一个线程的语句执行完后,如果没有对应的join来阻塞(直到该线程完整执行完毕才执行下一行代码),那么如果我们想要让嵌套开辟的子线程完全回归,值得每一层配都有join了,如果不都配join,在统计开辟的线程数和运行时间上就比较头疼.
//todo 相应而生的策略:先创建所有需要创建的进程,然后统一start;就解决了线程数的统计问题(统一join,就解决了时间统计的问题)(而且不会退化为单线程排队执行.
/*
Thread threadNew = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("共启用了"+count+"个线程");
}
});
threadNew.start();
threadNew.join();*/
System.out.println("共启用了"+count+"个线程");
System.out.println("目录拷贝完成,共耗时" + (System.currentTimeMillis() - startTime) + "毫秒");
// System.out.println("over!");
}
//todo 多线程嵌套递归的方式复制
/*本递归复制函数具有检查并创建新目录的能力,*/
static void copyDir(String oldPath, String newPath) throws IOException {
System.out.println(count++);//testing(通过中途的内部打印来监视count的累计情况.)
File file = new File(oldPath);
String[] filePath = file.list();/*//当前路径下存在的目录名和文件名的数组.比较建议用list方法,不推荐用listFile方法,因为后面
要通过连接目录名来创建新目录,用字符串比较方便.*/
/*检查新目录是否存在.若不存在,则创建一个*/
if (!(new File(newPath)).exists()) {
(new File(newPath)).mkdir();//创建目录
}
/*遍历当前目录下的子目录和文件*/
// for (int i = 0; i < filePath.length; i++)
for (String x : filePath) {
/*如果这(x)是一个子目录:(执行递归)*/
if ((new File(oldPath + File.separator + x)).isDirectory()) {
Thread thread = new Thread(new Runnable() {
public void run() {
try {
copyDir(oldPath + File.separator + x, newPath + File.separator + x);
} catch (IOException e) {
e.printStackTrace();
}
}
});
thread.start();
}
/*如果x所指的是个文件:执行复制即可*/
if (new File(oldPath + File.separator + x).isFile()) {
File source = new File(oldPath + File.separator + x);
File dest = new File(newPath + File.separator + x);
if (!(dest.exists())) {
Files.copy(source.toPath(), dest.toPath());//创建新文件的能力
}
}
}//endFor
//System.out.println("The replication operation has been successfully executed!");
}//endCopyFunction
}继续修改
package experiment10.exp1;
import experiment9.FileName;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.List;
/**
* @Author xuchaoxin
* @Date 12/19/2020 9:41 AM
* @Version 1.0
*/
public class CreatCopyPathThreads {
/*本递归复制函数具有检查并创建新目录的能力,*/
/**
* @param srcPath 可能是个目录,也可能是个文件
* @param desPath 当srcPath 是一个目录的时候,desPath也必须是一个目录(1.约定该参数和srcPath是相同尾缀时;2.不用关心尾缀
* 可能的参数组合包括:dir->dir;file->file;file->dir;(不可能是dir->file)
* @throws IOException
* @throws InterruptedException
*/
static void copyPath(String srcPath, String desPath) throws IOException, InterruptedException {
// System.out.println(count++);//testing(通过中途的内部打印来监视count的累计情况.)
File srcPathFile = new File(srcPath);
File desFile = new File(desPath);
/* 如果源目标是个目录,则要保证目标目录存在: */
// if (srcPathFile.isDirectory()&&!(new File(desPath)).exists()) {
// (new File(desPath)).mkdir();//创建目录
// }
/*分析源路径*/
if (srcPathFile.isDirectory()) {
if (!(new File(desPath)).exists()) {
desFile.mkdir();//创建目录
}
/*遍历当前目录下的子目录和文件(即各个条目)*/
String[] filesPathString = srcPathFile.list();
for (String subItem : filesPathString) {
String absoluteSrcSubItemStr = srcPath + File.separator + subItem;
String absoluteDesSubItemStr = desPath + File.separator + subItem;
/*直接递归:*/
copyPath(absoluteSrcSubItemStr, absoluteDesSubItemStr);
}//endFor
}//end if
else {
if (!desFile.exists()) {
Files.copy(srcPathFile.toPath(), desFile.toPath());
}
}
//test the class
public static void main(String[] args) {
try {
//计时开始.
long startTime = System.currentTimeMillis();
copyPath(FileName.fileName11_1, "D://src");
System.out.println("单线程目录拷贝完成,共耗时" + (System.currentTimeMillis() - startTime) + "毫秒");
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}//end class
