精华内容
下载资源
问答
  • 线程2--主线程(main线程)

    千次阅读 2019-06-07 17:23:55
    主线程(main线程) 主线程其实就是执行main方法的线程 /*Person类*/ package com.itheima.demo05MainThread; public class Person { private String name; public Person(String name) { this.name = name; ...

    主线程(main线程)

    • 主线程其实就是执行main方法的线程
    
    /*Person类*/
    
    package com.itheima.demo05MainThread;
    
    public class Person {
        private String name;
    
        public Person(String name) {
            this.name = name;
        }
    
        public void run(){
            for (int i = 0; i <20 ; i++) {
                System.out.println(name+i);
            }
        }
    }
    
    
    /*测试类*/
    
    public class Demo {
        public static void main(String[] args) {
            Person p1 = new Person("小王");
            p1.run();
    
            System.out.println(0/0);    
            //运行结果Exception in thread "main" java.lang.ArithmeticException: / by zero
            //因为有计算错误,程序执行到这不会再继续往下执行了
    
            Person p2 = new Person("大王");
            p2.run();
        }
    }
    
    

    这是一个单线程程序,程序从main方法开始执行

    JVM执行java程序,从main方法开始执行,main方法进入栈内存压栈
    JVM就会找操作系统(OS),开辟一条main方法通往CPU的路径,
    CPU就可以通过这个路径执行main方法
    这个路径就叫主线程(main线程)
    在这里插入图片描述

    要想程序继续执行,再开启一个线程,各自执行各自的任务.

    展开全文
  • main线程终止,其他线程还会运行吗?

    千次阅读 2020-03-06 13:59:10
    main线程终止,其他线程还会运行吗? 01 理论分析 当你启动一个Java Application的时候,这个时候系统创建一个进程,分配各项资源,然后这个进程启动了Main线程. 我们一般把Main线程说成主线程,因为其他线程一般是由...

    main线程终止,其他线程还会运行吗? 


    01 理论分析

    当你启动一个Java Application的时候,这个时候系统创建一个进程,分配各项资源,然后这个进程启动了Main线程.
    我们一般把Main线程说成主线程,因为其他线程一般是由main线程启动的.但其实,在进程层面看起来,main其实也是一个普通的线程.只不过一些其他的线程都是由main启动的.
    我们可以猜想一下:正常情况下,main线程启动了其他线程,他们各自执行,彼此不受影响.
    猜想依据:因为操作系统分配资源的单位是进程,就算main线程退出了,进程也还在.资源还在.在进程看来,线程应该都是平级的,没有父子关系.
    这个问题也可以换个说法,main线程是最后退出的线程吗?

    02 实践验证

    我们模拟一个线程池的例子,从main线程启动一个线程池,当发生异常,则让main线程抛出异常终止,看看线程池是否还继续运行.
    这里由于网上有些争论认为打印的方式无法判断main线程是否终止,所以我们的示例使用异常终止,并且使用jconsole工具进行验证.

    public class ThreadPoolException {     
           ExecutorService threadPool = Executors.newFixedThreadPool(5);     
           public static void main(String[] args) {         
                  ThreadPoolException t = new ThreadPoolException();         
                  t.futureGet();     
           }      
           void futureGet() {         
                  for (int i = 0; i < 5; i++) {             
                       Future future = threadPool.submit(() -> {                 
                              System.out.println("current thread name" + Thread.currentThread().getName());                 
                              Object object = null;                 
                              System.out.print("result## " + object.toString());             
                       });             
                       try {                 
                              future.get();             
                       } catch (Exception e) {                 
                               System.out.println(Thread.currentThread().getName() + "异常");                 
                               // 让主线程多等一段时间,便于观察. 
                               try {                     
                                    Thread.sleep(10000);                 
                               } catch (InterruptedException e1) {                     
                                    e1.printStackTrace();                 
                               }                 
                               //主线程终止 
                               throw new RuntimeException(Thread.currentThread().getName() + "异常");             
                    }         
            }     
         } 
    }		  
    欢迎大家关注我,需要更多Java面试资料和学习干货可以关注我的专栏【 Tom猫的Java屋

    Tom猫的java屋​zhuanlan.zhihu.com图标

    我们可以在jconsole中观察到:


    在main线程先出现然后会消失,线程池中的线程还在,只不过是wait状态. 在idea中直接运行代码,也可以观察到同样的结论.


    03 总结

    • JVM会在所有的非守护线程(用户线程)执行完毕后退出;
    • main线程是用户线程;
    • 仅有main线程一个用户线程执行完毕,不能决定JVM是否退出,也即是说main线程并不一定是最后一个退出的线程。

    如果你希望在main线程退出后,所有其他线程也退出.那么你可以把其他线程都设置为守护线程,也就是setDaemon(true). 对于线程池,你可以在main线程退出的的时候手动进行一些处理.比如shutdown等方法.

    展开全文
  • Java中的Main线程

    千次阅读 2017-07-05 11:22:46
    一个多线程程序可以包含两个或者更多的并发部分。每一部分都称为一个线程,而且每个线程都定义为一个独立的执行路径。...这就是通常所说的Main线程,因为当我的程序一启动,它就开始执行了。属性 大

    原文地址:http://www.geeksforgeeks.org/main-thread-java/

    Java对多线程编程提供了内置的支持。一个多线程程序可以包含两个或者更多的并发部分。每一部分都称为一个线程,而且每个线程都定义为一个独立的执行路径。

    Main Thread

    当一个Java程序启动以后,有一个线程就会立马跑起来。这就是通常所说的Main线程,因为当我的程序一启动,它就开始执行了。

    属性

    • 大量其他的子线程都是从它这里产生的
    • 通常它都是最后一个结束执行的线程,因为它要做各种关闭的动作

    流程图


    这里写图片描述

    如何控制main线程

    当我们的程序启动以后,Main线程就自动被创建出来了。想要控制它,我们就得获取一个它的引用。这个可以通过调用currentThread()来做到,这个方法是在Thread类中。这个方法返回一个当前正在被调用的线程的引用。main线程的默认优先级是5,其他剩下的用户线程优先级都是子类继承基类。

    // Java program to control the Main Thread
    public class Test extends Thread {
        public static void main(String[] args) {
            // getting reference to Main thread
            Thread t = Thread.currentThread();
    
            // getting name of Main thread
            System.out.println("Current thread: " + t.getName());
    
            // changing the name of Main thread
            t.setName("Geeks");
            System.out.println("After name change: " + t.getName());
    
            // getting priority of Main thread
            System.out.println("Main thread priority: " + t.getPriority());
    
            // setting priority of Main thread to MAX(10)
            t.setPriority(MAX_PRIORITY);
    
            System.out.println("Main thread new priority: " + t.getPriority());
    
            for (int i = 0; i < 5; i++) {
                System.out.println("Main thread");
            }
    
            // Main thread creating a child thread
            ChildThread ct = new ChildThread();
    
            // getting priority of child thread
            // which will be inherited from Main thread
            // as it is created by Main thread
            System.out.println("Child thread priority: " + ct.getPriority());
    
            // setting priority of Main thread to MIN(1)
            ct.setPriority(MIN_PRIORITY);
    
            System.out.println("Child thread new priority: " + ct.getPriority());
    
            // starting child thread
            ct.start();
        }
    }
    
    // Child Thread class
    class ChildThread extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println("Child thread");
            }
        }
    }

    输出:

    Current thread: main
    After name change: Geeks
    Main thread priority: 5
    Main thread new priority: 10
    Main thread
    Main thread
    Main thread
    Main thread
    Main thread
    Child thread priority: 10
    Child thread new priority: 1
    Child thread
    Child thread
    Child thread
    Child thread
    Child thread

    main方法和Main线程之间的关系

    对于每一个程序,Main线程都是由Java虚拟机创建的。Main线程首先要验证main()方法的存在,然后初始化这个类。注意从JDK 6开始main()被强制是一个独立的应用程序。

    main线程的死锁(只有单个线程)

    我们可以仅仅利用Main线程来创建一个死锁,例如,只用一个线程,下面的Java代码做了演示:

    // Java program to demonstrate deadlock
    // using Main thread
    public class Test {
        public static void main(String[] args) {
            try {
    
                System.out.println("Entering into Deadlock");
    
                Thread.currentThread().join();
    
                // the following statement will never execute
                System.out.println("This statement will never execute");
    
            }
    
            catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    输出:

    Entering into Deadlock

    解释

    Thread.currentThread().join()的声明就告诉Main线程要等待这个线程(例如等待自己)。因此Main线程在等待他自己挂掉,也就是死锁么。

    展开全文
  • Java Main线程与子线程之间的关系

    千次阅读 2019-12-01 22:48:58
    参考:... 1、Main线程结束之后,子线程非守护线程会继续运行 。 public class DaemonThread { private static class UseThread extends Thread{ @Override public void r...

    参考:https://www.cnblogs.com/qiumingcheng/p/8202393.html

    1、Main线程结束之后,子线程非守护线程会继续运行 。

    public class DaemonThread {
       private static class UseThread extends Thread{
          @Override
          public void run() {
             while (true) {
                System.out.println(Thread.currentThread().getName()
                      + " I am extends Thread.");
             }
    
          }
       }
    
       public static void main(String[] args) {
          UseThread useThread = new UseThread();
          //useThread.setDaemon(true);
          useThread.start();
    
       }
    }

    2、Main线程不能设置为守护线程,子线程可以设置成守护线程。

    public static void main(String[] args) {
    
    		Thread.currentThread().setDaemon(true);
    
    		UseThread useThread = new UseThread();
    		//useThread.setDaemon(true);
    		useThread.start();
    
    	}
    
    
    Exception in thread "main" java.lang.IllegalThreadStateException
    	at java.lang.Thread.setDaemon(Thread.java:1359)

    3、虚拟机中没有非守护线程执行时,进程结束,即使有守护线程。

    public static void main(String[] args) {
    
    	//	Thread.currentThread().setDaemon(true);
    
    		UseThread useThread = new UseThread();
    		useThread.setDaemon(true);
    		useThread.start();
    
    	}
    
    
    console : 
    Process finished with exit code 0

     

    展开全文
  • 9、通过实现Runnable接口的方式创建一个新线程,要求main线程打印100此次“main”,新线程打印50次“new”。 public class MyRunnable implements Runnable { public void run() { for (int i = 0; i ; i++) { ...
  • Java中main线程只是一个用来启动应用程序的普通非守护线程,main线程终止时其中的子线程也不会终止不防来做个实验:上述一个main主线程里面产生了两个子线程,内容为打印当前线程的名字,当输出 main is over 说明...
  • 线程跟main线程的关系

    2018-01-12 17:40:51
    代码跟运行结果如下,本人只想知道main中的isAlive在t线程启动前为什么是死的, 在t线程启动后为什么是活的。两者有什么必然的联系呢。 ``` public class CountOperate extends Thread { public ...
  • Java守护线程和main线程整理

    千次阅读 2017-10-09 09:40:45
    Java中有两类线程:User Thread(用户线程)、Daemon Thread(守护线程) 用个比较通俗的比如,任何一个守护线程都是整个JVM中所有非守护线程的保姆:只要当前JVM实例中尚存在任何一个非守护线程没有结束,守护线程就...
  • 通过实现 Runnable 接口的方式创建一个新线程,要求 main 线程打印100次“main”,新线程打印50次“new”。 public class MyRunnable implements Runnable { public void run() { for (int i=0; i&lt;50; i+...
  • Java中的main线程是不是最后一个退出的线程 个人blog原文地址:http://www.gemoji.me/when_main_thread_end/  之所以写这篇文章,是因为上次被人问到这么一个问题:“在main函数里启动一个定时器,是不是...
  • main线程会比其他线程优先结束

    千次阅读 2017-08-02 13:14:29
    最近在学习volatile时,看到一篇文章关于使用volatile进行同步同步控制利用线程实现计数器,代码如下: public class Main{ private static int count = 0; public static void plus() { try { Thread.sleep...
  • 我使用2.92版本,关键字:000721ec wxbase292u_vc.dll ,在XP上经常崩溃,源于非main线程更新GUI, 因为我们程序使用了很多的线程,并在线程中使用事件回调更新UI,十次有5次都崩溃,全改成wx.CallAfter后正常。 ...
  • public static void main(String[] args){ MyThread me=new MyThread(); Thread thread=new Thread(me); thread.start(); for(int i=0;i&lt;50;i++){ System.out.println("main");...
  • 以下转自百度知道: 这是代码: ...public static void main(String[] args) { Thread t=Thread.currentThread(); System.out.println("A: isInterrupted="+t.isInterrupted()); t.interrupt();
  • 当main方法中只有守护线程时,...因为main线程执行完了后进程中就没有非守护线程了,从而进程也就终止了实例代码如下:运行结果为:由此可见:进程的终止决定于是否存在用户线程,守护线程 的终止决定于进程是否终止...
  • Java线程的6种状态及切换(透彻讲解)

    万次阅读 多人点赞 2016-12-24 16:57:03
    Java中线程的状态分为6种。 ...线程对象创建后,其他线程(比如main线程)调用了该对象的start()方法。该状态的线程位于可运行线程池中,等待被线程调度选中,获取CPU的使用权,此时处于就绪状...
  • main 方法中,休眠一段时间再去...是不是因为main中首先顺序执行,只有在新建线程并且启动之后才会存在新线程和main线程并行执行?最后除了后台线程外,main线程终止,是不是得等待其他线程终止,程序才会退出?
  • 线程main方法

    千次阅读 2018-08-02 14:02:55
    一个java程序必须有main方法吗? 一个java程序必须有main方法。 一个程序,无论复杂或简单,总体上都是一个“函数”;这个函数就称为“main() 函数”,也就是“主函数”。比如有个“做菜”程序,那么“ 做菜 ”这个...
  • JAVA多线程——守护线程

    千次阅读 2020-09-01 17:39:18
    线程分为用户线程(如main线程)和守护线程 虚拟机必须确保用户线程执行完成 虚拟机不用等待守护线程执行完毕 守护线程的作用:后台记录操作,日志,监控内存,垃圾回收,等待机制等 package ...
  • Main函数中线程执行顺序

    千次阅读 2017-03-20 11:30:01
    public class Main { public static void main(String[] args) { Thread t = new Thread() { public void run() { print(); } }; t.start(); System.out.print("MT"); } static void
  • 线程(一):创建线程线程的常用方法

    万次阅读 多人点赞 2018-09-01 19:14:23
    一:为什么要学多线程 应付面试 :多线程几乎是面试中必问的题,所以掌握一定的基础知识是必须的。 了解并发编程:实际工作中很少写多线程的代码,这部分代码一般都被人封装起来了,在业务中使用多线程的机会也...
  • 线程的5种状态详解

    万次阅读 多人点赞 2018-08-23 11:02:42
    2.可运行(RUNNABLE):线程对象创建后,其他线程(比如main线程)调用了该对象的start()方法。该状态的线程位于可运行线程池中,等待被线程调度选中,获取cpu 的使用权 。 3.运行(RUNNING):可运行状态(runnable)的...
  • java线程组和线程

    千次阅读 2017-08-11 09:56:47
    java程序的线程组和线程的结构:main线程下创建thread8:Thread thread8 = new Thread(new ThreadGroup("hello"),"t8"); //获取顶层的system 线程组 while(tg.getParent()!=null){ //System.out.println(tg); tg =...
  • Java 线程线程状态流程图

    千次阅读 2018-02-24 17:19:49
    可运行(runnable):线程对象创建后,其他线程(比如main线程)调用了该对象的start()方法。该状态的线程位于可运行线程池中,等待被线程调度选中,获取cpu 的使用权 。 运行(running):可运行状态(runnable)的线程...
  • 每个线程默认的优先级都与创建它的父线程的优先级相同,在默认情况下,main线程具有普通优先级,由main线程创建的子线程也具有普通优先级。 Thread类提供了setPriority(int newPriority)、getPriority()方法来设置和...
  • Java前台线程与后台线程

    千次阅读 2018-04-15 23:26:57
    上一篇博客在main()方法中,创建并启动了四个新的线程后,main()方法中的代码执行完毕,此时,方法会结束,main线程也就随之结束了 通过程序的运行结果可以看出,虽然,main线程结束了,但是整个Java程序却没有随之...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 994,295
精华内容 397,718
关键字:

main线程