从多线程想到做有意义的编程

    写着各程序的意义在那里呢？

    很多时候我们写的代码都是没有意义的，比如重复的方法，重复的程序模块，同样的写法，相似的实习机制，测试都显得那样的时曾相识的等等。结果呢？很多代码都烂熟于胸了，而往后的日子中遇到相似的问题，很容易就稀里哗啦的就程序写完，然后有一种工作完成的成就感，轻松，愉悦，但是这样的编程意义在哪？

    自己也写了好多代码！很多时候有人会问一个程序员的代码量，10W行，20W行，或者问一个计算机专业的毕业生代码多少W行，更甚者在找工作时还要有有什么10W行代码量。看到就好笑，其实事实大伙都心知肚明的；圈子里流传这么一句：“工作20年的人，可能只有5年的经验；而工作5年的人，也可能有20年的经验”。

    说到这，大伙看一篇文章:技术人员，你拿什么拯救你的生活--温水煮青蛙

    看来这篇文章，感触还是很深的，我们的行业还处于社会主义初级阶段时期，还有很长的路要走，需要我们的努力好，思考，行动，改变。

    什么是有意义的编程呢？

    学习软件开发也有些日子了，代码写了不少，前不久将先前的程序全部删除掉了。还依稀记得当初的些许想法，这些程序留下来，等学到更多知识和技巧的时候可以拿来复读一下，或者改改。事实证明这个很不现实的想法。首先当初的代码没成体系，也就是说只是对知识点的测试，或者是一下小的程序，根本不值花时间在这上面；其次要做一个合格的开发这编码当然要有过硬的功力，但这还不是最重要的。软件的开发思想，对软件本身的理解和对软件开发的思考更为重要，需求分析，系统设计等等，所以说在时间的价值上不值得投入；最后呢！当初的编码没有长久的意义，那些代码的生命周期就是验证问题，当问题解决了，它的生命意义也就结束了。

   晚上看来下多线程就写了下面代码，主要实现文件的复制。

1. package hj.xiao.filecopy; 
2.  
3. import java.io.BufferedInputStream; 
4. import java.io.BufferedOutputStream; 
5. import java.io.File; 
6. import java.io.FileInputStream; 
7. import java.io.FileNotFoundException; 
8. import java.io.FileOutputStream; 
9. import java.io.IOException; 
10.  
11. public class CopyThread implements Runnable { 
12.  
13.     // 源文件目录 
14.     private File srcDir; 
15.     // 目的文件目录 
16.     private File dstDir; 
17.  
18.     // 构造方法，创建文件目录对象 
19.     public CopyThread(String srcDir, String dstDir) { 
20.         File srcTarget = new File(srcDir); 
21.         File dstTarget = new File(dstDir); 
22.         if (srcTarget.exists() && srcTarget.isDirectory()) { 
23.             this.srcDir = srcTarget; 
24.         } 
25.         if (!dstTarget.exists()) { 
26.             boolean bo = dstTarget.mkdirs(); 
27.             if (bo) { 
28.                 this.dstDir = dstTarget; 
29.             } else { 
30.                 String defaultPath = System.getProperty("user.dir"); 
31.                 dstTarget = new File(defaultPath); 
32.                 dstTarget.mkdirs(); 
33.             } 
34.         } 
35.     } 
36.  
37.     // 实现Runnable接口 
38.     @Override 
39.     public void run() { 
40.         copyFile(this.srcDir, this.dstDir); 
41.     } 
42.  
43.     // 文件复制的实现方法 
44.     private void copyFile(File src, File dst) { 
45.         File[] fs = src.listFiles(); 
46.         BufferedInputStream bis = null; 
47.         BufferedOutputStream bos = null; 
48.         if (fs.length == 0) { 
49.             return; 
50.         } 
51.         byte[] bufs = new byte[1024 * 1024]; 
52.         int size = 0; 
53.         for (File f : fs) { 
54.             if (f.isFile()) { 
55.                 try { 
56.                     bis = new BufferedInputStream(new FileInputStream(f)); 
57.                     String dstPath = dst.getAbsolutePath() + File.separator 
58.                             + f.getName(); 
59.                     File dstFile = new File(dstPath); 
60.                     boolean bo = dstFile.createNewFile(); 
61.                     if (bo) { 
62.                         bos = new BufferedOutputStream(new FileOutputStream( 
63.                                 dstFile)); 
64.                     } 
65.                     while ((size = bis.read(bufs, 0, bufs.length)) != -1) { 
66.                         bos.write(bufs, 0, size); 
67.                     } 
68.                     bis.close(); 
69.                     bos.close(); 
70.                 } catch (FileNotFoundException e) { 
71.                     e.printStackTrace(); 
72.                 } catch (IOException e) { 
73.                     e.printStackTrace(); 
74.                 } finally { 
75.                     System.gc(); 
76.                 } 
77.             } else { 
78.                 String dstPath = dst.getAbsolutePath() + File.separator 
79.                         + f.getName(); 
80.                 File dstFileDir = new File(dstPath); 
81.                 if (!dstFileDir.exists()) { 
82.                     boolean bo = dstFileDir.mkdirs(); 
83.                     if (bo) { 
84.                         copyFile(f, dstFileDir); 
85.                     } 
86.                 } 
87.             } 
88.         } 
89.     } 
90. } 

