多线程程序设计学习（5）balking模式和timed模式

Balking【返回模式】timed【超时模式】
一:balking pattern的参与者
--->GuardedObject(被警戒的对象)

--->该模式的角色：模拟修改警戒对象的线程，当警戒条件达到执行具体操作的线程，参与者（被警戒的参与者）


二：balking pattern模式什么时候使用
--->不需要刻意去执行什么操作的时候（比如说自动保存）
--->不想等待警戒条件成立时。（不让线程休息）
--->警戒条件只有第一次成立时候。

三：balking pattern思考
--->balking pattern (返回模式)和Guarded suspension pattern(等待唤醒模式)的中间
        3.1Guarded suspension当警戒条件不成立时，会等待，直到成立，并被唤醒。
        3.2balking 当警戒条件不成立，退出。
        3.3两种极端的处理方式之间还有一种折衷的做法。在条件成立为止之前，等待一段时间，看看条件是否成立，如果不成立，则balk。这种方式称之为guarded timed 或简单称之为timeOut
---->线程类中的各个唤醒方法
        3.1:当notify方法执行时==>如果wait set里有多条线程，只有一条被唤醒
        3.2:当notifyAll方法执行时==>wait set里有多少条线程都被唤醒。
        3.3:interrupt方法执行时==>wait set里的线程会（与调用notify,notifyAll一样）重新尝试获取锁定。
                                                       ==> notify,notifyAll是对实例调用的，而interrupt是对线程调用的。关于中断，后续会提到。
        3.4:发生timeout时，由于wait（超时时间），和被notify或notifyAll唤醒重新尝试获取锁定，分不清楚，所以timeout需要程序员自己写。

---->sleep和wait的区别有：
1，这两个方法来自不同的类分别是Thread和Object
2，最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
3，wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在
    任何地方使用
   synchronized(x){
      x.notify()
     //或者wait()
   }
   4,sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常
   5.wait被唤醒后，重新获取锁，从阻塞的代码处继续往下执行。和sleep一样。

Balking【返回模式】案例：模拟自动保存文件，当文件没有更改时，每隔一秒的自动保存数据，真正保存操作不执行。如果有修改，则执行真正保存操作。

数据类

 1 package com.yeepay.sxf.thread4;
 2 
 3 import java.io.File;
 4 import java.io.FileOutputStream;
 5 import java.io.IOException;
 6 
 7 /**
 8  * 数据类。
 9  * @author sxf
10  *
11  */
12 public class Data {
13     //文件名
14     private String fileName;
15     //文件内容
16     private String content;
17     //表示是否被修改过
18     private boolean flag;
19     //构造器
20     public Data(String fileName, String content) {
21         super();
22         this.fileName = fileName;
23         this.content = content;
24         this.flag=true;
25         File file =new File(fileName);
26         try {
27             file.createNewFile();
28             FileOutputStream iFileOutputStream=new FileOutputStream(file);
29             iFileOutputStream.write(content.getBytes());
30         } catch (IOException e) {
31             // TODO Auto-generated catch block
32             e.printStackTrace();
33         }
34     }
35     //修改内容
36     public synchronized void channgeContent(String newContent){
37         this.content=newContent ;
38         flag=true;
39     }
40     
41     //把新的数据写入文件
42     private void save() throws IOException{
43         System.out.println("Data.save()"+Thread.currentThread().getName()+"执行写入操作，写入的内容为："+content);
44         FileOutputStream fileWriter=new FileOutputStream(new File(fileName));
45         fileWriter.write(content.getBytes());
46     }
47     
48     //保存内容
49     public synchronized void saveNewContent(){
50         if(!flag){
51             System.out.println("Data.saveNewContent(试图新保存，但没有更改)");
52             return;
53         }
54         try {
55             save();
56             System.out.println("Data.saveNewContent(新内容保存成功)");
57             flag=false;
58         } catch (IOException e) {
59             e.printStackTrace();
60         }
61     }
62 }

View Code

模拟修改数据的线程

 1 package com.yeepay.sxf.thread4;
 2 /**
 3  * 模拟自动修改线程
 4  * @author sxf
 5  *
 6  */
 7 public class ChangeThread implements Runnable{
 8     private Data data;
 9 
10     public ChangeThread(Data data) {
11         super();
12         this.data = data;
13     }
14 
15     @Override
16     public void run() {
17         for(int i=0;i<20;i++){
18             //修改内容
19             System.out.println("ChangeThread.run()"+Thread.currentThread().getName()+"第"+i+"次修改");
20             data.channgeContent("新内容"+i);
21             //线程休息10秒
22             try {
23                 Thread.sleep(10000L);
24             } catch (InterruptedException e) {
25                 // TODO Auto-generated catch block
26                 e.printStackTrace();
27             }
28         }
29     }
30 
31     
32 }

View Code

