不需要就算了，Balk 即 停止并返回。

    我们在并发编程的时候，经常会遇到这样的情况，就是我们并发请求，但是只要一个回应，谁先来就用谁，后来的就扔掉。现实中就是，老师让我们回答问题，问：1+1 等于多少？ 然后抢答，你的手速比较慢，小明先回答了：2。虽然你内心极度不甘心，虽然你知道等于 10 但是你没有机会了。

    好了，小葵花课堂开课了，我们如何在程序中实现这个呢？其实很简单，用一个 flag 来保存，是否有人抢到。如果有人抢到了就把 flag 置为true。那么后来的自然就不能去响应了。这个就要保证修改 flag 的时候是 synchronized 。
    在举个例子，我们平时用的word，会有自动保存的功能。保存线程每隔1秒保存一下，但是如果没有改变是不需要再次保存的。

    Data 最关键的就是 changed 这个 flag。change 和 save 都是 synchronized 的方法。保证安全。

    1. public class Data {
    3.     private String fileName;
    4.     private String content;
    5.     private boolean changed;
    7.     public Data(String fileName, String content) {
    8.         this.fileName = fileName;
    9.         this.content = content;
    10.     }
    12.     public synchronized void change(String newContent) {
    13.         this.content = newContent;
    14.         changed = true;
    15.     }
    17.     public synchronized void save() throws IOException {
    18.         if (changed == true) {
    19.             doSave();
    20.             changed = false;
    21.         } else {
    22.             System.out.println(Thread.currentThread().getName()+"-- no change");
    23.             return;
    24.         }
    25.     }
    27.     private void doSave() throws IOException {
    28.         System.out.println(Thread.currentThread().getName()+"--"+content);
    29.         Writer writer = new FileWriter(fileName);
    30.         writer.write(content);
    31.         writer.close();
    32.     }
    33. }

    SaverThread 线程 每一秒保存一下。

    1. public class SaverThread extends Thread {
    2.     private final Data data;
    4.     public SaverThread(String name, Data data) {
    5.         super(name);
    6.         this.data = data;
    7.     }
    9.     @Override
    10.     public void run() {
    11.         super.run();
    12.         try {
    13.             while (true) {
    15.                 data.save();
    16.                 Thread.sleep(1000);
    17.             }
    18.         } catch (IOException e) {
    19.             e.printStackTrace();
    20.         } catch (InterruptedException e) {
    21.             e.printStackTrace();
    22.         }
    23.     }
    24. }

    ChangerThread 线程 不定时写入。

    1. public class ChangerThread extends Thread {
    2.     private final Data data;
    3.     private Random random = new Random();
    5.     public ChangerThread(String name, Data data) {
    6.         super(name);
    7.         this.data = data;
    8.     }
    10.     @Override
    11.     public void run() {
    12.         super.run();
    13.         Random random = new Random();
    14.         long num = 0;
    15.         try {
    16.             while (true) {
    18.                 String str = "change:" + num++;
    19.                 data.change(str);
    20.                 Thread.sleep(random.nextInt(2000));
    22.             }
    23.         } catch (InterruptedException e) {
    24.             e.printStackTrace();
    25.         }
    27.     }
    28. }
    1. public class Main {
    3.     public static void main(String[] args) {
    4.         Data data = new Data("data.txt", "empty");
    5.         new ChangerThread("ChangerThread",data).start();
    6.         new SaverThread("SaverThread",data).start();
    8.     }
    9. }

    实行结果如下：

    image.png