20145238-荆玉茗 《Java程序设计》第6周学习总结

20145238 《Java程序设计》第6周学习总结

教材学习内容总结

第十章输入和输出
10.1.1
·如果要将数据从来源中取出，可以使用输入串流，若将数据写入目的地，可以使用输出串流。在java中，输入串流代表对象为java.in.InputStream实例，输出串流代表对象为java.io.Outputstream实例
·在来源与目的地都不知道的情况下可以设计一个通用的dump（）方法,该方法接受InputStream与OutputStream实例，分别代表读取数据的来源，以及输出的目的地

import java.io.*;

public class IO {
    public static void dump(InputStream src, OutputStream dest)
                               throws IOException {
        try (InputStream input = src; OutputStream output = dest) {
            byte[] data = new byte[1024];
            int length;
            while ((length = input.read(data)) != -1) {
                output.write(data, 0, length);
            }
        }
    }
}

·每次从Inputstream读入的数据，都会先置入byte数据，她的read（）方法会尝试读入btye的数据，并返回读入的字节。

·要将某个文档读入并另存为另一个数据，可以由命令行操作如下java cc.openhome.Copy c:\workspace\Main.java C:\workspace\Main.txt
10.1.2
·可以使用System的setIn（）方法指定InputStream实例，重新指定标准输入来源
·FileInputStream是InputStream的子类，主要操作InputStream的read（）抽象方法；FIleOutputStream是OutputStream的子类，主要操作其write（）的操作方法
·ByteArrayInputStream是InputStream的子类，可以指定byte数据创建实例，主要操作其read（）抽象方法；ByteArrayOutputStream是OutputStream的子类，主要操作其write（） 的操作方法

10.1.3
串流装饰器本身并没有改变InputStream和OutputStream的行为，只是在得到数据之后，再做一些加工处理。
·BufferedInputStream与BufferedOutputStream主要在内部提供缓冲区功能。

import java.io.*;

public class BufferedIO {
    public static void dump(InputStream src, OutputStream dest)
                              throws IOException {
        try(InputStream input = new BufferedInputStream(src);
             OutputStream output = new BufferedOutputStream(dest)) {
            byte[] data = new byte[1024];
            int length;
            while ((length = input.read(data)) != -1) {
                output.write(data, 0, length);
            }
        }
    }
}

·DataInputStream与DataOutputStream主要提供读取、写入java基本数据类型的方法，会自动在指定的类型与字节之间转换。实例代码见git开源中国。

10.2.1
·Reader、Writer也有一些装饰器类可供使用，如果串流处理的字节数据，实际上代表某些字符的编码数据，而你想要将这些字节数据转换为对应的编码字符，可以使用InputStreamReader和OutputStreamWriter
示范代码如下

import java.io.*;

public class CharUtil {
    public static void dump(Reader src, Writer dest) throws IOException {
        try(Reader input = src; Writer output = dest) {
            char[] data = new char[1024];
            int length;
            while((length = input.read(data)) != -1) {
                output.write(data, 0, length);
            }
        }
    }
}

·若要使用CharUtil.dump（）读入文档、转为字符串并显示在文本模式中，可以如下：

import java.io.*;

public class CharUtilDemo {
    public static void main(String[] args) throws IOException {
        FileReader reader = new FileReader(args[0]);
        StringWriter writer = new StringWriter();
        CharUtil.dump(reader, writer);
        System.out.println(writer.toString());
    }
}

·解析几个常用子类：
StringReader可以将字符串打包，当做读取来源，StringWriter可以作为写入目的地，最后toString（）取得所有写入的字符组成的字符串。CharArrayReader、CharArrayWriter类似，将char数组当做读取来源以及写入目的地。

10.2.2
·如果处理串流字节数据，将这些字节数据转换为对应的编码制度，可以使用 InputStringReader、InputStringWriter打包。
·BufferedReader、BufferedWriter可对Reader、Writer提供缓冲区，
·printWriter与PrintStream处理可以对OutputStream打包之外，Printwriter还可以对writer进行打包，提供print（）、println（）、format（）等方法。

