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

时间:2020-12-11 19:22:59

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

教材学习内容总结

本周学习了课本第十、十一章内容,即输入/输出、线程与并行API。

第十章 输入输出

10.1 InputStream与OutputStream

10.1.1

  • java将输入/输出抽象化为串流,数据有来源及目的地,衔接两者的是串流对象。

  • 从应用程序角度来看,如果要将数据从来源取出,可以使用输入串流,如果要将数据写入目的地,可以使用输出串流。在JAVA中,输入串流代表对象为java.io.InputStream 实例,输出串流代表对象为java.io.OutputStream 实例。

  • 通用的 dump() 方法:
    代码如下:

package cc.openhome;

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数组中。InputStream的 read() 方法,每次会尝试读入 byte 数组的数据,并返回实际读入的字节,只要不是 -1,就表示读取到数据。可以使用OutputStream 的 write() 方法,指定要写出的 byte 数组、初始索引与数据长度。

  • 将某个文档读入并另存为另一个文档:
    代码如下:

package cc.openhome;

import java.io.*;

public class Copy {
    public static void main(String[] args) throws IOException {
        IO.dump(
              new FileInputStream(args[0]), 
              new FileOutputStream(args[1])
        );
    }
}
  • 从http服务器读取某个网页,并另存为文档:
package cc.openhome;

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

10.1.2串流继承架构

  • System.in:文本模式下取得整行用户输入。可以使用System的setIn()方法指定InputStream实例,重新指定标准输入来源。System.out为PrintStream实例。使用 setOut() 方法指定 PrintStream 实例,将结果输出至指定的目的地

  • System.err为PrintStream实例,称为标准错误输出串流,用来立即显示错误信息。

  • 使用System.setErr()指定PrintStream,重新指定标准错误输出串流。

  • FileInputStream是InputStream的子类,可以指定文件名创建实例,一旦创建文档就开启,接着就可用来读取数据,主要操作 InputStream 的 read() 抽象方法,使之可以从文档中读取数据。

  • FileOutputStream可以指定文件名创建实例,一旦创建文档就开启,接着就可用来写出数据,主要操作 InputStream 的 write() 抽象方法,使之可以写出数据至文档。

  • ByteArrayInputStream是InputStream的子类,可以指定 byte 数组创建实例,一旦创建就可将 byte 数组当作数据源进行读取。主要操作了 InputStream 的 read() 抽象方法,使之可从 byte 数组中读取数据。

  • ByteArrayOutputStream是OutputStream的子类可以指定 byte 数组创建实例,一旦创建就可将 byte 数组当作目的地写出数据。主要操作了 OutputStream 的 write() 抽象方法,使之可写出数据至 byte 数组。

10.1.3串流处理装饰器

BufferedInputStream与BufferedOutputStream主要在内部提供缓冲区功能。

代码如下:

package cc.openhome;

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);
            }
        }
    }
}
  1. DataInputStream与DataOutputStrea用来装饰InputStream、OutputStream、DataInputStream、DataOutputStream 提供读取、写入 java 基本数据类型的方法,像是s读写int double boolean 等的方法。这些方法会自动在指定的类型与字节间转换。
    代码如下:
package cc.openhome;

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

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    @Override
    public String toString() {
        return String.format("(%s, %s, %d)", number, name, age);
    }
    
    public void save() throws IOException {
        try(DataOutputStream output = 
                new DataOutputStream(new FileOutputStream(number))) {
            output.writeUTF(number);
            output.writeUTF(name);
            output.writeInt(age);
        } 
    }
    
    public static Member load(String number) throws IOException {
        Member member;
        try(DataInputStream input = 
                new DataInputStream(new FileInputStream(number))) {
            member = new Member(
                    input.readUTF(), input.readUTF(), input.readInt());
        } 
        return member;
    }
}
  • ObjectInputStream 提供 readObject() 方法将数据读入为对象,ObjectOutputStream 提供 writeObject() 方法将对象写至目的地。
    代码如下:
