Balking设计模式

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.concurrent.TimeUnit;

public class Test {
    public static void main(String[] args){
        BalkingTest.test();
    }
}

/*
    22.2 Balking模式之文档编辑

    多个线程监控某个共享变量，A线程监控到共享变量发生变化后即立即触发某个动作，但是
    此时发现另外一个线程B已经针对该变量的变化开始了行动，因此A便放弃了准备开始的工作
    ，我们把这种线程间交互称作Balking（犹豫）设计模式

        ——简而言之，就是当你去获取临界区资源时，发现正有人在使用着，那么你没有阻塞
            而是放弃了去获取这部分的资源。你认定，别的线程已经开始了对这部分资源的
            修改操作，所以你无需操作。
 */
class Document{
    private boolean changed = false;

    private List<String> content = new ArrayList<>();

    private final FileWriter writer;

    private static AutoSaveThread autoSaveThread;

    private Document(String documentPath, String documentName)
        throws IOException {
        this.writer = new FileWriter(new File(documentPath,documentName),true);
    }

    public static Document create(String documentPath, String documentName)
        throws IOException{
        Document document = new Document(documentPath,documentName);
        autoSaveThread = new AutoSaveThread(document);
        autoSaveThread.start();
        return document;
    }

    public void edit(String content) {
        synchronized (this) {
            this.content.add(content);
            this.changed=true;
        }
    }

    public void close() throws IOException{
        autoSaveThread.interrupt();
        writer.close();
    }

    public void save() throws IOException{
        synchronized (this) {
            if (!changed) {
                return;
            }

            System.out.println(Thread.currentThread()+" execute the save action");

            for (String cacheLine : content) {
                this.writer.write(cacheLine);
                this.writer.write("\r\n");
            }
            this.writer.flush();
            this.changed=false;
            this.content.clear();
        }
    }
}

class AutoSaveThread extends Thread{
    private final Document document;

    public AutoSaveThread(Document document) {
        super("DocumentAutoSaveThread");
        this.document = document;
    }

    @Override
    public void run() {
        while (true) {
            try{
                document.save();
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException|IOException e) {
                break;
            }
        }
    }
}

class DocumentEditThread extends Thread{
    private final String documentPath;
    private final String documentName;
    private final Scanner scanner = new Scanner(System.in);

    public DocumentEditThread(String documentPath, String documentName) {
        super("DocumentEditThread");
        this.documentPath = documentPath;
        this.documentName = documentName;
    }

    @Override
    public void run() {
        int times = 0;

        try{
            Document document = Document.create(documentPath,documentName);
            while (true) {
                String text = scanner.next();
                if("quit".equals(text)){
                    document.close();
                    break;
                }
                document.edit(text);
                if (times == 5) {
                    document.save();
                    times=0;
                }
                times++;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class BalkingTest{
    public static void test(){
        new DocumentEditThread(".","temp.tmp").start();
    }
}