Java 多线程(创建，结束，生命周期，常见方法)

想要学习多线程，必须要先理解什么是并发什么是并行。

　　并行：是指两个或多个线程在同一时刻发生。

　　并发：是指两个或多个线程在同一时间段内发生。

为了方便理解多线程的概念，我们先举一个例子：

     假如我们把公司看做是一个进程，那么人就是其中的线程。进程必须得有一个主线程，公司在创业初期往往可能出现一人打天下的现象，但是，至少得有一个人，公司才能运作。公司创业初期，业务还不算太多，往往就是老板一个人身兼数职，一天如果只有1、2趟活儿，应该还是忙得过来的。时间长了，随着业务的发展、口碑的建立，生意越来越兴隆，一个人肯定就忙不过来了。假设一天有5个活儿，老板一个人必须搬完A家才能搬B家，搬到黄昏估计也就搬到C家，D和E家都还在焦急地等待着呢。老板一个人要充当搬运工、司机、业务联系人、法人代表、出纳等众多角色，累死累活公司的规模也上不去，人手不够制约了公司的发展。那么怎么办，很简单，增加人手，然后这些人各司其职，同时工作，很块就处理完了公司的业务。而这些人手就是所谓的线程，开启了的线程可以并行运行。

　　多线程的好处：多线程相当于在一个进程中有多条不同的执行路径，在同一时刻进行执行，可以提高程序的执行效率。

　　多线程的应用场景：迅累多线程下载，数据库连接池，分批发送敦信等。

　　同步：相当于单线程，代码从上往下按照顺序执行。

　　异步：相当于多线程，开启一条新的路径执行，多条执行路径同时执行，互不影响。

一，进程和线程的概念

       进程：是一个正在执行的程序。每一个进程都有一个执行顺序，该顺序是一个执行路径，或者叫做执行单元。进程是资源分配的基本单位（内存，进程ID（PID））。

        线程：是一条执行路径，是进程内部的一个独立的执行单元，每个线程互不影响，一个进程至少有一个线程，线程控制进程的执行。线程是资源调度的单位。

　　多线程：在一个进程中多个线程并发执行。

　　1.1进程和线程的区别

　　♦内存区别：进程是有独立的内存空间，每一个进程之间是相互独立的，互不干扰。

　　　　　　　线程除了有私有的内存空间外，还有共有的内存空间。

　　♦安全性：进程是相互独立的，一个进程的崩溃是不会影响到其他的进程，进程是安全的。

　　　　　　线程存在内存空间的共享，一个线程的崩溃可能会影响到其他线程，所以线程没有进程安全性高。

　　1.2进程和线程的关系

　　        进程是相互独立的，一个进程下可以有一个或者多个线程。

　　Java中很少使用进程的概念，但可以使用下面代码来创建进程：

　　Runtime  runtime=Runtime.getRuntime();//创建进程的方法

　　1.3Java默认有几个线程？

　　Java默认是有两个线程：主线程和垃圾回收的线程（Main和GC）

　　1.4java本身能否启动线程？

　　java本身是没有办法启动线程的，线程启动时需要调用底层操作系统的支持。Java通过调用本地方法，来调用c++编写的动态函数库，由c++去操作底层来启动线程。所以Java是通过间接的调用来启动线程的。

二，自定义线程的四种方式：1.继续Thread类，2.实现Runable接口，3.实现Callable接口的方法，4.线程池管理方法，另外还可以使用匿名对象。

   第一种：继承Thread类

        步骤： 1.定义类继承Thread类

　　　　　  2.重写Thread类中的run方法

                    为什么要重写run()方法？ 将新定义的线程所要执行的代码存储在run()方法中，因为Thread类是用来描述线程的，而用于存储该线程运行时的代码的功能，就是由run()方法实现的，所以一般将新建的线程所要执行的代码，都放到run()方法中。注意主线程运行时的代码是存储在main()方法中的。（一般新建立的线程调用的start()方法，是由父类继承下来的，而start()方法中调用的run()方法，是被Thread子类重写过的方法。

　　　　　  3.调用线程的start()方法（该方法的作用：启动线程，并调用run方法）

class Demo extends Thread//1.继承Thread类
{
    public void run() { //2.重写run方法
        for(int i=0;i<10;i++){
            System.out.println("run..."+i);
        }
    }
}
public class TreadDemo {
    public static void main(String[] args) {//main函数也是一个线程
        Demo d=new Demo();//创建一个线程
        d.start();//3.调用start方法
        for(int i=0;i<20;i++){
            System.out.println("main...."+i);
        }
    }
}

