20145312 《Java程序设计》第六周学习总结

20145312 《Java程序设计》第六周学习总结

学习笔记

Chapter10 输入 /输出

10.1InputStream 与 OutputStream

10.1.1 串流设计的概念

1. Java 将输入/输出抽象化为串流，数据有来源及目的地，衔接两者的是串流对象。
2. 在来源与目的地都不知道的情况下，举个例子来说，可以设计一个通用的 dump()方法。
   代码如下：

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 = -1;
            while ((length = input.read(data)) != -1){
                output.write(data, 0, length);
            }
        }
    }
}
/*
dump()方法接受 InputStream 与 OutputStream 实例，分别代表读取数据的来源，以及输 出数据的目的地。在进行 InputStream 与 OutputStream 的相关操作时若发生错误，会抛出 java.io.IOException 异常，在这里不特别处理，而是在 dump()方法上声明 throws，由调用 dump()方法的客户端处理。 在不使用 InputStream 与 OutputStream 时，必须使用 close()方法关闭串流。由于 InputStream 与 OutputStream 操作了 java.io.Closeable 接 口 ，其 父 接 口 为 java.lang.AutoCloseable 接口，因此可使用 JDK7 尝试自动关闭资源语法。 
 */

1. dump()方法并没有 限定来源或目的地真实形式，而是依赖于抽象的 InputStream、OutputStream。如果要将某个 文档读入并另存为另一个文档，则可以这么使用：

import java.io.*;
public class Copy {
    public static void main(String[] args) throws IOException {
        IO.dump{
            new FileInputStream(args[0]),
            new FileOutputStream(args[1])
        };
    }
}
/*
这个程序可以由命令行自变量指定读取的文档来源与写出的目的地，例如： 
> java cc.openhome.Copy c:\workspace\Main.java C:\workspace\Main.txt 
 */

3.如果要从 HTTP 服务器读取某个网页，并另存为文档，也可以使用这里设计的 dump() 方法。
代码如下：

import java.io.*;
import java.net.URL;
public class Download {
    public static void main(String[] args) throws IOException{
        URL url = new URL(args[0]);
        InputStream src = url.openStream();
        OutputStream dest = new FileOutputStream(args[1]);
        IO.dump(src, dest);
    }
}
/*
 只要指定网址，java.net.URL实例会自动进行 HTTP 协议。可以使用 openStream()方法取得 InputStream 实例，代表 与网站连接的数据串流。可以这样指定网址下载文档：
> java cc.openhome.Download http://openhome.cc c:\workspace\index.txt
 */

10.1.2 串流继承架构

1. 标准输入/输出
    System.in 与 System.out查看 API 文件的话，会发现它们分别是 InputStream 与 PrintStream 的实例，分别代表标准输入(Standard input)与标准输出(Standard output)，通常对应至文本模式中的输入与输出。
    以 System.in 而言，因为文本模式下通常是取得整行用户输入，因此较少直接操作 InputStream 相关方法，而是如前面章节使用 java.util.Scanner 打包 System.in。
   1）下面范例故意将标准输入指定为 FileInputStream，可以读取指定文档并显示在文本模式：

import java.io.*;
import java.util.*;
public class StandardIn {
    public static void main(String[] args) throws IOException{
        System.setIn(new FileInputStream(args[0]));
        try (Scanner scanner = new Scanner(System.in)){
            while (scanner.hasNextLine()){
                System.out.println(scanner.nextLine());
            }
        }
    }
}

2）如果使用>>则是附加信息。可以使用 System 的 setOut()方法指定PrintStream 实例，将结果输出至指定的目的地。例如，故意将标准输出指定至文档：

import java.io.*;
public class StandardOut {
    public static void main(String[] args) throws IOException{
        try (PrintStream printStream = new PrintStream(
                new FileOutputStream(args[0]))){
            System.setOut(printStream);
            System.out.println("HelloWorld");
        }
    }
}
/*
PrintStream 接受 InputStream 实例，在这个范例中用 PrintStream 打包 FileOutputStream， 操作 PrintStream 相关方法，PrintStream 会代你操作 FileOutputStream。 
 */