写一个主方法来测试：

1. public static void main(String[] args) { 
2.         String src0 = "D:" + File.separator + "摆渡恋人" + File.separator 
3.                 + "Thread1"; 
4.         String dst0 = "G:" + File.separator + "摆渡恋人" + File.separator 
5.                 + "Thread1"; 
6.         String src1 = "D:" + File.separator + "摆渡恋人" + File.separator 
7.                 + "Thread2"; 
8.         String dst1 = "G:" + File.separator + "摆渡恋人" + File.separator 
9.                 + "Thread2"; 
10.         Thread[] thread = new Thread[2]; 
11.         CopyThread[] copy = new CopyThread[2]; 
12.         copy[0] = new CopyThread(src0, dst0); 
13.         copy[1] = new CopyThread(src1, dst1); 
14.         thread[0] = new Thread(copy[0], "Thread Copy-" + 1); 
15.         thread[1] = new Thread(copy[1], "Thread Copy-" + 2); 
16.         thread[0].start(); 
17.         thread[1].start(); 
18.     } 

简简单单的测试一下，然后结果如图：

可以看到目的目录的属性信息和原目录的属性信息相同，文件复制成功。

     到这里这个程序的生命周期就结束了，意义了能说结束吗？

     当然可以说这个程序此时已经不具有什么意义了。

     程序员，我们不甘心，不应该就想到这里，看到这里就停止我们的思考呀！想想看：

     1.将文件复制的类封装起来，并增加文件处理过程信息，这样就可以把握我们的处理过程

     2.如果传人一个文件夹目录我们能否通过程序自动来识别该目录下的文件夹和文件，然后继续想，能不能通过设置一定的文件大小阀值来采用不同的机制实现文件复制；或者通过文件的大小范围来确定用指定的线程来处理，而不同的线程中的处理方法可以有不同的实现机制

     3.如果是桌面应用程序，能否继续实现断点式的复制

     4.接下来还有程序的设计，能够继续扩展而不做大的改动，能否封装后做到通用。

    等等，程序死了，人还要活着，还得为美好的明天活得更好，所以思考就不能停下来。

    回到上面的问题，有意义的编程，每个人都有自己的想法和思考，我觉得有意义的编程：

    首先：解放自己，远离代码苦工

    其次：不断质疑，不断实践，不断挑战未曾尝试的东西

    再次：解放别人，软件不会给用户带来技能力上的压力，体验上的反感。

    最后：珍惜自己的生命，时间如白驹过隙，韶华易逝，勤动手，多实践，做勤快的人，而不是辛劳的人；代码的意义也就融入了生活的意义当中。