运行结果部分图：

 运行结果分析：

     主线程（要执行代码存储在main()函数中）开始执行，当运行到这一句Demo d=new Demo();   会新创建一个线程2，接着主线程调用新线程的start()方法，而start()方法内部又会区调用run()方法（这个新线程要执行的代码存储在run()方法中），此时新线程也开启了。而这一块打印结果为什么是main和run 的交替？因为当线程2开启后，只能说明线程2具备了运行条件，不一定立马就有cup的执行权，所以打印的结果先是main.....i  ,这时线程2突然抢到了cup执行权，于是也进行了打印输出run.....i ，接着cup执行权又被主线程强走，然后打印main.....i ,所以打印结果就是他们的交替。下图是对上述代码执行过程的分析，要注意的是一个进程在开始至少有一个线程，而对于上面这个代码，刚开始的这个主线程就是由main()函数开启的。而且只要进程中还有线程未执行完毕，该进程就不会结束。

          说到这一块可能就有人迷惑，那既然调用start()方法时，该方法会接着调用run()方法，那为什么不能直接调用run()方法来执行呢？要注意start()方法的作用不止调用run()方法，还用启动线程的作用。

先举一个直接调用run()方法的例子：

   public static void main(String[] args) {//main函数也是一个线程
        Demo d=new Demo();//创建一个线程
        d.run();//3.调用start方法
        for(int i=0;i<20;i++){
            System.out.println("main...."+i);
        }
    }

      run()方法中的代码与上个例子中的相同。

 执行结果：

     不论运行多少次，都会发现结果和上图都是一样的。这和线程的随机性明显不符，为什么呢？？（线程的随机性指的是多个线程的执行结果不唯一，谁抢到cup执行权谁执行）

      因为当你直接调用run()方法时，虽然通过该句Demo d=new Demo()已创建新线程，但是并没有启动新线程！！ 所以当主线程执行到这一句d.run()，因为新线程没有开启，所以run()方法中的内容是在主线程中执行了的，所以只有当run打印完，才会轮到main打印。 

     要注意，人们平时看到的多个线程在“同时”执行，其实在底层并不是多个线程同时一块执行的，而是通过快速的交替使用cup来执行自己的任务，因为其交替的速度非常快，快到人眼是感觉不到的，所以使我们在表面上看去，以为是多个线程在同时执行。这也就是为什么当我们电脑打开的程序也多时，电脑就会越卡。

补充：可通过Thread的getName()方法获得新线程的默认名字。 新线程的默认名字格式：Thread-0   编号从0开始。

//两种获得线程名字的方法
this.getName();
Thread.currentThread().getName();

Thread.currentThread()//可获得当前线程对象

　　那如何给新线程自定义名字呢？通过查资料，我们得知Thread有一个带参构造函数，所以我们可以直接在新建线程时，直接将名字赋给它。

      Demo d=new Demo("one");//创建一个线程

        要注意我们既然要使用它的带参构造函数，那么我们在子类中就必须定义一个带参构造函数。

class Demo extends Thread//1.继承Thread类
{
    Demo(String name){ //定义一个带参构造函数。
        super(name);
    }
    public void run() { //2.重写run方法
        for(int i=0;i<10;i++){
            System.out.println(this.getName()+"run..."+i);
        }
    }
}
public class TreadDemo {
    public static void main(String[] args) {//main函数也是一个线程
        Demo d=new Demo("one");//创建一个线程
        d.start();//3.调用start方法d.run()
        for(int i=0;i<20;i++){
            System.out.println("main...."+i);
        }
    }
}

   第二种：实现Runable接口（其实Thread也是实现Runnable接口的）

       步骤：1.创建类实现Runnable接口

               2.实现Runnable接口中的run()方法

                      目的：将线程执行的代码存储在run()方法中

　　　　   3.通过Thread类建立线程对象

　　　　　4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数

                    为什么要将Runnable接口的子类对象传递给Thread的构造函数？