模拟自动保存的线程

 1 package com.yeepay.sxf.thread4;
 2 /**
 3  * 自动保存的线程
 4  * @author sxf
 5  *
 6  */
 7 public class ZiDongSaveThread implements Runnable{
 8     private Data data;
 9 
10     
11     public ZiDongSaveThread(Data data){
12         this.data=data;
13     }
14     @Override
15     public void run() {
16         while(true){
17             //保存数据
18             data.saveNewContent();
19             //线程休息1秒，意味着每隔一妙钟自动保存一次文件
20             try {
21                 Thread.sleep(1000L);
22             } catch (InterruptedException e) {
23                 // TODO Auto-generated catch block
24                 e.printStackTrace();
25             }
26         }
27         
28     }
29     
30 }

View Code

测试类

 1 package com.yeepay.sxf.thread4;
 2 /**
 3  * 测试类
 4  * @author sxf
 5  *
 6  */
 7 public class Test {
 8     
 9     
10 public static void main(String[] args) {
11     //声明内容
12     Data data=new Data("/usr/war/hsl.txt", "老黄买了新手机");
13     //声明自动保存线程
14     Thread saveThread=new Thread(new ZiDongSaveThread(data));
15     saveThread.setName("自动保存线程");
16     //声明模拟修改线程
17     Thread chaThread=new Thread(new ChangeThread(data));
18     chaThread.setName("模拟修改线程");
19     
20     //启动线程
21     saveThread.start();
22     chaThread.start();
23     
24     
25 }
26 }

View Code

打印结果

Data.save()自动保存线程执行写入操作，写入的内容为：老黄买了新手机
Data.saveNewContent(新内容保存成功)
ChangeThread.run()模拟修改线程第0次修改
Data.save()自动保存线程执行写入操作，写入的内容为：新内容0
Data.saveNewContent(新内容保存成功)
Data.saveNewContent(试图新保存，但没有更改)
Data.saveNewContent(试图新保存，但没有更改)
Data.saveNewContent(试图新保存，但没有更改)
Data.saveNewContent(试图新保存，但没有更改)
Data.saveNewContent(试图新保存，但没有更改)
Data.saveNewContent(试图新保存，但没有更改)
Data.saveNewContent(试图新保存，但没有更改)
Data.saveNewContent(试图新保存，但没有更改)
Data.saveNewContent(试图新保存，但没有更改)
ChangeThread.run()模拟修改线程第1次修改
Data.save()自动保存线程执行写入操作，写入的内容为：新内容1
Data.saveNewContent(新内容保存成功)
Data.saveNewContent(试图新保存，但没有更改)
Data.saveNewContent(试图新保存，但没有更改)
Data.saveNewContent(试图新保存，但没有更改)
Data.saveNewContent(试图新保存，但没有更改)

timed【超时模式】案例：一个线程提供下载数据，另一个线程执行下载，如果有5秒钟以上，提供下载的线程没有提供数据，下载线程因超时异常，停止下载线程运行。

超时异常类

 1 package com.yeepay.sxf.thread4;
 2 /**
 3  * 超时异常类
 4  * @author sxf
 5  *
 6  */
 7 public class TimeOutException extends InterruptedException {
 8 
 9     public TimeOutException(String msg){
10         super(msg);
11     }
12 }

View Code

下载数据的数据类

 1 package com.yeepay.sxf.thread4;
 2 /**
 3  * 下载数据类
 4  * @author sxf
 5  *
 6  */
 7 public class FileData {
 8     //提供下载的数据
 9     private String data;
10     //有数据可下载
11     private boolean flag;
12     //超时时间
13     private long timeout;
14     
15     //构造器
16     public FileData(String data, boolean flag, long timeout) {
17         super();
18         this.data = data;
19         this.flag = flag;
20         this.timeout = timeout;
21     }
22     
23     
24     //修改状态，唤醒其他所有线程
25     public synchronized void  changeStatus(String data){
26         this.data=data;
27         flag=true;
28         notify();
29     }
30     
31     //下载操作。如果等timeout/1000秒钟，没有数据供下载，就报超时异常，终止下载
32     public synchronized void execu() throws InterruptedException{
33         //开始执行的时间
34         long start=System.currentTimeMillis();
35         int i=0;
36         System.out.println("FileData.execu(开始时间1)");
37         while (!flag) {
38             //现在的时间
39             long now=System.currentTimeMillis();
40             long reset=timeout-(now-start);
41             if(reset<=0){
42                 throw new TimeOutException("已经等候"+timeout+"时间了还没有数据可供下载，超时");
43             }
44             //如果没有超时，就让下载线程进入wait set,设置超时时间。被唤醒，继续从这里开始执行。
45             wait(reset);
46         }
47         //真正的下载操作
48         download();
49     }
50     
51     
52     //真正的下载操作
53     private void download(){
54         System.out.println("顺利下载数据==>："+data);
55         //下载完之后，将下载状态改为不可下载，等待放入新数据供下载
56         this.flag=false;
57     }
58     
59     public String getData() {
60         return data;
61     }
62     public void setData(String data) {
63         this.data = data;
64     }
65     public boolean isFlag() {
66         return flag;
67     }
68     public void setFlag(boolean flag) {
69         this.flag = flag;
70     }
71     
72     
73     
74     public long getTimeout() {
75         return timeout;
76     }
77     public void setTimeout(long timeout) {
78         this.timeout = timeout;
79     }
80 }