1. FileInputStream 与 FileOutputStream
   1） FileInputStream 是 InputStream 的子类，可以指定文件名创建实例读取数据。FileOutputStream 是 OutputStream 的子类，可以指定文件名创 建实例写出数据。无论 FileInputStream 还是 FileOutputStream，不使用时都要使用 close()关闭文档。
   2）FileInputStream 主要操作了 InputStream 的 read()抽象方法，使之可从文档中读取数据， FileOutputStream 主要操作了 OutputStream 的 write()抽象方法，使之可写出数据至文档。

2. ByteArrayInputStream 与 ByteArrayOutputStream
   1）ByteArrayInputStream 是 InputStream 的子类，可以指定 byte 数组创建实例将 byte 数组当作数据源进行读取。ByteArrayOutputStream 是 OutputStream 的子类，可 以指定 byte 数组创建实例将 byte 数组当作目的地写出数据。
   2）ByteArrayInputStream 主要操作了 InputStream 的 read()抽象方法，使之可从 byte 数组 中读取数据。ByteArrayOutputStream 主要操作了 OutputStream 的 write()抽象方法，使之可 写出数据至 byte 数组。

   10.1.3 串流处理装饰器

3. BufferedInputStream 与 BufferedOutputStream
   1）BufferedInputStream 与 BufferedOutputStream 主要在内部提供缓冲区功能，操作上与 InputStream、OutputStream 并没有太大差别。例如，改写前面的 IO.dump()为 BufferedIO.dump() 方法：

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 = -1;
            while ((length = input.read(data)) != -1){
                output.write(data, 0, length);
            }
        }
    }
}

1. DataInputStream 与 DataOutputStream
   1）DataInputStream、DataOutputStream 用来装饰 InputStream、OutputStream，DataInputStream、 DataOutputStream 提供读取、写入 Java 基本数据类型的方法，像是读写 int、double、 boolean 等的方法。这些方法会自动在指定的类型与字节间转换。
   2）下面的 Member 类可以调用 save()储存 Member 实例本身的数据，文件名为 Member 的会员号码，调用 Member.load()指定 会员号码，则可以读取文档中的会员数据，封装为 Member 实例并返回：

import java.io.*;
public class Member {
    private String number;
    private String name;
    private int age;

    public Member(String number, String name, int age){
        this.number = number;
        this.name = name;
        this.age = age;
    }
    // 部分程序代码省略，因为只一些Getter、Setter...
    @Override
    public String toString(){
        return String.format("(%s, %s, %d)", number, name, age);
    }
    public void save(){
        try(DataOutputStream output = //建立 DataOutputStream 打包 FileOutputStream
                    new DataOutputStream(new FileOutputStream(number))){
            output.writeUTF(number);
            output.writeUTF(name);
            output.writeInt(age);
        } catch(IOException ex){ //根据不同的类型调用 writeXXX()方法
            throw new RuntimeException(ex);
        }
    }
    public static Member load(String number){
        Member member = null;
        try(DataInputStream input = // 建立 DataInputStream 打包 FileInputStream 
                    new DataInputStream(new FileInputStream(number))){
            member = new Member(
                    input.readUTF(), input.readUTF(), input.readInt());
        } catch(IOException ex){
            throw new RuntimeException(ex);
        }
        return member;
    }
}

3）在 save()方法中，使用 DataOutputStream 打包 FileOutputStream，储存 Member 实例时， 会使用 writeUTF()、writeInt()方法分别储存字符串与 int 类型。在 load()方法中，则使 用 DataInputStream 打包 FileInputStream，并调用 readUTF()、readInt()分别读入字符串、 int 类型。下面是个使用 Member 类的例子：

public class MemberDemo {
    public static void main(String[] args) {
        Member[] members = {new Member("B1234", "Justin", 90),
                new Member("B5678", "Monica", 95),
                new Member("B9876", "Irene", 88)};
        for (Member member : members) {
            member.save();
        }
        System.out.println(Member.load("B1234"));
        System.out.println(Member.load("B5678"));
        System.out.println(Member.load("B9876"));
    }
}

结果如下：

(B1234, Justin, 90)
(B5678, Monica, 95)
(B9876, Irene, 88)