　　　　　  因为自定义的run()方法所属的对象是Runnable接口的子类对象，所以要让线程去执行指定对象的run()方法，就必须明确该run(方法的所属对象。

　　　　　5.调用Thread类的start方法开启线程并调用Runnable接口子类的run()方法

    实现方式和继承方式的区别：

　　1，实现方式避免了单继承的局限性。（因为一个类只能继承一个类，当继承了Thread类就无法在继承其他类，但因为实现多个接口，所以就可以继承其他类和实现其他接口。）

　　2，实现方式更适合处理多线程共享数据的问题。（因为实现方式创建多个线程时，使用的资源都是一份共享的，而使用继承方式创建多个线程时，因为是通过new的方式，所以每个线程使用的资源不是同一份，因此必须使用static变量修饰，以达到资源共享的目的。）        

　　3，线程池只能放入实现Runnable或Callable接口的线程，不能直接放入继承Thread的类。

　　4，继承Thread：线程代码存放在Thread子类的run()方法中

              实现Runnable:线程代码存放在Runnable接口子类的run()方法

 1  class Demo implements Runnable{// 1.定义类实现Runnable接口 
 2      public void run() { //2.重写run方法 
 3          for(int i=0;i<100;i++){
 4              System.out.println(Thread.currentThread().getName()+"run..."+i);
 5     }
 6  }
 7  public class TreadDemo {
 8      public static void main(String[] args) {//main函数也是一个线程
 9          Demo d=new Demo();
10          Thread t1=new Thread(d);//3.通过Thread类建立线程对象     4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数
11          Thread t2=new Thread(d);
12          t1.start();//5.调用Thread类的start方法开启线程并调用Runnable接口子类的run()方法
13          t2.start();
14          for(int i=0;i<200;i++){
15              System.out.println("main...."+i);
16         }
17     }
18 }

 第三种：实现callable接口<泛型>

　　步骤：1.创建类(MyCallable)并实现Callable接口。

　　　　　2.实现call()方法。（同run方法，但不同的是要抛异常）

　　　　　3.创建FutureTask实例，并将MyCallable类的实例作为参数传递给FutureTask。

　　　　　4.创建Thread实例，并将FutureTask的实例作为参数传递给Thread。

　　　　　5.调用Thread实例的start方法来开启线程

　　　　　6.获取并打印(MyCallable)的执行结果。FutureTask实例.get().

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

class MyCallable implements Callable {//1.定义类(MyCallable)去实现Callable接口。
    @Override
    public Object call() throws Exception {//2.实现call()方法。
        for (int i = 0; i <100 ; i++) {
            System.out.println("子线程"+i);
        }
        return  "子线程执行完毕";
    }
}
public class MyCallableDemo {
    public static void main(String[] args) {
        FutureTask futureTask = new FutureTask(new MyCallable());//FutureTask类实现了Runnable接口
        //　3.创建FutureTask实例，并创建MyCallable类的实例作为参数传递给FutureTask实例。
        Thread thread=new Thread(futureTask);//4.创建Tread实例
        thread.start();//5.调用Tread实例的start方法来开启线程
        for (int i = 0; i <100 ; i++) {
            System.out.println("主线程"+i);
        }
        try {
            System.out.println(futureTask.get());//获取子线程的结果
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

　　为什么要创建FutureTask类的实例？？ 　　

　　因为Thread接收Runnable类型的，但不接收Callable类型的，所以就需要一个转换器，而FutureTask实现了Runnable接口，且构造方法支持Callable类型的。

　　FutureTask接口与Runnable接口的关系：

 Future接口中常用的方法：

1.判断任务是否完成：isDone()

2.能够中断任务：cance()

3.能够获取任务执行结果：get()

第四种：使用线程池　　

　　步骤：1.使用Executor获取线程池对象

　　　　2.通过线程池对象获取线程并执行MyRunnable()实例

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class MyRunnable implements Runnable{//创建MyRunnable()实例


    @Override
    public void run() {
        for (int i = 0; i <10; i++) {
            System.out.println("子线程。。。"+i);
        }
    }
}
public class TreadExtendDemo {
    public static void main(String[] args) {
        ExecutorService executorService=Executors.newFixedThreadPool(10);//1.使用Executor获取线程池对象
        executorService.execute(new MyRunnable());//2.通过线程池对象获取线程并执行MyRunnable()实例

        for (int i = 0; i <10 ; i++) {
            System.out.println("main"+i);
        }
    }
}

第五种：使用匿名对象。

public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread=new Thread(new Runnable() {//使用匿名方法创建线程
            @Override
            public void run() {
                for (int i = 0; i <100 ; i++) {
                    System.out.println("子线程。。。。"+i);
                }
            }
        });
        thread.start();//开启线程

        for (int i = 0; i <100 ; i++) {
            System.out.println("主线程"+i);
        }
    }
}

面试题：Runnable和Callable接口比较

相同点：

• 两者都是借口。
• 两者都可用来编写多线程程序。
• 两者都需要调用Tread.start()方法启动线程。

不同点：

• 实现Callable接口的线程能够返回执行结果，而实现Runnable接口的线程不能返回结果；
• Callable接口的call()方法允许抛出异常，而Runnable接口的run()方法的不允许抛异常；
• 实现Callable接口的线程可以调用Future.cancel()取消执行，也可以调用isDone()来判断线程是否执行完，也就是说可以实现对线程的监控，而实现Runnable接口的线程不能；

注意点：Callable接口支持返回执行结果，但需要调用FutureTask.get()方法实现，此方法会阻塞主线程直到获取‘将来’结果；当不调用此方法时，主线程不会阻塞。

三，结束线程的方法--（♦使用通知方式）

　   1.stop()已过时

　　2.使用Interrupt方法中断线程。

　　注意点：我一开始看到该方法的时候，认为interrupt会使线程停止运行，但事实上并非如此，调用一个线程的Interrupt方法会把线程的状态改为中断态。这其中又可以细分成两个方面：
　　      1）对于因执行了sleep、wait、join方法而休眠的线程：调用Interrupt方法会使他们不再休眠，同时会抛出 InterruptedException异常。比如一个线程A正在sleep中，这时候另外一个程序里去调用A的interrupt方法，这时就会迫使A停止休眠而抛出InterruptedException异常，从而提前使线程逃离阻塞状态。
　　      2）对于正在运行的线程，即没有阻塞的线程，调用Interrupt方法就只是把线程A的状态改为interruptted，也就是将中断标志改为true，但是不会影响线程A的继续执行。因为一个线程不应该由其他线程来强制中断或自行停止，会造成线程不安全，所以说interrupt()并不能将真正的中断线程，还需要被中断的线程进行配合才行，也就是说一个有中断需求的线程，在执行过程中会不断的检查自己的中断标志位，如果被设置了中断标志，就自行停止线程。

　　3.采用通知的方法（标志）。

　　    当线程完成执行并结束后，就无法再次运行了。应该通过使用标志来指示run方法退出的方式来停止线程，即通知方式。该方式可通过线程以安全的方式结束运行。

　　【代码演示】：在main方法中启动两个线程，第一个线程循环随机打印100以内的整数，直到第二个线程从键盘中读取了“over”命令。

import java.util.Random;
import java.util.Scanner;
class TraddDemo_1 implements Runnable{
//第一个线程随机打印100以内的整数
    boolean flag=true;
    @Override
    public void run() {
        while (flag){
            System.out.println(flag);
            try{
                Thread.sleep(3000);//为抢占cpu执行权
            }catch (Exception e){ }
            Random in=new Random();
            int number=in.nextInt(100)+1;//随机打印1-100之间的数字
            System.out.println("随机数字:"+number);
        }
    }
    public   void setFlag(boolean flag){
        this.flag=flag;
    }
}
class TreadDemo_2 implements Runnable{//因为两个线程做的事不同，所以要重写一个线程
    TraddDemo_1 t;
    public TreadDemo_2(TraddDemo_1 t){
        this.t=t;//变量t引用的是TreadDemo_1的地址
    }
    @Override
    public void run() {
        Scanner in=new Scanner(System.in);
        while (true){
            System.out.println("请输入终止符：");
            String str=in.nextLine();
            if(str.equals("over")){
                t.setFlag(false);
                break;
            }else {
                System.out.println("您输入的终止符不正确！");
            }
        }
    }
}
public class ThreadStopDemo {
    public static void main(String[] args) {
    TraddDemo_1 traddDemo1=new TraddDemo_1();
    TreadDemo_2 treadDemo2=new TreadDemo_2(traddDemo1);//将引用传递给TreadDemo_2 
    new Thread(traddDemo1).start();//创建线程，并启动
    new Thread(treadDemo2).start();
    }
}

 　　运行结果：

四，线程的常见方法

  

  

  

 

　　yield()方法：暂停当前正在执行的线程对象，会让当前线程由“运行状态”进入到“就绪状态”，并且让步于其他相同或优先级更高的线程执行，如果没有优先级高于当前线程的线程，则当前线程会继续执行。注意不能确定暂停的时间，且即使释放CPU执行权也不会释放锁。

　　

　　join()方法：若在当前线程中调用B线程的join方法，则当前线程会让B线程插队在自己面前执行，如果B线程抢到了cpu执行权，则B线程肯定会执行完，是一个串行的过程。注B线程有可能没有也没有抢到执行权。

　　join(long millis)方法：当前线程会让B线程插队在自己面前执行，但只等待millis秒。

　　join(long millis,int nanos)方法：同join(long millis)方法，因为在底层还是将nanos四舍五入为millis.

　　注意：调用join会释放锁，因为在join方法里调用了wait方法。

　　

　　interrupt()方法：中断操作。

　　1）对于因执行了sleep、wait、join方法而休眠的线程，调用Interrupt方法会使他们不再休眠，同时会抛出 InterruptedException异常。比如一个线程A正在sleep中，这时候在另外一个线程里去调用A的interrupt方法，这时就会迫使A停止休眠从而提前使线程逃离阻塞状态，并且会抛出InterruptedException异常，。
　　 2）对于正在运行的线程，即没有阻塞的线程，调用Interrupt方法就只是把线程A的状态改为interruptted，也就是将中断标志改为true，但是不会影响线程A的继续执行，直到调用了使线程进入阻塞状态的sleep，join，wait方法时才会起到作用，先抛出InterruptedException异常，然后使线程立即跳出阻塞状态。

　　isinterrupted()方法：判断当前线程是否发生了中断操作，true 已发生中断，false 未发生中断操作。

　　

　　sleep()方法：线程休眠。哪个线程调用就让哪个线程休眠。

　　sleep(long millis)

　　sleep(long millis,int nanos)    都是提供休眠操作。

　　sleep休眠期间，会让出CPU使用权，但线程仍然持有锁。

　　sleep休眠时间到了之后，不会立即执行，而是线程由“阻塞状态”进入“就绪状态”。

　　

　　setDaemon(boolean  n)方法：设置守护线程（true）或用户线程（false即默认的）。

　　用户线程（非守护线程）：线程的任务体正常执行完。

　　后台线程（守护线程）：服务于用户线程，所有用户线程执行结束，哪怕守护线程的任务体还没有执行完毕，也会伴随着结束，比如：垃圾回收机制。

　　守护线程的生命周期：

　　　　守护线程的生命周期是依赖于用户线程，当有用户线程存在，守护线程就会存在，当没有用户线程存在，那守护线程也会随之消亡。需要注意的是：Java虚拟机在“用户线程”都结束后是会退出。

　　

　　Priority优先级：线程的优先级

　　线程的优先级：就是来指导线程都执行优先级。

　　方法介绍：

　　int getPriority() 获取优先级

　　setPriority() 设置优先级

　　方法特点：

　　1.Java线程的优先级并不绝对，它所控制的是执行的机会，也就是说，优先级高的线程执行效率比较大，而优先级低的也并不是没有机会，只是执行的概率相对低一些。

　　2.Java一共有10个优先级，分别为1-10，数值越大，表明优先级越高，一个普通的线程，其优先级为5；线程的优先级具有继承性，如果一个线程B是在另一个线程A中创建的，则B叫做A的子线程，B的初始优先级与A保持一致。

　　3.优先级范围：Java中的优先级的范围是1-10。最小值为1，默认的是5，最大值为10。“优先级高的会优先于低的先执行”。

　　

【代码演示】：join方法。

class B extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <4 ; i++) {
            System.out.println("B正在使用电脑");
        }
    }
}
public class ThreadJoinDemo {
    public static void main(String[] args) {
        B b=new B();
        b.start();
        for (int i = 0; i <5; i++) {
            System.out.println("A正在使用电脑");
            if(i>=3){
                try {
                    b.join();//调用B的join方法后，如果B抢到了执行权则一定会运行完代码。
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

　　运行结果：

　【代码演示】：对正在运行的代码调用interrupt方法。

public class TestDemo {
    public static void main(String[] args) {
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                int n=0;
                while (true){
                    n++;
                    System.out.println("子线程"+n);
                    if(n==100){
                        System.out.println("休眠");
                        try {
                            Thread.sleep(100000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }

            }
        });
        thread.start();
        thread.interrupt();

    }
}

运行结果：

　　通过结果可知，当线程正在运行这时调用了interrupt方法代码确实没有什么变化，直到调用了sleep方法时，我们可以明显发现线程并没有进入睡眠状态，而是继续运行，并且报出来sleep interrupted异常。

　【代码演示】：setDaemon方法

class Waiter extends Thread{
    @Override
    public void run() {
        while(true) {//使用while语句，直到主线程运行结束，该线程才停止。
            System.out.println("服务员正在工作");
        }
    }
}
public class TreadSetDaemonDemo {
    public static void main(String[] args) {
        Waiter  waiter=new Waiter();
        waiter.setDaemon(true);
        waiter.start();
        for (int i = 0; i <200 ; i++) {
            System.out.println("餐厅还在营业！");
        }
    }
}

　　运行结果：

 　　只有当餐厅停止营业，服务员才停止工作。这里之所以后面还打印了3个“服务员正在工作”，是因为打印是单线程的，当餐厅停止营业时，虽然服务员也停止服务了，但是打印里面还缓存了一部分未打印完。   

1、 总结wait()和sleep()方法之间的区别和联系

从表面上看，wait()和sleep()都可以使得当前线程进入阻塞状态，但是两者之间存在本质性的差别，下面总结两者的区别和相似之处：

1) wait()和sleep()都可以使得线程进入阻塞状态

2) wait()和sleep()都是可中断方法，被中断之后都会收到中断异常

3) wait()是Object类中的方法，由于wait()调用必须在一个synchronized方法/块中，调用之前需要先获取对象的monitor，每个对象都有自己的monitor，让当前线程等待当前对象的monitor，当然需要当前对象来操作，所以wait()方法就必须要定义在Object类中, 而sleep()是Thread特有的方法

4) wait()方法执行必须在同步方法/同步块中，而sleep()不需要

5) 线程在同步方法中执行sleep()时，并不会释放掉monitor的锁，而wait()会释放掉