第十一章线程与并行API
11.1
·单线程程序：启动的程序从main（）程序进入点开始至结束只有一个流程。示范代码如下：

import static java.lang.System.out;

public class TortoiseHareRace {
    public static void main(String[] args) {
        boolean[] flags = {true, false};
        int totalStep = 10;
        int tortoiseStep = 0;
        int hareStep = 0;
        out.println("龜兔賽跑開始...");
        while(tortoiseStep < totalStep && hareStep < totalStep) {
            tortoiseStep++;       
            out.printf("烏龜跑了 %d 步...%n", tortoiseStep);
            boolean isHareSleep = flags[((int) (Math.random() * 10)) % 2];
            if(isHareSleep) {
                out.println("兔子睡著了zzzz");
            } else {
                hareStep += 2;    
                out.printf("兔子跑了 %d 步...%n", hareStep);
            }
        }
    }
}

·多线程程序：一个程序拥有多个流程。示范代码如下：

public class TortoiseHareRace2 {
    public static void main(String[] args) {
        Tortoise tortoise = new Tortoise(10);
        Hare hare = new Hare(10);
        Thread tortoiseThread = new Thread(tortoise);
        Thread hareThread = new Thread(hare);
        tortoiseThread.start();
        hareThread.start();
    }
}

·撰写多线程程序的方式：操作Runnable接口，在run（）中定义额外流程；继承Thread类，在run（）中定义额外流程；

·差别：操作Runnable接口的好处就是较有弹性，类还有机会继承其他类；若继承了Thread类，那该类就是一种Thread，通常是为了直接利用Thread中定义的一些方法，才会继承Thread来操作。

·如果主程序中启动了额外线程，默认会等待被启动的所有线程都执行完run（）方法才中止JVM。如果一个Thread被标示为Daemon线程，在所有的非Daemon线程都结束时，JVM自动就会终止。

public class DaemonDemo {

    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (true) {
                System.out.println("Orz");
            }
        });
        // thread.setDaemon(true);
        thread.start();
    }
}

·在调用Thread实例start（）方法后，基本状态为可执行（Runnable）、被阻断（Blocked）、执行中（Running）。

·线程有其优先权，可使用Thread的setPriority（）方法设定优先权，可设定值为1到10，默认是5，超出1到10外的设定值会抛出IllegalArgumentException。数字越大优先权越高，排班器越优先排入CPU，如果优先权相同，则输流执行。

·如果A线程正在运行，流程中允许B线程加入，等到B线程执行完毕后再继续A线程流程，则可以使用join（）方法完成这个需求。示范代码如下

import static java.lang.System.out;

public class JoinDemo {

    public static void main(String[] args) throws InterruptedException {
        out.println("Main thread 開始...");

        Thread threadB = new Thread(() -> {
            out.println("Thread B 開始...");
            for (int i = 0; i < 5; i++) {
                out.println("Thread B 執行...");
            }
            out.println("Thread B 將結束...");
        });

        threadB.start();
        threadB.join(); // Thread B 加入 Main thread 流程

        out.println("Main thread將結束...");
    }
}

·线程完成run（）方法后，就会进入Dead，进入Dead（或已经调用过start（）方法）的线程不可以再次调用start（）方法，否则会抛出IllegalArgumentException。

·如果要停止线程，最好自行操作，让线程跑完应有的流程，而非调用Thread的stop（）方法。不仅停止线程必须自行根据条件操作，线程的暂停、重启，也必须视需求操作，而不是直接调用suspend（）、resume（）等方法。

public class ThreadGroupDemo {

    public static void main(String[] args) {
        ThreadGroup group = new ThreadGroup("group") {
            @Override
            public void uncaughtException(Thread thread, Throwable throwable) {
                System.out.printf("%s: %s%n", 
                        thread.getName(), throwable.getMessage());
            }
        };

        Thread thread = new Thread(group, () -> {
            throw new RuntimeException("測試例外");
        });

        thread.start();
    }
}