1. ObjectInputStream 与 ObjectOutputStream
   1）ObjectInputStream 提供 readObject()方法将数据读入为对象，而 ObjectOutputStream 提 供 writeObject()方法将对象写至目的地，可以被这两个方法处理的对象，必须操作 java.io.Serializable 接口，下面这个范例改写前一个范例，使用 ObjectInputStream、ObjectOutputStream 来储存、 读入数据：

import java.io.*;
public class Member2 implements Serializable  {
    private String number;
    private String name;
    private int age;

    public Member2(String number, String name, int age){
        this.number = number;
        this.name = name;
        this.age = age;
    }
    // 部分程序代码省略,因为只一些Getter、Setter...
    @Override
    public String toString() {
        return String.format("(%s, %s, %d)", number, name, age);
    }
    public void save() {
        try(ObjectOutputStream output =
                    new ObjectOutputStream(new FileOutputStream(number))) {
            output.writeObject(this);
        } catch(IOException ex) {
            throw new RuntimeException(ex);
        }
    }
    public static Member2 load(String number) {
        Member2 member = null;
        try(ObjectInputStream input =
                    new ObjectInputStream(new FileInputStream(number))) {
            member = (Member2) input.readObject();
        } catch(IOException | ClassNotFoundException ex) {
            throw new RuntimeException(ex);
        }
        return member;
    }
}

2）下面的程序用来测试 Member2 类是否可正确写出与读入对象，执行结果与 MemberDemo 是相同的：

public class Member2Demo {
    public static void main(String[] args) {
        Member2[] members = {new Member2("B1234", "Justin", 90),
                new Member2("B5678", "Monica", 95),
                new Member2("B9876", "Irene", 88)};
        for(Member2 member : members) {
            member.save();
        }
        System.out.println(Member2.load("B1234"));
        System.out.println(Member2.load("B5678"));
        System.out.println(Member2.load("B9876"));
    }
}

结果如下：

(B1234, Justin, 90)
(B5678, Monica, 95)
(B9876, Irene, 88)

10.2 字符处理类

10.2.1 Reader 与 Writer 继承架构

1. 针对字符数据的读取，Java SE 提供了 java.io.Reader 类，其抽象化了字符数据读入 的来源。针对字符数据的写入，则提供了 java.io.Writer 类，其抽象化了数据写出的目的地。 举个例子来说，如果想从来源读入字符数据，或将字符数据写至目的地，都可以使用 下面的 CharUtil.dump()方法：

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 = 0;            
            while((length = input.read(data)) != -1) {                 
                output.write(data, 0, length);            
            }        
        }    
    }
}

1. dump()方法接受 Reader 与 Writer 实例，分别代表读取数据的来源，以及输出数据的目 的地。在进行 Reader 与 Writer 的相关操作时若发生错误，会抛出 IOException 异常。
   3.在不使用 Reader 与 Writer 时，必须使用 close()方法关闭串流。Reader 与 Writer 操作了 Closeable 接口，其父接口为 AutoCloseable 接口。
2. StringWriter 是一种 Writer，可以将字符数据写至 StringWriter，最后使用 toString()方法取得字符串，代表所有写入的字符数据。所以，若要使用 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());
    }
}

10.2.2字符处理装饰器

1. InputStreamReader 与 OutputStreamWriter
   1）串流处理的字节数据，实际上代表某些字符的编码数据，可以使用 InputStreamReader、OutputStreamWriter 对串流数据打包将这些字节数 据转换为对应的编码字符。
   2）在建立 InputStreamReader 与 OutputStreamWriter 时，可以指定编码，如果没有指定编码， 则以 JVM 启动时所获取的默认编码来做字符转换。下面将 CharUtil 的 dump()改写，提供可 指定编码的 dump()方法：

import java.io.*;
public class CharUtil2 {
    public static void dump(Reader src, Writer dest) throws IOException {
        try(Reader input = src; Writer output = dest) {
            char[] data = new char[1024];
            int length = 0;
            while((length = input.read(data)) != -1) {
                output.write(data, 0, length);
            }
        }
    }
    public static void dump(InputStream src, OutputStream dest,
                            String charset) throws IOException {
        dump(
                new InputStreamReader(src, charset),
                new OutputStreamWriter(dest, charset)
        );
    }
    // 采用默认编码
    public static void dump(InputStream src, OutputStream dest)
            throws IOException {
        dump(src, dest, System.getProperty("file.encoding"));
    }
}