6) Sleep()短暂休眠之后会主动退出阻塞，而wait()（没有指定时间）则需要被其他线程中断后/其他线程唤醒并获取到当前对象的monitor后才能退出阻塞

2、 interrupted()和isInterrupted（）有什么区别？写一个简单的示例来验证

1) isIntereripted是Thread的一个成员方法，它主要判断当前线程是否被中断，该方法仅仅是对interrupt标识的一个判断，并不影响标识发生任何改变。

2) interrupted是一个静态方法，虽然其也用于判断当前线程是否被中断，但是调用该方法会直接擦除掉线程的interrupt标识，要注意的是，如果当前线程被打断了，那么第一次调用interrupted方法会返回true，并且立即擦除了interrupt标识；第二次包括以后的调用永远都会返回false。

 

3、 什么是守护线程？为什么会有守护线程？什么时候需要守护线程？

 

要回答这些问题，我们必须先搞清楚另外一个比较重要的问题：JVM程序在什么情况下会退出？

 

　　来自JDK官方文档：The java virtual machine exits when the only threads running are all daemon threads.这句话指的是正常退出的情况，而不是调用了System.exit()方法，通过这句话的描述，我们不难发现，在正常情况下， 若JVM总没有一个非守护线程，则JVM的进程会退出。

　　如果一个JVM进程中都是守护线程（即没有一个非守护线程存在），那么JVM这一进程在某一程序结束的时候也会退出，也就是说守护线程具备自动结束生命周期的特性，而非守护线程则不具备这一特点。假设JVM进程的垃圾回收线程是非守护线程，那么某一程序完成工作结束，则JVM无法退出，因为垃圾回收线程还在正常的工作。

 