·每个线程产生时，都会归入某个线程群组，这视线程是在哪个群组中产生，如在main（）主流程中产生一个线程，该线程会属于main线程群组。如果没有指定，则归入产生该子线程的线程群组，也可以自行指定线程群组，线程一旦归入某个群组，就无法更换群组。

·每个对象都会有个内部锁定，或称为监控锁定。被标示为synchronized的区块将会被监控，任何线程要执行synchronized区块都必须先取得指定的对象锁定。
·如果在方法上标示synchronized，则执行方法必须取得该实例的锁定。synchronized不只可声明在方法上，也可以描述句方式使用。不正确的使用可能会造成死结。

class Resource {
    private String name;
    private int resource;

    Resource(String name, int resource) {
        this.name = name;
        this.resource = resource;
    }

    String getName() {
        return name;
    }

    synchronized int doSome() {
        return ++resource;
    }

    synchronized void cooperate(Resource resource) {
        resource.doSome();
        System.out.printf("%s 整合 %s 的資源%n",
                this.name, resource.getName());
    }
}

public class DeadLockDemo {
    public static void main(String[] args) {
        Resource resource1 = new Resource("resource1", 10);
        Resource resource2 = new Resource("resource2", 20);
        
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                resource1.cooperate(resource2);
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                resource2.cooperate(resource1);
            }
        });

        thread1.start();
        thread2.start();
    }
}

·Java的synchronized提供的是可重入同步，也就是线程取得某对象锁定后，若执行过程中又要执行synchronized，尝试取得锁定的对象又是同一个，则可以直接执行。

·执行synchronized范围的程序代码期间，若调用锁定对象的wait（）方法，线程会释放对象锁定，并进入对象等待集合而处于阻断状态，其他线程可以竞争对象锁定，取得锁定的线程可以执行synchronized范围的程序代码。

·放在等待集合的线程不会参与CPU排班，wait（）可以指定等待时间，时间到之后线程会再次加入排班，如果指定时间0或不指定，则线程会持续等待，直到被中断（调用interrupt（）或是告知notify（））可以参与排班。

·被竞争锁定的对象调用notify（）时，会从对象等待集合中随机通知一个线程加入排班，再次执行synchronized前，被通知的线程会与其他线程共同竞争对象锁定；如果调用notifyAll（），所有等候集合中的线程都会被通知参与排班，这些线程会与其他线程共同竞争对象锁定。

11.2 并行API
·在使用高级并行API时，Lock接口的操作对象可实现synchronized的功能。

import java.util.Arrays;

public class ArrayList {
    private Object[] list;
    private int next;
   
    public ArrayList(int capacity) {
        list = new Object[capacity];
    }

    public ArrayList() {
        this(16);
    }

    public void add(Object o) {
        if(next == list.length) {
            list = Arrays.copyOf(list, list.length * 2);
        }
        list[next++] = o;
    }
    
    public Object get(int index) {
        return list[index];
    }
    
    public int size() {
        return next;
    }
}

·在使用高级并行API时，Condition接口的操作对象可实现Object的wait（）、notify（）、notifyAll（）功能。

·在使用高级并行API时，Future接口的操作对象可以让你在未来取得执行结果。

教材学习中的问题和解决过程

·撰写单线程序、多线程程序的方式差别：操作Runnable接口的好处就是较有弹性，类还有机会继承其他类；若继承了Thread类，那该类就是一种Thread，通常是为了直接利用Thread中定义的一些方法，才会继承Thread来操作。

·StringReader可以将字符串打包，当做读取来源，StringWriter可以作为写入目的地，最后toString（）取得所有写入的字符组成的字符串。CharArrayReader、CharArrayWriter类似，将char数组当做读取来源以及写入目的地。

代码调试中的问题和解决过程

·存档IDEA程序时，再次打开无法运行，只能重新新建一个项目，因为打开时候默认的方式没有通过JDK。。。

其他

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第一周	200/200	2/2	20/20
第二周	300/500	2/4	18/38
第三周	500/1000	3/7	22/60
第四周
第五周
第六周	500/1300	6/9	30/90

参考资料

• Java学习笔记(第8版)
• 《Java学习笔记(第8版)》学习指导
• ...