1. BufferedReader 与 BufferedWriter
   1）BufferedReader、BufferedWriter 可对 Reader、Writer 提 供缓冲区作用，在处理字符输入/输出时，对效率也会有所帮助。
   2）创建 BufferedReader 时要指定被打包的 Reader，可以指定或采用默认缓冲区大小。
2. PrintWriter
   1）PrintWriter 与 PrintStream 使用上极为类似，不过除了可以对 OutputStream 打包之外， PrintWriter 还可以对 Writer 进行打包，提供 print()、println()、format()等方法。

Chapter 11 线程与并行API

11.1 线程

11.1.1 线程简介

1.单线程程序：启动的程序从 main() 程序进入点开始至结束只有一个流程。
2.多线程程序：程序有多个流程。
3.在 java 中，从 main() 开始的流程会由主线程执行。
代码如下：

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();
    }
}
/*
在以上程序中，主线程执行 main() 定义的流程，main() 定义的流程中建立了 tortoiseThread 与 hareThread 两个线程，这两个线程会分别执行 Tortoise 与 Hare() 的 run() 定义的流程，要启动线程执行指定流程，必须调用 Thread 实例的 start() 方法
*/

11.1.2 Tread与Runnable

1.Thread：如果想要加装主线程，就要创建 Thread 实例，要启动额外的主线程就是调用 Thread 实例的 start() 方法
2.额外线程执行流程的进入点，有两种方式：
•可以定义在 Runnable 的 run() 方法中
•继承 Thread 类，重新定义 run() 方法
3.在 java 中，任何线程可执行的流程都要定义在 Runnable 的 run() 方法，Thread 类本身也操作了 Runnable 接口，run() 方法的操作如下：

@Override
public void run(){
    if(target != null){
       target.run();
    }
}

11.1.3 线程生命周期

1.Daemon 线程
1)主线程会从 main() 方法开始执行，直到 main() 方法结束后停止 JVM
2)如果主线程中启动了额外线程，默认会等待被启动的所有线程都执行完 run() 方法才中止 JVM
3)如果一个 Thread 被标示为 Daemon 线程，在所有的非 Daemon 线程都结束时，JVM 自动就会终止
4)从 main() 方法开始的就是一个非 Daemin 线程，可以使用 setDaemon() 方法来设定一个线程是否为 Daemon 线程.
代码如下：

package cc.openhome;

public class DaemonDemo {

    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (true) {
                System.out.println("Orz");
            }
        });
        // thread.setDaemon(true);
        thread.start();
    }
}
/*使用 isDaemon() 方法可以判断线程是否为 Daemon 线程*/

2.Thread 基本状态图
1）在调用 Thread 实例 start() 方法后，基本状态为可执行（Runnable）、被阻断（Blocked）、执行中（Running）
2）状态间的转移如下图：

3）setPriority()：线程有其优先权，可使用 Thread 的 setPriority() 方法设定优先权，可设定值为1到10，默认是5，超出1到10外的设定值会抛出 IllegalArgumentException
4）数字越大优先权越高，排版器越优先排入 CPU，如果优先权相同，则输流执行
5）改进效能的方式：运用多线程，当某线程进入 Blocked 时，让另一线程排入 CPU 执行，避免 CPU 空闲下来
6）interrupt()：一个进入 Blocked 状态的线程，可以由另一个线程调用，该线程的 interrupt() 方法，让它离开 Blocked 状态，例：

public class InterruptedDemo {

    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(99999);
            } catch (InterruptedException ex) {
                System.out.println("我醒了XD");
            }
        });
        thread.start();
        thread.interrupt(); // 主线程调用thread的interrupt()
    }
}

3.安插线程
1)join()：如果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将结束...");
    }
}

4.停止线程
1）线程完成 run() 方法后，就会进入 Dead ，进入 Dead 的线程不可以再次调用 start() 方法，否则会抛出 IllegalThreadStateException
2）如果要停止线程，最好自行操作，让线程跑完应有的流程，而非调用 Thread 的 stop() 方法
3）stop()：直接调用 Thread 的 stop() 方法，将不理会所设定的释放、取得锁定流程，线程会直接释放所有已锁定对象，这有可能使对象陷入无法预期状态

