zoukankan      html  css  js  c++  java

  • Java线程：线程的调度-守护线程——Java线程：线程的调度-合并——Java线程：新特征-障碍器——Java线程：大总结

    Java线程：线程的调度-守护线程
     
    守护线程与普通线程写法上基本么啥区别，调用线程对象的方法setDaemon(true)，则可以将其设置为守护线程。
     
    守护线程使用的情况较少，但并非无用，举例来说，JVM的垃圾回收、内存管理等线程都是守护线程。还有就是在做数据库应用时候，使用的数据库连接池，连接池本身也包含着很多后台线程，监控连接个数、超时时间、状态等等。
     
    setDaemon方法的详细说明：
    public final void setDaemon(boolean on)将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。    
      该方法必须在启动线程前调用。    

      该方法首先调用该线程的 checkAccess 方法，且不带任何参数。这可能抛出 SecurityException（在当前线程中）。    


      参数： 
        on - 如果为 true，则将该线程标记为守护线程。    
      抛出：    
        IllegalThreadStateException - 如果该线程处于活动状态。    
        SecurityException - 如果当前线程无法修改该线程。 
      另请参见： 
        isDaemon(), checkAccess()

     
    /** 
    * Java线程：线程的调度-守护线程 
    * 
    * @author leizhimin 2009-11-4 9:02:40 
    */     
    public class Test { 
            public static void main(String[] args) { 
                    Thread t1 = new MyCommon(); 
                    Thread t2 = new Thread(new MyDaemon()); 
                    t2.setDaemon(true);        //设置为守护线程 

                    t2.start(); 
                    t1.start(); 
            } 
    } 

    class MyCommon extends Thread { 
            public void run() { 
                    for (int i = 0; i < 5; i++) { 
                            System.out.println("线程1第" + i + "次执行！"); 
                            try { 
                                    Thread.sleep(7); 
                            } catch (InterruptedException e) { 
                                    e.printStackTrace(); 
                            } 
                    } 
            } 
    } 

    class MyDaemon implements Runnable { 
            public void run() { 
                    for (long i = 0; i < 9999999L; i++) { 
                            System.out.println("后台线程第" + i + "次执行！"); 
                            try { 
                                    Thread.sleep(7); 
                            } catch (InterruptedException e) { 
                                    e.printStackTrace(); 
                            } 
                    } 
            } 
    }
     
    后台线程第0次执行！ 
    线程1第0次执行！ 
    线程1第1次执行！ 
    后台线程第1次执行！ 
    后台线程第2次执行！ 
    线程1第2次执行！ 
    线程1第3次执行！ 
    后台线程第3次执行！ 
    线程1第4次执行！ 
    后台线程第4次执行！ 
    后台线程第5次执行！ 
    后台线程第6次执行！ 
    后台线程第7次执行！ 

    Process finished with exit code 0
     
    从上面的执行结果可以看出：
    前台线程是保证执行完毕的，后台线程还没有执行完毕就退出了。
     
    实际上：JRE判断程序是否执行结束的标准是所有的前台执线程行完毕了，而不管后台线程的状态，因此，在使用后台县城时候一定要注意这个问题。

    本文出自 “熔 岩” 博客，请务必保留此出处http://lavasoft.blog.51cto.com/62575/221845


    Java线程：线程的调度-合并
     
    线程的合并的含义就是将几个并行线程的线程合并为一个单线程执行，应用场景是当一个线程必须等待另一个线程执行完毕才能执行时可以使用join方法。
     
    join为非静态方法，定义如下：
    void join()    
        等待该线程终止。    
    void join(long millis)    
        等待该线程终止的时间最长为 millis 毫秒。    
    void join(long millis, int nanos)    
        等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。
     
    /** 
    * Java线程：线程的调度-合并 
    * 
    * @author leizhimin 2009-11-4 9:02:40 
    */     
    public class Test { 
            public static void main(String[] args) { 
                    Thread t1 = new MyThread1(); 
                    t1.start(); 

                    for (int i = 0; i < 20; i++) { 
                            System.out.println("主线程第" + i + "次执行！"); 
                            if (i > 2) try { 
                                    //t1线程合并到主线程中，主线程停止执行过程，转而执行t1线程，直到t1执行完毕后继续。 
                                    t1.join(); 
                            } catch (InterruptedException e) { 
                                    e.printStackTrace(); 
                            } 
                    } 
            } 
    } 

    class MyThread1 extends Thread { 
            public void run() { 
                    for (int i = 0; i < 10; i++) { 
                            System.out.println("线程1第" + i + "次执行！"); 
                    } 
            } 
    }
     
    主线程第0次执行！ 
    主线程第1次执行！ 
    主线程第2次执行！ 
    线程1第0次执行！ 
    主线程第3次执行！ 
    线程1第1次执行！ 
    线程1第2次执行！ 
    线程1第3次执行！ 
    线程1第4次执行！ 
    线程1第5次执行！ 
    线程1第6次执行！ 
    线程1第7次执行！ 
    线程1第8次执行！ 
    线程1第9次执行！ 
    主线程第4次执行！ 
    主线程第5次执行！ 
    主线程第6次执行！ 
    主线程第7次执行！ 
    主线程第8次执行！ 
    主线程第9次执行！ 
    主线程第10次执行！ 
    主线程第11次执行！ 
    主线程第12次执行！ 
    主线程第13次执行！ 
    主线程第14次执行！ 
    主线程第15次执行！ 
    主线程第16次执行！ 
    主线程第17次执行！ 
    主线程第18次执行！ 
    主线程第19次执行！ 

    Process finished with exit code 0

    本文出自 “熔 岩” 博客，请务必保留此出处http://lavasoft.blog.51cto.com/62575/221817


    Java5中，添加了障碍器类，为了适应一种新的设计需求，比如一个大型的任务，常常需要分配好多子任务去执行，只有当所有子任务都执行完成时候，才能执行主任务，这时候，就可以选择障碍器了。
     
    障碍器是多线程并发控制的一种手段，用法很简单。下面给个例子：
     
    import java.util.concurrent.BrokenBarrierException; 
    import java.util.concurrent.CyclicBarrier; 

    /** 
    * Java线程：新特征-障碍器 
    * 
    * @author leizhimin 2009-11-6 10:50:10 
    */     
    public class Test { 
            public static void main(String[] args) { 
                    //创建障碍器，并设置MainTask为所有定数量的线程都达到障碍点时候所要执行的任务(Runnable) 
                    CyclicBarrier cb = new CyclicBarrier(7, new MainTask()); 
                    new SubTask("A", cb).start(); 
                    new SubTask("B", cb).start(); 
                    new SubTask("C", cb).start(); 
                    new SubTask("D", cb).start(); 
                    new SubTask("E", cb).start(); 
                    new SubTask("F", cb).start(); 
                    new SubTask("G", cb).start(); 
            } 
    } 

    /** 
    * 主任务 
    */     
    class MainTask implements Runnable { 
            public void run() { 
                    System.out.println(">>>>主任务执行了！<<<<"); 
            } 
    } 

    /** 
    * 子任务 
    */     
    class SubTask extends Thread { 
            private String name; 
            private CyclicBarrier cb; 

            SubTask(String name, CyclicBarrier cb) { 
                    this.name = name; 
                    this.cb = cb; 
            } 

            public void run() { 
                    System.out.println("[子任务" + name + "]开始执行了！"); 
                    for (int i = 0; i < 999999; i++) ;    //模拟耗时的任务 
                    System.out.println("[子任务" + name + "]开始执行完成了，并通知障碍器已经完成！"); 
                    try { 
                            //通知障碍器已经完成 
                            cb.await(); 
                    } catch (InterruptedException e) { 
                            e.printStackTrace(); 
                    } catch (BrokenBarrierException e) { 
                            e.printStackTrace(); 
                    } 
            } 
    }
     
    运行结果：
    [子任务E]开始执行了！ 
    [子任务E]开始执行完成了，并通知障碍器已经完成！ 
    [子任务F]开始执行了！ 
    [子任务G]开始执行了！ 
    [子任务F]开始执行完成了，并通知障碍器已经完成！ 
    [子任务G]开始执行完成了，并通知障碍器已经完成！ 
    [子任务C]开始执行了！ 
    [子任务B]开始执行了！ 
    [子任务C]开始执行完成了，并通知障碍器已经完成！ 
    [子任务D]开始执行了！ 
    [子任务A]开始执行了！ 
    [子任务D]开始执行完成了，并通知障碍器已经完成！ 
    [子任务B]开始执行完成了，并通知障碍器已经完成！ 
    [子任务A]开始执行完成了，并通知障碍器已经完成！ 
    >>>>主任务执行了！<<<< 

    Process finished with exit code 0
     
    从执行结果可以看出，所有子任务完成的时候，主任务执行了，达到了控制的目标。

    本文出自 “熔 岩” 博客，请务必保留此出处http://lavasoft.blog.51cto.com/62575/222738


    Java线程是Java语言中一个非常重要的部分，Java5之前，多线程的语言支持还是比较弱的，内容也较少，写一个复杂的多线程程序是相当有挑战性的。
     
    在Java5以后，Java对多线程做了很多扩展，扩展部分称之为并发包。这部分内容大大增强了Java多线程编程的能力，通过使用Java5线程新特征的API，可以很容易的做出复杂的多线程程序。与其他语言相比，已经是相当强悍了。
     
    通过十多篇博文，将Java多线程的方方面面过了一遍，对我来说是一个学习和提高的过程，也为Java线程系列博文能给后来的学习者带来便利。
     
    知识点都过了一遍，要总结起来感觉很困难，毕竟Java线程是一个庞大的话题，不知道从何说起，如果泛泛而谈，那总结还有什么意义呢，再次，将前面的博文串联起来，按照先后顺序加上链接，以方便浏览也最好的首尾。
     
    下面是Java线程系列博文的一个编目：
     
    Java线程：新特征-锁（上） Java线程：大总结
     
     
     
    另外，在网上看到两篇不错的博文，可以参考参考：

    本文出自 “熔 岩” 博客，请务必保留此出处http://lavasoft.blog.51cto.com/62575/222742
  • 相关阅读:
    R语言中gsub使用示例记录
    linux 系统中wget实现并行下载
    R语言中实现将多行数据合并为一行
    python安装包国内镜像加速
    VMware Workstation 与 Device/Credential Guard不兼容
    缩放矩阵， 这里面有关于矩阵的 种种操作 这个要学下 很有用
    ffd 点的控制效果、
    摘抄 ： max mel 的一些用法。
    帮朋友写的查找选择的父子骨骼。之前我都是用递归，这个好、
    距离的算法。 下面两个是对等的。
  • 原文地址：https://www.cnblogs.com/daichangya/p/12959309.html
Copyright © 2011-2022 走看看