• Java多线程编程- Wait等待超时控制

    前言：

    本文是基于《Java多线程编程实战指南》第五章个人理解，因为第五章内容很多，因此拆成了很多文章，源码是摘抄作者的源码，源码会加上自己的理解。

    读书笔记目前笔者正在更新如下， 《Java多线程编程实战指南-核心篇》，《How Tomcat Works》，再到《spring 源码》解读。

    Wait超时时间：

    Object.wait(long)允许我们制定一个超时时间（单位为毫秒），如果被暂停的等待线程在这个时间内没有被其他线程唤醒，那么Java虚拟机会自动唤醒该线程。

    不过Object.wait(long)既无返回值也不会抛出特定的异常，以便区分其返回是由于其他线程通知了当前线程还是由于等待超时。因此，使用Object.wait(long)的时候我们需要一些额外的处理。

    实例：

    1.  
    2.  
    3. import java.util.Random;
    4.  
    5. public class TimeoutWaitExample {
    6.   private static final Object lock = new Object();
    7.   private static boolean ready = false;
    8.   protected static final Random random = new Random();
    9.  
    10.   public static void main(String[] args) throws InterruptedException {
    11.     Thread t = new Thread() {
    12.       @Override
    13.       public void run() {
    14.         for (;;) {
    15.           synchronized (lock) {
    16.             ready = random.nextInt(100) < 5 ? true : false;
    17.             if (ready) {
    18.               lock.notify();
    19.             }
    20.           }
    21.           // 使当前线程暂停一段（随机）时间
    22.           Tools.randomPause(500);
    23.         }// for循环结束
    24.       }
    25.     };
    26.     t.setDaemon(true);
    27.     t.start();
    28.     waiter(1000);
    29.   }
    30.  
    31.   public static void waiter(final long timeOut) throws InterruptedException {
    32.     if (timeOut < 0) {
    33.       throw new IllegalArgumentException();
    34.     }
    35.  
    36.     long start = System.currentTimeMillis();
    37.     long waitTime;
    38.     long now;
    39.     synchronized (lock) {
    40.       while (!ready) {
    41.         now = System.currentTimeMillis();
    42.         // 计算剩余等待时间
    43.         waitTime = timeOut - (now - start);
    44.         Debug.info("Remaining time to wait:%sms", waitTime);
    45.         if (waitTime <= 0) {
    46.           // 等待超时退出
    47.           break;
    48.         }
    49.         lock.wait(waitTime);
    50.       }// while循环结束
    51.  
    52.       if (ready) {
    53.         // 执行目标动作
    54.         guardedAction();
    55.       } else {
    56.         // 等待超时，保护条件未成立
    57.         Debug.error("Wait timed out,unable to execution target action!");
    58.       }
    59.     }// 同步块结束
    60.   }
    61.  
    62.   private static void guardedAction() {
    63.     Debug.info("Take some action.");
    64.     // ...
    65.   }
    66. }

    基本流程讲解： 

    1.初始化时候，构建一个静态对象Object

    2.创建了一个通知线程Thread t，是一个守护线程，并且for里面循环取值，random.nextInt，再100内取大于5的概率较大，所以是大概率位false，小概率位true

    3.所以主线程是在ready=falise的while循环里，并且停止在lock.wait，主线程进入waiting状态，等待时间需要扣除一部分代码到wait语句时间。

    4.最终当时间到达等待时间时间，再此判断ready条件，如果为true，则运行相应动作，如果不为true，则无法执行对应的动作。所以上述代码运行有两种结果，都有可能发生。

    其他代码：

    1. import java.io.PrintStream;
    2. import java.text.SimpleDateFormat;
    3. import java.util.Date;
    4.  
    5. public class Debug {
    6.     private static ThreadLocal sdfWrapper = new ThreadLocal() {
    7.         @Override
    8.         protected SimpleDateFormat initialValue() {
    9.             return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    10.         }
    11.  
    12.     };
    13.  
    14.     enum Label {
    15.         INFO("INFO"),
    16.         ERR("ERROR");
    17.         String name;
    18.  
    19.         Label(String name) {
    20.             this.name = name;
    21.         }
    22.  
    23.         public String getName() {
    24.             return name;
    25.         }
    26.     }
    27.  
    28.     // public static void info(String message) {
    29.     // printf(Label.INFO, "%s", message);
    30.     // }
    31.  
    32.     public static void info(String format, Object... args) {
    33.         printf(Label.INFO, format, args);
    34.     }
    35.  
    36.     public static void info(boolean message) {
    37.         info("%s", message);
    38.     }
    39.  
    40.     public static void info(int message) {
    41.         info("%d", message);
    42.     }
    43.  
    44.     public static void error(String message, Object... args) {
    45.         printf(Label.ERR, message, args);
    46.     }
    47.  
    48.     public static void printf(Label label, String format, Object... args) {
    49.         SimpleDateFormat sdf = sdfWrapper.get();
    50.         @SuppressWarnings("resource")
    51.         final PrintStream ps = label == Label.INFO ? System.out : System.err;
    52.         ps.printf('[' + sdf.format(new Date()) + "][" + label.getName()
    53.                 + "]["
    54.                 + Thread.currentThread().getName() + "]:" + format + " %n", args);
    55.     }
    56. }
    1. import sun.misc.Unsafe;
    2.  
    3. import java.io.*;
    4. import java.lang.reflect.Field;
    5. import java.math.BigInteger;
    6. import java.security.DigestInputStream;
    7. import java.security.MessageDigest;
    8. import java.security.NoSuchAlgorithmException;
    9. import java.util.Random;
    10. import java.util.logging.Level;
    11. import java.util.logging.Logger;
    12.  
    13. public final class Tools {
    14.     private static final Random rnd = new Random();
    15.     private static final Logger LOGGER = Logger.getAnonymousLogger();
    16.  
    17.     public static void startAndWaitTerminated(Thread... threads)
    18.             throws InterruptedException {
    19.         if (null == threads) {
    20.             throw new IllegalArgumentException("threads is null!");
    21.         }
    22.         for (Thread t : threads) {
    23.             t.start();
    24.         }
    25.         for (Thread t : threads) {
    26.             t.join();
    27.         }
    28.     }
    29.  
    30.     public static void startThread(Thread... threads) {
    31.         if (null == threads) {
    32.             throw new IllegalArgumentException("threads is null!");
    33.         }
    34.         for (Thread t : threads) {
    35.             t.start();
    36.         }
    37.     }
    38.  
    39.     public static void startAndWaitTerminated(Iterable threads)
    40.             throws InterruptedException {
    41.         if (null == threads) {
    42.             throw new IllegalArgumentException("threads is null!");
    43.         }
    44.         for (Thread t : threads) {
    45.             t.start();
    46.         }
    47.         for (Thread t : threads) {
    48.             t.join();
    49.         }
    50.     }
    51.  
    52.     public static void randomPause(int maxPauseTime) {
    53.         int sleepTime = rnd.nextInt(maxPauseTime);
    54.         try {
    55.             Thread.sleep(sleepTime);
    56.         } catch (InterruptedException e) {
    57.             Thread.currentThread().interrupt();
    58.         }
    59.     }
    60.  
    61.     public static void randomPause(int maxPauseTime, int minPauseTime) {
    62.         int sleepTime = maxPauseTime == minPauseTime ? minPauseTime : rnd
    63.                 .nextInt(maxPauseTime - minPauseTime) + minPauseTime;
    64.         try {
    65.             Thread.sleep(sleepTime);
    66.         } catch (InterruptedException e) {
    67.             Thread.currentThread().interrupt();
    68.         }
    69.     }
    70.  
    71.     public static Unsafe getUnsafe() {
    72.         try {
    73.             Field f = Unsafe.class.getDeclaredField("theUnsafe");
    74.             ((Field) f).setAccessible(true);
    75.             return (Unsafe) f.get(null);
    76.         } catch (Exception e) {
    77.             e.printStackTrace();
    78.         }
    79.         return null;
    80.     }
    81.  
    82.     public static void silentClose(Closeable... closeable) {
    83.         if (null == closeable) {
    84.             return;
    85.         }
    86.         for (Closeable c : closeable) {
    87.             if (null == c) {
    88.                 continue;
    89.             }
    90.             try {
    91.                 c.close();
    92.             } catch (Exception ignored) {
    93.             }
    94.         }
    95.     }
    96.  
    97.     public static void split(String str, String[] result, char delimeter) {
    98.         int partsCount = result.length;
    99.         int posOfDelimeter;
    100.         int fromIndex = 0;
    101.         String recordField;
    102.         int i = 0;
    103.         while (i < partsCount) {
    104.             posOfDelimeter = str.indexOf(delimeter, fromIndex);
    105.             if (-1 == posOfDelimeter) {
    106.                 recordField = str.substring(fromIndex);
    107.                 result[i] = recordField;
    108.                 break;
    109.             }
    110.             recordField = str.substring(fromIndex, posOfDelimeter);
    111.             result[i] = recordField;
    112.             i++;
    113.             fromIndex = posOfDelimeter + 1;
    114.         }
    115.     }
    116.  
    117.     public static void log(String message) {
    118.         LOGGER.log(Level.INFO, message);
    119.     }
    120.  
    121.     public static String md5sum(final InputStream in) throws NoSuchAlgorithmException, IOException {
    122.         MessageDigest md = MessageDigest.getInstance("MD5");
    123.         byte[] buf = new byte[1024];
    124.         try (DigestInputStream dis = new DigestInputStream(in, md)) {
    125.             while (-1 != dis.read(buf))
    126.                 ;
    127.         }
    128.         byte[] digest = md.digest();
    129.         BigInteger bigInt = new BigInteger(1, digest);
    130.         String checkSum = bigInt.toString(16);
    131.  
    132.         while (checkSum.length() < 32) {
    133.             checkSum = "0" + checkSum;
    134.         }
    135.         return checkSum;
    136.     }
    137.  
    138.     public static String md5sum(final File file) throws NoSuchAlgorithmException, IOException {
    139.         return md5sum(new BufferedInputStream(new FileInputStream(file)));
    140.     }
    141.  
    142.     public static String md5sum(String str) throws NoSuchAlgorithmException, IOException {
    143.         ByteArrayInputStream in = new ByteArrayInputStream(str.getBytes("UTF-8"));
    144.         return md5sum(in);
    145.     }
    146.  
    147.     public static void delayedAction(String prompt, Runnable action, int delay/* seconds */) {
    148.         Debug.info("%s in %d seconds.", prompt, delay);
    149.         try {
    150.             Thread.sleep(delay * 1000);
    151.         } catch (InterruptedException ignored) {
    152.         }
    153.         action.run();
    154.     }
    155.  
    156.     public static Object newInstanceOf(String className) throws InstantiationException,
    157.             IllegalAccessException, ClassNotFoundException {
    158.         return Class.forName(className).newInstance();
    159.     }
    160.  
    161. }

    参考文献：

    《Java多线程编程实战指南-核心篇》

  • 相关阅读:
    【力扣刷题】Day01——数组基础
    Metabase学习教程：系统管理-6
    【洛谷】P5020 货币系统
    HotReload For Unity的文档的导航的翻译，添加了一些自己的理解。很垃圾
    ubuntu 下C++程序利用Valgrind工具调试内存问题
    【每日一读】CoRGi: Content-Rich Graph Neural Networks with Attention
    大模型应用实战1——GLM4的原理与应用（用大模型做游戏npc制作）
    【Rust日报】2022-08-31 RustDesk 跻身 Rust 开源项目 Top 10 第九名
    Swift Combine 使用调试器调试管道 从入门到精通二十六
    app运行踩过的坑大赏
  • 原文地址：https://blog.csdn.net/u012895183/article/details/133174786