　　守护线程经常用做执行一些后台任务，因此有时也被称之为后台线程，当你希望关闭某些线程的时候，或者退出JVM进程的时候，一些线程能够自动关闭，此时就可以考虑使用守护线程为你完成这样的工作。

 

 五.线程的生命周期 

　　当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，它要经过新建(New)、就绪（Runnable）、运行（Running）、阻塞(Blocked)和死亡(Dead)5种状态。尤其是当线程启动以后，它不可能一直"霸占"着CPU独自运行，所以CPU需要在多条线程之间切换，于是线程状态也会多次在运行、阻塞之间切换。

　　要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：

　　1.新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态。（jvm为线程分配内存，初始化成员变量）

　　2.就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备运行条件。（jvm为线程创建方法栈和程序计数器，等待线程调度器调度）

　　3.运行：当就绪的线程被调度并获得处理器资源时，便进入运行状态，run()方法定义了线程的操作和功能。

　　4.阻塞：在某种特殊情况下，被人挂起或执行输入输出操作时，让出cpu，并临时终止自己的执行，进入阻塞状态。

　　5.死亡：线程完成了它的全部工作或线程被提前强制性的终止。

        

        

   

1、新建和就绪状态

　　当程序使用new关键字创建了一个线程之后，该线程就处于新建状态，此时它和其他的Java对象一样，仅仅由Java虚拟机为其分配内存，并初始化其成员变量的值。此时的线程对象没有表现出任何线程的动态特征，程序也不会执行线程的线程执行体。当线程对象调用了start()方法之后，该线程处于就绪状态。Java虚拟机会为其创建方法调用栈和程序计数器，处于这个状态中的线程并没有开始运行，只是表示该线程可以运行了。至于该线程何时开始运行，取决于JVM里线程调度器的调度。