11.1.4 ThreadGroup

1.每个线程都属于某个线程群组
2.每个线程产生时，都会归入某个线程群组，这视线程在那个群组中产生，如果没有指定，则归入产生该子线程的线程群组，也可以自行指定线程群组，线程一旦归入某个群组，就无法再更换
3.java.lang.ThreadGroup：管理群组中的线程，可以使用以下方式产生群组，并在产生线程时指定所属群组：

ThreadGroup group1 = new ThreadGroup("group1");
ThreadGroup group2 = new ThreadGroup("group2");
Thread thread1 = new Thread(group1,"group1's member");
Thread thread2 = new Thread(group2,"group2's member");

4.interrupt()：中断群组中所有线程
5.setMaxpriority()：设定群组中所有线程最大优先权（本来就有更高优先权的线程不受影响）
6.enumerate()：一次取得群组中所有线程：

Thread[] threads = new Thread[threadGroup1.activeCount()];
threadGroup1.enumerate(threads);

7.activeCount()：取得群组的线程数量，enumerate() 方法要传入 Thread 数组，这会将线程对象设定至每个数组索引
8.uncaughtException()：群组中某个线程发生异常而未捕捉时，JVM 会调用此方法进行处理。如果 ThreadGroup 有父 ThreadGroup，就会调用父 ThreadGroup 的 uncaughtException() 方法，否则看看异常是否为 ThreadDeath 实例，若是则什么都不做，若不是则调用异常的 printStrackTrace()，如果必须定义 ThreadGroup 中的线程异常处理行为，可重新定义此方法，例：

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();
    }
}

9.uncaughtException() 方法第一个参数可取得发生异常的线程实例，第二个参数可取得异常对象在JDK5 之后，如果 ThreadGroup 中的线程发生异常，uncaughtException() 方法处理顺序为：
1）如果 ThreadGroup 有父 ThreadGroup，就会调用父 ThreadGroup 的 uncaughtException() 方法
2）否则，看看 Thread 是否使用 setUncaughtExceptionHandler() 方法设定 Thread.Uncaught-ExceptionHandler 实例，有的话就会调用其 uncaughtException() 方法
3）否则，看看异常是否为 ThreadDeath 实例，若“是”则什么都不做，若“否”则调用异常的 printfStractTrace()
10.对于线程本身未捕捉的异常，可以自行指定处理方式。
代码如下：

public class ThreadGroupDemo2 {

    public static void main(String[] args) {
        ThreadGroup group = new ThreadGroup("group");
        
        Thread thread1 = new Thread(group, () -> {
            throw new RuntimeException("thread1 测试例外");
        });
        thread1.setUncaughtExceptionHandler((thread, throwable) -> {
            System.out.printf("%s: %s%n", 
                    thread.getName(), throwable.getMessage());
        });

        Thread thread2 = new Thread(group, () -> {
            throw new RuntimeException("thread2 测试异常");
        });

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

11.1.5 synchronized 与 volatile
1.synchronized
1）每个对象都会有个内部锁定，或称为监控锁定。被标示为 synchronized 的区块将会被监控，任何线程要执行 synchronized 区块都必须先取得指定的对象锁定
2）如果在方法上标示 synchronized，则执行方法必须取得该实例的锁定
3）线程若因尝试执行 synchronized 区块而进入 Blocked，在取得锁定之后，会先回到 Runnable 状态，等待 CPU 排版器排入 Running 状态
4）java的 synchronized 提供的是可重入同步，也就是线程取得某对象锁定后，若执行过程中又要执行 synchronized，尝试取得锁定的对象来源又是同一个，则可以直接执行
5）有些资源在多线程下彼此交叉取用，有可能造成死结。
代码如下：

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();
    }
}

2.volatile
1）synchronized 要求达到的所标示区块的互斥性与可见性，互斥性是指 synchronized 区块同时间只能有一个线程，可见性是指线程离开 synchronized 区块后，另一线程接触到的就是上一线程改变后的对象状态
2）在java中对于可见性的要求，可以使用 volatile 达到变量范围。
代码如下：

class Variable1 {
    static int i = 0, j = 0;

    static void one() {
        i++;
        j++;
    }

