• 【翻译六】java-连接和实例


    Joins

    The join method allows one thread to wait for the completion of another. If t is a Thread object whose thread is currently executing,

    t.join();
    

    causes the current thread to pause execution until t's thread terminates. Overloads of join allow the programmer to specify a waiting period. However, as with sleepjoin is dependent on the OS for timing, so you should not assume thatjoin will wait exactly as long as you specify.

    Like sleepjoin responds to an interrupt by exiting with an InterruptedException.

    译文:

    连接

    连接方法允许一个线程等待另外一个线程执行完毕。如果t是正在执行的一个thread对象。

    t.join();

    引起当前线程停止执行知道t这个线程终止。重载join方法允许程序员指定一段等待时间。然而,同sleep方法一样,join方法也是依赖于系统时间的,因此不要认为join等待的时间会和你指定的一模一样。同sleep方法一样,join返回一个中断如果捕获到一个interruptedException异常。

    The SimpleThreads Example

    The following example brings together some of the concepts of this section. SimpleThreads consists of two threads. The first is the main thread that every Java application has. The main thread creates a new thread from the Runnable object,MessageLoop, and waits for it to finish. If the MessageLoop thread takes too long to finish, the main thread interrupts it.

    The MessageLoop thread prints out a series of messages. If interrupted before it has printed all its messages, theMessageLoop thread prints a message and exits.

    public class SimpleThreads {
    
        // Display a message, preceded by
        // the name of the current thread
        static void threadMessage(String message) {
            String threadName =
                Thread.currentThread().getName();
            System.out.format("%s: %s%n",
                              threadName,
                              message);
        }
    
        private static class MessageLoop
            implements Runnable {
            public void run() {
                String importantInfo[] = {
                    "Mares eat oats",
                    "Does eat oats",
                    "Little lambs eat ivy",
                    "A kid will eat ivy too"
                };
                try {
                    for (int i = 0;
                         i < importantInfo.length;
                         i++) {
                        // Pause for 4 seconds
                        Thread.sleep(4000);
                        // Print a message
                        threadMessage(importantInfo[i]);
                    }
                } catch (InterruptedException e) {
                    threadMessage("I wasn't done!");
                }
            }
        }
    
        public static void main(String args[])
            throws InterruptedException {
    
            // Delay, in milliseconds before
            // we interrupt MessageLoop
            // thread (default one hour).
            long patience = 1000 * 60 * 60;
    
            // If command line argument
            // present, gives patience
            // in seconds.
            if (args.length > 0) {
                try {
                    patience = Long.parseLong(args[0]) * 1000;
                } catch (NumberFormatException e) {
                    System.err.println("Argument must be an integer.");
                    System.exit(1);
                }
            }
    
            threadMessage("Starting MessageLoop thread");
            long startTime = System.currentTimeMillis();
            Thread t = new Thread(new MessageLoop());
            t.start();
    
            threadMessage("Waiting for MessageLoop thread to finish");
            // loop until MessageLoop
            // thread exits
            while (t.isAlive()) {
                threadMessage("Still waiting...");
                // Wait maximum of 1 second
                // for MessageLoop thread
                // to finish.
                t.join(1000);
                if (((System.currentTimeMillis() - startTime) > patience)
                      && t.isAlive()) {
                    threadMessage("Tired of waiting!");
                    t.interrupt();
                    // Shouldn't be long now
                    // -- wait indefinitely
                    t.join();
                }
            }
            threadMessage("Finally!");
        }
    }
    
    译文:
    简单的线程实例
    下面的这个实例包括了这一节介绍的内容。SimpleThreads包含了两个线程。第一个是每个java程序都有的主线程。主线程中创建了一个新的messageloop线程,主线程需要一直等到它执行完。如果MessageLoop线程占用了太长的时间,那么主线程就会抛出interruptedException中断它。
    MessageLoop线程打印一串信息,如果中断发生在这个线程执行打印操作完毕前,那么就会打印中断信息,并且退出这个线程。
     1 public class SimpleThreads {
     2 
     3     // Display a message, preceded by
     4     // the name of the current thread
     5     static void threadMessage(String message) {
     6         String threadName =
     7             Thread.currentThread().getName();
     8         System.out.format("%s: %s%n",
     9                           threadName,
    10                           message);
    11     }
    12 
    13     private static class MessageLoop
    14         implements Runnable {
    15         public void run() {
    16             String importantInfo[] = {
    17                 "Mares eat oats",
    18                 "Does eat oats",
    19                 "Little lambs eat ivy",
    20                 "A kid will eat ivy too"
    21             };
    22             try {
    23                 for (int i = 0;
    24                      i < importantInfo.length;
    25                      i++) {
    26                     // Pause for 4 seconds
    27                     Thread.sleep(4000);
    28                     // Print a message
    29                     threadMessage(importantInfo[i]);
    30                 }
    31             } catch (InterruptedException e) {
    32                 threadMessage("I wasn't done!");
    33             }
    34         }
    35     }
    36 
    37     public static void main(String args[])
    38         throws InterruptedException {
    39 
    40         // Delay, in milliseconds before
    41         // we interrupt MessageLoop
    42         // thread (default one hour).
    43         long patience = 1000 * 60 * 60;
    44 
    45         // If command line argument
    46         // present, gives patience
    47         // in seconds.
    48         if (args.length > 0) {
    49             try {
    50                 patience = Long.parseLong(args[0]) * 1000;
    51             } catch (NumberFormatException e) {
    52                 System.err.println("Argument must be an integer.");
    53                 System.exit(1);
    54             }
    55         }
    56 
    57         threadMessage("Starting MessageLoop thread");
    58         long startTime = System.currentTimeMillis();
    59         Thread t = new Thread(new MessageLoop());
    60         t.start();
    61 
    62         threadMessage("Waiting for MessageLoop thread to finish");
    63         // loop until MessageLoop
    64         // thread exits
    65         while (t.isAlive()) {
    66             threadMessage("Still waiting...");
    67             // Wait maximum of 1 second
    68             // for MessageLoop thread
    69             // to finish.
    70             t.join(1000);
    71             if (((System.currentTimeMillis() - startTime) > patience)
    72                   && t.isAlive()) {
    73                 threadMessage("Tired of waiting!");
    74                 t.interrupt();
    75                 // Shouldn't be long now
    76                 // -- wait indefinitely
    77                 t.join();
    78             }
    79         }
    80         threadMessage("Finally!");
    81     }
    82 }

    养眼是必须滴^^.


     
    简历: 三年国内著名软件公司Java信息系统开发经验。熟悉税务相关业务知识。一年以上互联网公司工作经验。 目标职位: Java研发工程师、大数据、推荐算法等。 目标城市: 北京,杭州,沈阳。 联系方式: 邮箱:hecuking@126.com
  • 相关阅读:
    zabbix监控windows案例
    Ansible自动化运维工具-上
    Nagios监控的部署与配置
    ELK+Redis+Nginx服务数据存储以及Nginx日志的收集
    ELK5.3日志分析平台&部署
    Centos7X部署Zabbix监控
    LVS+Keepalived负载均衡
    Nginx+tomcat负载均衡
    smokeping
    Err.number错误号和可捕获的 Microsoft access 数据库引擎和 DAO错误说明
  • 原文地址:https://www.cnblogs.com/accipiter/p/3179663.html
Copyright © 2020-2023  润新知