　　调用线程对象的start()方法之后，该线程立即进入就绪状态——就绪状态相当于"等待执行"，但该线程并未真正进入运行状态。如果希望调用子线程的start()方法后子线程立即开始执行，程序可以使用Thread.sleep(1) 来让当前运行的线程（主线程）睡眠1毫秒，1毫秒就够了，因为在这1毫秒内CPU不会空闲，它会去执行另一个处于就绪状态的线程，这样就可以让子线程立即开始执行。

2、运行和阻塞状态

　　2.1 线程运行状态

　　如果处于就绪状态的线程获得了CPU，开始执行run()方法的线程执行体，则该线程处于运行状态，如果计算机只有一个CPU。那么在任何时刻只有一个线程处于运行状态，当然在一个多处理器的机器上，将会有多个线程并行执行；当线程数大于处理器数时，依然会存在多个线程在同一个CPU上轮换的现象。

　　当一个线程开始运行后，它不可能一直处于运行状态（除非它的线程执行体足够短，瞬间就执行结束了）。线程在运行过程中需要被中断，目的是使其他线程获得执行的机会，线程调度的细节取决于底层平台所采用的策略。对于采用抢占式策略的系统而言，系统会给每个可执行的线程一个小时间段来处理任务；当该时间段用完后，系统就会剥夺该线程所占用的资源，让其他线程获得执行的机会。在选择下一个线程时，系统会考虑线程的优先级。所有现代的桌面和服务器操作系统都采用抢占式调度策略，但一些小型设备如手机则可能采用协作式调度策略，在这样的系统中，只有当一个线程调用了它的sleep()或yield()方法后才会放弃所占用的资源——也就是必须由该线程主动放弃所占用的资源。