View Code

提供数据供下载的线程类

 1 package com.yeepay.sxf.thread4;
 2 /**
 3  *制造数据线程
 4  * @author sxf
 5  *
 6  */
 7 public class GiveDataThread implements Runnable {
 8     //公共数据
 9     private FileData fileData;
10     
11     //构造器
12     public GiveDataThread(FileData fileData) {
13         super();
14         this.fileData = fileData;
15     }
16 
17 
18 
19     @Override
20     public void run() {
21             //制造数据线程，造100个数据
22             for (int i = 0; i <10; i++) {
23                 fileData.changeStatus("制造数据"+i);
24                 System.out.println("【制造线程制造数据】==》制造数据"+i);
25                 try {
26                     Thread.sleep(1000);
27                 } catch (InterruptedException e) {
28                     // TODO Auto-generated catch block
29                     e.printStackTrace();
30                 }
31                 
32         }
33         
34     }
35 
36     
37 }

View Code

下载数据的线程类

 1 package com.yeepay.sxf.thread4;
 2 /**
 3  * 下载线程
 4  * @author sxf
 5  *
 6  */
 7 public class DownLoadThread implements Runnable {
 8     private FileData fileData;
 9     private boolean flag=true;
10     //构造器
11     public DownLoadThread(FileData fileData) {
12         super();
13         this.fileData = fileData;
14     }
15 
16     @Override
17     public void run() {
18         //开始下载线程
19         System.out.println("DownLoadThread.run(下载线程开始");
20         //根据标识
21         while(flag){
22             //进行下载
23             try {
24                 fileData.execu();
25             } catch (TimeOutException e) {
26                 e.printStackTrace();
27                 flag=false;
28             }catch (InterruptedException e) {
29                 // TODO: handle exception
30                 System.out.println("DownLoadThread.run(非超时异常)");
31             }
32         }
33         
34         System.out.println("DownLoadThread.run(下载线程因为超时，而执行完毕)");
35     }
36     
37     
38     
39     
40 
41 }

View Code

测试类

 1 package com.yeepay.sxf.thread4;
 2 /**
 3  * 测试超时模式
 4  * @author sxf
 5  *
 6  */
 7 public class Test2 {
 8     
 9     
10     public static void main(String[] args) {
11         //声明数据类
12         FileData data=new FileData("sxf",true,5000);
13         //声明生产数据的线程
14         Thread giveThread=new Thread(new GiveDataThread(data));
15         //声明下载数据的线程
16         Thread downThread=new Thread(new DownLoadThread(data));
17         
18         //启动线程
19         giveThread.start();
20         downThread.start();
21     }
22 }

View Code

打印结果

【制造线程制造数据】==》制造数据0
DownLoadThread.run(下载线程开始
FileData.execu(开始时间1)
顺利下载数据==>：制造数据0
FileData.execu(开始时间1)
【制造线程制造数据】==》制造数据1
顺利下载数据==>：制造数据1
FileData.execu(开始时间1)
【制造线程制造数据】==》制造数据2
顺利下载数据==>：制造数据2
FileData.execu(开始时间1)
【制造线程制造数据】==》制造数据3
顺利下载数据==>：制造数据3
FileData.execu(开始时间1)
【制造线程制造数据】==》制造数据4
顺利下载数据==>：制造数据4
FileData.execu(开始时间1)
【制造线程制造数据】==》制造数据5
顺利下载数据==>：制造数据5
FileData.execu(开始时间1)
【制造线程制造数据】==》制造数据6
顺利下载数据==>：制造数据6
FileData.execu(开始时间1)
【制造线程制造数据】==》制造数据7
顺利下载数据==>：制造数据7
FileData.execu(开始时间1)
【制造线程制造数据】==》制造数据8
顺利下载数据==>：制造数据8
FileData.execu(开始时间1)
【制造线程制造数据】==》制造数据9
顺利下载数据==>：制造数据9
FileData.execu(开始时间1)
DownLoadThread.run(下载线程因为超时，而执行完毕)
com.yeepay.sxf.thread4.TimeOutException: 已经等候5000时间了还没有数据可供下载，超时
   at com.yeepay.sxf.thread4.FileData.execu(FileData.java:42)
   at com.yeepay.sxf.thread4.DownLoadThread.run(DownLoadThread.java:24)
   at java.lang.Thread.run(Thread.java:662)

相关阅读:
【剑指offer】复杂链表的复制
 【剑指offer】数组中只出现一次的数
 【剑指offer】数组在排序数组中出现的次数
 【剑指offer】数组中重复的数字
 【剑指offer】两个链表的第一个公共结点
 【剑指offer】1+….+n,不能使用相关关键字
 【剑指offer】连续子数组的最大和
 JS全国城市三级联动
 ES6语法
 前端es6基础语法
原文地址：https://www.cnblogs.com/shangxiaofei/p/4657516.html