    static void two() {
        System.out.printf("i = %d, j = %d%n", i, j);
    }
}

public class Variable1Test {
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            while (true) {
                Variable1.one();
            }
        });
        Thread thread2 = new Thread(() -> {
            while (true) {
                Variable1.two();
            }
        });
        
        thread1.start();
        thread2.start();
    }
}

3）可以在变量上声明 volatile，表示变量是不稳定的、易变的，也就是可能在多线程下存取，这保证变量的可见性，也就是若有线程变动了变量值，另一线程一定可以看到变更。被标示为 volatile 的变量，不允许线程快取，变量值的存取一定是在共享内存中进行。
代码如下：

class Variable3 {
    volatile static int i = 0, j = 0;

    static void one() {
        i++;
        j++;
    }

    static void two() {
        System.out.printf("i = %d, j = %d%n", i, j);
    }
}

public class Variable3Test {
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            while (true) {
                Variable3.one();
            }
        });
        Thread thread2 = new Thread(() -> {
            while (true) {
                Variable3.two();
            }
        });
        thread1.start();
        thread2.start();
    }
}
/*
volatile 保证的是单一变数的可见性，线程对变量的存取一定是在共享内存中，不会在自己的内存空间中快取变量，线程对共享内存中变量的存取，另一线程一定看得到
*/

11.1.6 等待与通知

1.wait()、notify()、notifyAll() 是 Object 定义的方法，可以通过这三个方法控制线程释放对象的锁定，或者通知线程参与锁定竞争
2.wait()：执行 synchronized 范围的程序代码期间，若要调用锁定对象的 wait() 方法，线程会释放对象锁定，并进入对象等待集合而处于阻断状态，其他线程可以竞争对象锁定，取得锁定的线程可以执行 synchronized 范围的程序代码。wait() 可以指定等待时间，时间到之后线程会再次加入排班，如果指定时间0或不指定，则线程会持续等待，只到被中断或是告知可以参与排班
3.noyify()：被竞争锁定的对象调用 noyify() 时，会从对象等待集合中随机通知一个线程加入排班，再次执行 synchronized 前，被通知的线程会与其他线程共同竞争对象锁定
4.notifyAll()：如果调用 notifyAll()，所有等待集合中的线程都会被通知参与排班，这些线程会与其他线程共同竞争对象锁定

11.2并行API

11.2.1 Lock、ReadWriteLock 与 Condition

1.Lock
1）Lock 接口主要操作类之一为 ReentrantLock，可以达到synchronized 的作用，也提供额外的功能。
代码如下：

import java.util.Arrays;
import java.util.concurrent.locks.*;

public class ArrayList<E> {
    private Lock lock = new ReentrantLock();
    private Object[] elems;
    private int next;
   
    public ArrayList(int capacity) {
        elems = new Object[capacity];
    }

    public ArrayList() {
        this(16);
    }

    public void add(E elem) {
        lock.lock();
        try {
            if (next == elems.length) {
                elems = Arrays.copyOf(elems, elems.length * 2);
            }
            elems[next++] = elem;
        } finally {
            lock.unlock();
        }
    }
    
    public E get(int index) {
        lock.lock();
        try {
            return (E) elems[index];
        } finally {
            lock.unlock();
        }
    }
    
    public int size() {
        lock.lock();
        try {
            return next;
        } finally {
            lock.unlock();
        }
    }
}
/*
想要锁定 Lock 对象，可以调用其 lock 方法，只有取得 Lock 对象锁定的线程，才可以继续往后执行程序代码，要接触锁定，可以调用 Lock 对象的 unlock()
*/

2）Lock 接口还定义了tryLock() 方法，如果线程调用 tryLock() 可以取得锁定会返回 true，若无法取得锁定并不会发生阻断，而是返回 false。
代码如下：

import java.util.concurrent.locks.*;

class Resource {
    private ReentrantLock lock = new ReentrantLock();
    private String name;

    Resource(String name) {
        this.name = name;
    }
    
    void cooperate(Resource res) {
        while (true) {
            try {
                if (lockMeAnd(res)) {
                    System.out.printf("%s 整合 %s 的资源%n", this.name, res.name);
                    break;
                }
            } finally {
                unLockMeAnd(res);
            }
        }
    }