　　2.2 线程阻塞状态

当发生如下情况时，线程将会进入阻塞状态

① 线程调用sleep()方法主动放弃所占用的处理器资源

② 线程调用了一个阻塞式IO方法，在该方法返回之前，该线程被阻塞

③ 线程试图获得一个同步监视器，但该同步监视器正被其他线程所持有。关于同步监视器的知识、后面将存更深入的介绍

④ 线程在等待某个通知（notify）

⑤ 程序调用了线程的suspend()方法将该线程挂起。但这个方法容易导致死锁，所以应该尽量避免使用该方法

当前正在执行的线程被阻塞之后，其他线程就可以获得执行的机会。被阻塞的线程会在合适的时候重新进入就绪状态，注意是就绪状态而不是运行状态。也就是说，被阻塞线程的阻塞解除后，必须重新等待线程调度器再次调度它。

　　2.3 解除阻塞

针对上面几种情况，当发生如下特定的情况时可以解除上面的阻塞，让该线程重新进入就绪状态：

① 调用sleep()方法的线程经过了指定时间。

② 线程调用的阻塞式IO方法已经返回。

③ 线程成功地获得了试图取得的同步监视器。

④ 线程正在等待某个通知时，其他线程发出了个通知。

⑤ 处于挂起状态的线程被调甩了resdme()恢复方法。

 3. 死亡状态

线程会以如下3种方式结束，结束后就处于死亡状态：

① run()或call()方法执行完成，线程正常结束。

② 线程抛出一个未捕获的Exception或Error。

③ 直接调用该线程stop()方法来结束该线程——该方法容易导致死锁，通常不推荐使用。