package cc.openhome;

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

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    @Override
    public String toString() {
        return String.format("(%s, %s, %d)", number, name, age);
    }
    
    public void save() throws IOException {
        try(ObjectOutputStream output = 
                new ObjectOutputStream(new FileOutputStream(number))) {
            output.writeObject(this);
        } 
    }
    
    public static Member2 load(String number) 
                    throws IOException, ClassNotFoundException {
        Member2 member;
        try(ObjectInputStream input = 
                new ObjectInputStream(new FileInputStream(number))) {
            member = (Member2) input.readObject(); 
        } 
        return member;
    }
}

10.2 字符处理类
10.2.1 Reader与Writer 继承架构

针对字符数据的读取,Java SE 提供了 java.io.Reader 类,其抽象化了字符数据读入的来源。针对字符数据的写入,Java SE 提供了 java.io.Writer 类,其抽象化了数据写出的目的地。

  • 如果从来源读入字符数据、将字符数据写至目的地,可以使用 CharUtil.dump() 方法:代码如下
package cc.openhome;

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

每次从Reader 读入的数据,都会先置入 char 数组中.Reader 的 read() 方法,每次会尝试读入 char 数组长度的数据,并返回实际读入的字符数,只要不是-1,就表示读取到字符。可以使用 write() 方法,指定要写出的 byte 数组、初始索引与数据长度。

  • 使用CharUtil.dump() 读入文档、转为字符串并显示在文本模式中:
    代码如下
package cc.openhome;

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对串流数据打包。

  2. BufferedReader 与 BufferedWriter,可对 Reader、Writer 提供缓冲区作用,在处理字符输入/输出时,对效率也会有所帮助。

  3. PrintWriter:除了可对OutStream打包之外,还可对Writer 进行打包,提供 print()、println()、format() 方法。

第十一章 线程与并行API

11.1线程

11.1.1线程简介

•单线程程序就是启动的程序从 main() 程序进入点开始至结束只有一个流程。
多线程程序:程序拥有多个流程

•在 java 中,从 main() 开始的流程会由主线程执行。可以创建Thread实例来执行Runnable实例定义的run()方法:
代码如下:

package cc.openhome;

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

运行结果:
20145201 《Java程序设计》第六周学习总结

11.1.2 Thread 与 Runnable

  • 如果想要创建Thread实例,就要启动额外CPU就是调用Thread实例的 start() 方法。

  • 额外线程执行流程的进入点,有两种方式:可以定义在 Runnable 的 run() 方法中。也可以继承 Thread 类,重新定义 run() 方法。

11.1.3线程生命周期

  1. Daemon 线程
  • 主线程会从 main() 方法开始执行,直到 main() 方法结束后停止 JVM。如果主线程中启动了额外线程,默认会等待被启动的所有线程都执行完 run() 方法才中止 JVM。如果一个 Thread 被标示为 Daemon 线程,在所有的非 Daemon 线程都结束时,JVM 自动就会终止。

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

若没有使用setDaemon()设定为true,则程序会不断输出orz不终止,
使用 isDaemon() 方法可以判断线程是否为Daemon线程。

2.Thread 基本状态图

在调用 Thread 实例 start() 方法后,基本状态为可执行(Runnable)、被阻断(Blocked)、执行中(Running)

同一时间点上,一个 CPU 只能执行一个线程,只是 CPU 会不断切换线程,且切换动作很快,所以看起来像是同时执行.

  • 改进效能的方式:运用多线程,当某线程进入 Blocked 时,让另一线程排入 CPU 执行,避免 CPU 空闲下来

  • 一个进入 Blocked 状态的线程,可以由另一个线程调用,该线程的 interrupt() 方法,让它离开 Blocked 状态.

代码如下:

package cc.openhome;

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.安插线程

  • 如果A线程正在运行,流程中允许B线程加入,等到B线程执行完毕后再继续A线程流程,则可以使用 join() 方法完成这个需求。

代码如下:

package cc.openhome;

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将结束...");
    }
}

运行结果:
20145201 《Java程序设计》第六周学习总结

4 . 停止线程

  • 线程完成 run() 方法后,就会进入 Dead ,进入 Dead 的线程不可以再次调用 start() 方法,否则会抛出 IllegalThreadStateException.

  • 直接调用 Thread 的 stop() 方法,将不理会所设定的释放、取得锁定流程,线程会直接释放所有已锁定对象,这有可能使对象陷入无法预期状态.

  • 如果要停止线程,最好自行操作,让线程跑完应有的流程,而非调用 Thread 的 stop() 方法.