    private boolean lockMeAnd(Resource res) {
        return this.lock.tryLock() && res.lock.tryLock();
    }

    private void unLockMeAnd(Resource res) {
        if (this.lock.isHeldByCurrentThread()) {
            this.lock.unlock();
        }
        if (res.lock.isHeldByCurrentThread()) {
            res.lock.unlock();
        }
    }
}

public class NoDeadLockDemo {

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

2.ReadWriteLock
1）ReadWriteLock 接口定义了读取锁定与写入锁定行为，可以使用 readLock()、writeLock() 方法返回 Lock 操作对象
2）ReentrantReadWriteLock.ReadLock 操作了Lock 接口，调用其 lock() 方法时，若没有任何 ReentrantReadWriteLock.WriteLock 调用过 lock() 方法，也就是没有任何写入锁定时，就可以取得读取锁定
3）ReentrantReadWriteLock.WriteLock 操作了 Lock 接口，调用其 lock() 方法时，若没有任何 ReentrantReadWriteLock.ReadLock 或 ReentrantReadWriteLock.WriteLock 调用过 lock() 方法，也就是没有任何读取或写入锁定时，才可以取得写入锁定

3.StampedLock
1）StampedLock：支持乐观读取操作。
代码如下：

import java.util.Arrays;
import java.util.concurrent.locks.*;

public class ArrayList3<E> {
    private StampedLock lock = new StampedLock();
    private Object[] elems;
    private int next;

    public ArrayList3(int capacity) {
        elems = new Object[capacity];
    }

    public ArrayList3() {
        this(16);
    }

    public void add(E elem) {
        long stamp = lock.writeLock();
        try {
            if (next == elems.length) {
                elems = Arrays.copyOf(elems, elems.length * 2);
            }
            elems[next++] = elem;
        } finally {
            lock.unlockWrite(stamp);
        }
    }

    public E get(int index) {
        long stamp = lock.tryOptimisticRead();
        Object elem = elems[index];
        if (!lock.validate(stamp)) {
            stamp = lock.readLock();
            try {
                elem = elems[index];
            } finally {
                lock.unlockRead(stamp);
            }
        }
        return (E) elem;
    }

    public int size() {
        long stamp = lock.tryOptimisticRead();
        int size = next;
        if (!lock.validate(stamp)) {
            stamp = lock.readLock();
            try {
                size = next;
            } finally {
                lock.unlockRead(stamp);
            }
        }
        return size;
    }
}
/*
validate()：验证戳记是不是被其他排他性锁定取得了，如果是的话返回 false，如果戳记是 0 也会返回 false
*/

3.Condition
1）Condition 接口用来搭配 Lock，最基本的用法就是达到 Object 的 wait()、notify()、notifyAll() 方法的作用。
代码如下：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Clerk {
    private int product = -1;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void setProduct(int product) throws InterruptedException {
        lock.lock();        
        try {
            waitIfFull();
            this.product = product;
            System.out.printf("生产者设定 (%d)%n", this.product);
            condition.signal();
        } finally {
            lock.unlock();
        }
    }

    private void waitIfFull() throws InterruptedException {
        while (this.product != -1) {
            condition.await();
        }
    }

    public int getProduct() throws InterruptedException {
        lock.lock();        
        try {
            waitIfEmpty();
            int p = this.product;
            this.product = -1;
            System.out.printf("消费者取走 (%d)%n", p);
            condition.signal();
            return p;
        } finally {
            lock.unlock();
        }
    }

    private void waitIfEmpty() throws InterruptedException {
        while (this.product == -1) {
            condition.await();
        }
    }
}

2）signal()：要通知等待集合中的一个线程，则可以调用 signal() 方法，signalAll()：如果要通知所有等待集合中的线程，可以调用 signalAll()。
3）一个Condition 对象可代表有一个等待集合，可以重复调用 Lock 的newCondition()，取得多个Condition 实例，这代表了可以有多个等待集合

11.2.2 Executor

1.从JDK5 开始，定义了 java.util.concurrent.Executor 接口，目的是将 Runnable 的指定与实际如何执行分离
2.Executor 接口只定义了一个 execute() 方法：

package java.util.concurrent;
public interface Executor{
    void execute(Runnable command);
}

3.ThreadPoolExecutor
1）根据不同的线程池需求，ThreadPoolExecutor 拥有数种不同构造函数可供使用，不过通常会使用 java.util.concurrent.Executors 的 newCachedThreadPool()、newFixedThreadPool() 静态方法来创建 ThreadPoolExecutor 实例。
代码如下：

import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Download3 {
    public static void main(String[] args) throws Exception {
        URL[] urls = {
            new URL("http://openhome.cc/Gossip/Encoding/"),
            new URL("http://openhome.cc/Gossip/Scala/"),
            new URL("http://openhome.cc/Gossip/JavaScript/"),
            new URL("http://openhome.cc/Gossip/Python/")
        };
        
        String[] fileNames = {
            "Encoding.html",
            "Scala.html",
            "JavaScript.html",
            "Python.html"
        };

        ExecutorService executorService = Executors.newCachedThreadPool();
        new Pages(urls, fileNames, executorService).download();
        executorService.shutdown();
    }
}

4.ScheduledThreadPoolExecutor
1）ScheduledExecutorService 的操作类 ScheduledThreadPoolExecutor 为 ThreadPoolExecutor 的子类，具有线程池与排程功能。
代码如下：

import java.util.concurrent.*;

public class ScheduledExecutorServiceDemo {

    public static void main(String[] args) {
        ScheduledExecutorService service
                = Executors.newSingleThreadScheduledExecutor();
        
        service.scheduleWithFixedDelay(
                () -> {
                    System.out.println(new java.util.Date());
                    try {
                        Thread.sleep(2000); // 假设这个工作会进行两秒
                    } catch (InterruptedException ex) {
                        throw new RuntimeException(ex);
                    }
                }, 2000, 1000, TimeUnit.MILLISECONDS);
    }
}

5.ForkJoinPool

•java.util.ForkJoinPool：解决分而治之的问题

•在分而治之需要结合并行的情况下，可以使用 ForkJoinTask，其操作了 Future 接口，可以让你在未来取得耗时工作的执行结果

•ForkJoinPool 与其他的 ExecutorService 操作不同的地方在于，它实现了工作窃取演算，其建立的线程如果完成手边任务，会尝试寻找并执行其他任务建立的子任务，让线程保持忙碌状态，有效利用处理器的能力

11.2.3并行Collection

1.CopyOnWriteArraySet 操作了 List 接口，这个类的实例在写入操作时，内部会建立新数组，并复制原有数组索引的参考，然后在新数组上进行写入操作，写入完成后，再将内部原参考旧数组的变量参考至新数组
2.BllockingQueu 是 Queue 的子接口，新定义了 put() 与 take() 等方法，线程若调用 put() 方法，在队列已满的情况下会被阻断，线程若调用 take() 方法，在队列为空的情况下会被阻断.
代码如下：

import java.util.concurrent.BlockingQueue;

public class Producer3 implements Runnable {
    private BlockingQueue<Integer> productQueue; 
    
    public Producer3(BlockingQueue<Integer> productQueue) { 
        this.productQueue = productQueue; 
    } 
    
    public void run() { 
        System.out.println("生产者开始生产整数......"); 
        for(int product = 1; product <= 10; product++) { 
            try { 
                productQueue.put(product);
                System.out.printf("生产者提供整数 (%d)%n", product);
            } catch (InterruptedException ex) {
                throw new RuntimeException(ex);
            }
        }       
    } 
}

代码托管截图

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

问题：在编写教材P325页的代码时，每次运行的结果为什么不一样？
解决：在仔细分析代码后我发现：程序中设置了兔子随机睡觉，如果兔子不睡觉就将 hareStep 递增2，表示兔子走两步，只要兔子或乌龟其中一个走完10步就离开循环，根据兔子睡觉的随机性，结果不同。

其他（感悟、思考等，可选）

本周学习任务较重，再加上之前的还有未消化的内容，本周我花了大量的时间在看书和敲代码上。本周主要学习的输入输出和线程与并行又提高了一个难度与深度，但是学得多了，打的代码多了自然就掌握了不少Java编程的技巧。希望我今后的学习能越来越好。

学习进度条

参考资料

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

转载于:https://www.cnblogs.com/yx20145312/p/5376293.html