11.1.4 关于ThreadGroup

11.1.4 关于ThreadGroup

  • 每个线程都属于某个线程群组。若在main()主流程中生产一个线程,该线程会属于main线程群组。可以使用一下程序片段取得目前线程所属线程群组名:
    Thread.currentThread().getThreadGroup().getName();

  • 每个线程产生时,都会归入某个线程群组,这视线程在那个群组中产生。如果没有指定,则归入产生该子线程的线程群组。也可以自行指定线程群组,线程一旦归入某个群组,就无法再更换。

  • 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");

•interrupt()方法可以中断群组中所有线程。
setMaxpriority()方法可以设定群组中所有线程最大优先权(本来就有更高优先权的线程不受影响)。
enumerate():一次取得群组中所有线程。例如:
Thread[] threads = new Thread[threadGroup1.activeCount()];
threadGroup1.enumerate(threads);
activeCount()方法取得群组的线程数量,enumerate() 方法要传入 Thread 数组,这会将线程对象设定至每个数组索引。

•uncaughtException()方法:群组中某个线程发生异常而未捕捉时,JVM 会调用此方法进行处理。如果 ThreadGroup 有父 ThreadGroup,就会调用父 ThreadGroup 的 uncaughtException() 方法,否则看看异常是否为 ThreadDeath 实例。若是则什么都不做,若不是则调用异常的 printStrackTrace()。如果必须定义 ThreadGroup 中的线程异常处理行为,可重新定义此方法。
例:

package cc.openhome;

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();
    }
}
  • 在JDK5 之后,如果 ThreadGroup 中的线程发生异常,uncaughtException() 方法处理顺序为:

  • 如果 ThreadGroup 有父 ThreadGroup,就会调用父 ThreadGroup 的 uncaughtException() 方法。

  • 否则,看看 Thread 是否使用 setUncaughtExceptionHandler() 方法设定 Thread.Uncaught-ExceptionHandler 实例,有的话就会调用其 uncaughtException() 方法。

  • 否则,看看异常是否为 ThreadDeath 实例,若“是”则什么都不做,若“否”则调用异常的 printfStractTrace()。

•对于线程本身未捕捉的异常,可以自行指定处理方式。
例:

package cc.openhome;

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
    每个对象都会有个内部锁定,或称为监控锁定。被标示为 synchronized 的区块将会被监控,任何线程要执行 synchronized 区块都必须先取得指定的对象锁定。

如果在方法上标示 synchronized,则执行方法必须取得该实例的锁定。

线程若因尝试执行 synchronized 区块而进入 Blocked,在取得锁定之后,会先回到 Runnable 状态,等待 CPU 排版器排入 Running 状态。

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

由于线程无法取得锁定时会造成阻断,不正确地使用synchronized有可能造成能效低落,另一问题则是死结
例如有些资源在多线程下彼此交叉取用,有可能造成死结
代码如下:

package cc.openhome;

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

synchronized 要求达到的所标示区块的互斥性与可见性,互斥性是指 synchronized 区块同时间只能有一个线程,可见性是指线程离开 synchronized 区块后,另一线程接触到的就是上一线程改变后的对象状态。

•在java中对于可见性的要求,可以使用 volatile 达到变量范围,代码如下:

package cc.openhome;

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

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

package cc.openhome;

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等待与通知

wait()、notify()、notifyAll() 是 Object 定义的方法,可以通过这三个方法控制线程释放对象的锁定,或者通知线程参与锁定竞争。

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

  • 被竞争锁定的对象调用 noyify() 时,会从对象等待集合中随机通知一个线程加入排班,再次执行 synchronized 前,被通知的线程会与其他线程共同竞争对象锁定。

  • 如果调用 notifyAll(),所有等待集合中的线程都会被通知参与排班,这些线程会与其他线程共同竞争对象锁定。

11.2并行API

11.2.1Lock、ReadWriteLock 与 Condition

1.使用Lock

•Lock 接口主要操作类之一为 ReentrantLock,可以达到synchronized 的作用,也提供额外的功能。
代码如下:

package cc.openhome;

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().

  • Lock 接口还定义了tryLock() 方法,如果线程调用 tryLock() 可以取得锁定会返回 true,若无法取得锁定并不会发生阻断,而是返回 false。
    代码如下:
package cc.openhome;

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

ReadWriteLock 接口定义了读取锁定与写入锁定行为,可以使用 readLock()、writeLock() 方法返回 Lock 操作对象。

  • ReentrantReadWriteLock.ReadLock 操作了Lock 接口,调用其 lock() 方法时,若没有任何 ReentrantReadWriteLock.WriteLock 调用过 lock() 方法,也就是没有任何写入锁定时,就可以取得读取锁定。

  • ReentrantReadWriteLock.WriteLock 操作了 Lock 接口,调用其 lock() 方法时,若没有任何 ReentrantReadWriteLock.ReadLock 或 ReentrantReadWriteLock.WriteLock 调用过 lock() 方法,也就是没有任何读取或写入锁定时,才可以取得写入锁定。

3.使用StampedLock

•JDK8新新增了StampedLock类,可支持乐观读取操作。

代码如下:

package cc.openhome;

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

4.使用Condition
Condition 接口用来搭配 Lock,最基本的用法就是达到 Object 的 wait()、notify()、notifyAll() 方法的作用

代码如下:

package cc.openhome;

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();
        }
    }
}
  • 要通知等待集合中的一个线程,则可以调用 signal() 方法。
    如果要通知所有等待集合中的线程,可以调用 signalAll()。

  • 一个Condition 对象可代表有一个等待集合,可以重复调用 Lock 的newCondition(),取得多个Condition 实例,这代表了可以有多个等待集合。

11.2.2使用Executor

•从JDK5 开始,定义了 java.util.concurrent.Executor 接口,目的是将 Runnable 的指定与实际如何执行分离。

Executor 接口只定义了一个 execute() 方法:
package java.util.concurrent;
public interface Executor{
void execute(Runnable command);
}

1.使用ThreadPoolExecutor

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

代码如下:

package cc.openhome;

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

2.使用ScheduledThreadPoolExecutor

ScheduledExecutorService 的操作类 ScheduledThreadPoolExecutor 为 ThreadPoolExecutor 的子类,具有线程池与排程功能。
代码如下:

package cc.openhome;

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

3.使用ForkJoinPool

  • java.util.ForkJoinPool主要目的是在解决分而治之的问题

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

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

11.2.3 并行Collection简介

CopyOnWriteArrayList操作了List接口,这个类的实例在写入操作时,内部会建立新数组,并复制原有数组索引的参考。

CopyOnWriteArraySet 操作了 List 接口,这个类的实例在写入操作时,内部会建立新数组,并复制原有数组索引的参考,然后在新数组上进行写入操作,写入完成后,再将内部原参考旧数组的变量参考至新数组。

BllockingQueu 是 Queue 的子接口,新定义了 put() 与 take() 等方法,线程若调用 put() 方法,在队列已满的情况下会被阻断,线程若调用 take() 方法,在队列为空的情况下会被阻断。

代码如下:

package cc.openhome;

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

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

现在调试代码基本可以一次通过,主要是要细心看书,联系前后文,细心一些就可以了。

本周代码托管截图

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

其他(感悟、思考等,可选)

学习进程已经过半,现在基本有了自己的一套学习模式。书本是本源,首先应该把书上的知识弄懂,这期间可能会出现问题,要及时求教老师和同学早日弄懂。这种全新的学习模式,提高了我的自学能力,相信也会在将来的学习工作中是一个很好的经验。
目前还不能自己编写出一些较为复杂的程序,还需要积累经验,不能只是机械的敲代码,要理解其深刻含义。

学习进度条

代码行数(新增/累积) 博客量(新增/累积) 学习时间(新增/累积) 重要成长
目标 4500行 30篇 400小时
第一周 200/200 2/2 20/20
第二周 300/500 1/3 18/38
第三周 400/900 1/4 22/60
第四周 1000/1900 1/5 35/95
第五周 800/2700 1/6 30/125
第六周 700/3400 1/7 30/155