Question

java 的小问题

进程中只有后台线程运行时，进程就会结束。。这句什么具体意思。为什么会这样

Answer 1

Java线程空镇帆认识
在了解线程之前，先了解一下，什么是进程。简单地说，在多任务系统中，每个独立执行的程序就称为进程。在一个进程中又可以包含一个或多个线程，一个线程就是一个程序内部的一条执行线索。

线程又分为单线程和多线程。
在单线程中，程序代码是按照调用顺序依次往下执行，在这种情况下，当主函数调用了子函数，那么主函数就必须要等待子函数返回后才能继续往下执行，不能实现两段代码同时交替运行。如果想要一程序中的多段代码同时交替运行，那么就需要产生出多个线程，并指定产生的每个线程上所要运行的程序代码段，这就是多旅芦线程。
当我们的Java程序启动运行的时候，就自动产生了一个线程，主函数main就是在这个线程上运行的。当这个线程运行的时候不再产生出新的线程时，那么这个程序就是单线程的。

实现线程的方式有两种：
1. 继承java.lang.Thread，并重写它的run()方法，将线程的执行主体放入其中。
2. 实现java.lang.Runnable接口，实现它的run()方法，并将线程的执行主体放入其中。
这两种实现方式的区别并不大。继承Thread类的方式实现起来较为简单，但是继承它的类就不能再继承别的类了，因此也就不能继承别的类的有用的方法了。而使用是想Runnable接口的方式就不存在这个问题了，而且这种实现方式将线程主体和线程对象本身分离开来，逻辑上也较为清晰，所以推荐大家更多地采用这种方式。

如何启动线程
我们通过以上两种方式实现了一个线程之后，线程的实例并没有被创建，因此它们也并没有被运行。我们要启动一个线程，必须调用方法来启动它，这个方法就是Thread类的start()方法，而不是run()方法（既不是我们继承Thread类重写的run()方法，也不是实现Runnable接口的run()方法）。run()方法中包含的是线程的主体，也就是这个线程被启动后将要运行的代码，它跟线程的启动没有任何关系。上面两种实现线程的方式在启动时会有所不同。那下面我们就分别看看两种实现方式的具体方式。

用Thread类创建斗雹线程
Java的线程是通过java.lang.Thread类来控制的，一个Thread类的对象就代表一个线程，而且只能代表一个线程，通过Thread类和它定义的对象，我们可以获取当前线程对象、获取某一线程的名称，可以实现控制线程暂停一段时间等功能。为了深入了解Thread类，我们来看看这样的一个程序：
public class ThreadDemo{
public static void main(String args[]){
new TestThread().run();
while(true){
System.out.println("main thread is running");
}
}
}

class TestThread{
public void run(){
while(true){
System.out.println(Thread.currentThread().getName()+" is

running");
}
}
}
运行结果是在屏幕上不停的打印出main is running,这说明了主函数里的那段无限循环代码没有被执行。因为调用的子函数是一个无限循环，主函数就得到不执行。这段代码很清楚的说明了什么是单线程。
在我们的生活中为了提高效率，往往需要实现同步任务，即多个任务交替进行，那么多线程就能满足这样的情况。下面我们把上面的单线程代码稍微修改一下，让它来实现多线程任务，代码如下：
public class ThreadDemo{
public static void main(String args[]){
new TestThread().start();
while(true){
System.out.println("main thread is running");
}
}
}

class TestThread extends Thread{
public void run(){
while(true){
System.out.println(Thread.currentThread().getName()+" is

running");
}
}
}
在这段程序里TestThread类继承了Thead类，也就是说TestTread类具有了Thread类的全部特性，在程序中没有直接调用TestThread类对象的run方法，而是调用了该类对象从Thread类继承来的start方法。程序的运行结果是两个while循环处的代码同时交替运行，这就是我们常常谈到的多线程。由此可见，在单线程中，我们必须要等待前一个任务完成了才能进行下一个任务，而在多线程中，我们可以同时处理多个任务，不用在等待。
小结：
(1)要将一段代码在一个新的线程上运行，该段代码应该在一个类的run函数中，并且run函数所在的类是Thread类的子类。要实现多线程，必须要编写一个继承了Thread类的子类，子类要覆盖Thread类中的run函数，在子类的run函数中就是想要在新线程上运行的程序代码。
(2)启动一个新的线程，不是直接调用Thread子类对象的run方法，而是调用Thread子类对象的start方法，Thread类对象的start方法将产生一个新的线程，并在该线程上运行该Thread类对象的run方法。根据面向对象的多态性，在该线程上实际运行的是Thread子类对象中的run方法。
(3)由于线程的代码段是在run方法中，那么我们就可以通过控制run方法来控制程序的运行。

用Runnable接口创建多线程
在JDK文档中，还看到了一个Thread构造方法，从JDK文档中长款Runnable接口类的帮助，该接口中只有一个run方法，当使用Thread类中的方法创建对象时，需要为该方法传递一个实现了Runnable接口的类的对象，这样创建的线程将调用那个实现了Runnable接口的类对象中的run方法作为其运行代码，而不再调用Thread类中的run方法。我们将前面继承Thread类的程序稍微修改一下就可以了，代码如下：
public class ThreadDemo{
public static void main(String args[]){
TestThread tt=new TestThread();
Thread t=new Thread(tt);
t.start();
while(true){
System.out.println("main thread is running");
}
}
}

class TestThread implements Runnable{
public void run(){
while(true){
System.out.println(Thread.currentThread().getName()+" is

running");
}
}
}
这段代码的运行效果同继承Thread类的运行效果一样。既然直接继承Thread和实现Runnable接口都能实现多线程，那么这两种实现多线程的方式在应用上有什么区别呢？到底用哪一个好呢？下面就来看看。

两种实现多线程方式的对比分析
为了对Thread类和Runnable接口实现多线的方式进行比较分析，我们还是通过编写程序来看效果清楚些。我们来模拟一个售票系统，实现通过四个售票点发售某次列车的100张票，一个售票点用一个县城来表示。我们把前面的代码复制下来修改一下就可以了，具体代码如下：
public class ThreadDemo{
public static void main(String args[]){
TestThread tt=new TestThread();
tt.start();
tt.start();
tt.start();
tt.start();
}
}

class TestThread extends Thread{
private int tickets=100;
public void run(){
while(true){
if(tickets>0)
System.out.println(Thread.currentThread().getName()+" is

saling ticket"+tickets--);
}
}
}
在TheadDemo类的main方法中，我们创建了一个线程对象，并重复启动了四次，我们从运行结果上，我们发现其实只有一个线程在运行，这个结果告诉我们，一个线程对象只能启动一个线程，无论你调用多上遍start方法，结果都只有一个线程。因此，我们就要再次修改程序，在main方法中创建四个TestThread对象，修改后的程序代码如下：
public class ThreadDemo{
public static void main(String args[]){
TestThread tt1=new TestThread();
TestThread tt2=new TestThread();
TestThread tt3=new TestThread();
TestThread tt4=new TestThread();
tt1.start();
tt2.start();
tt3.start();
tt4.start();
}
}

class TestThread extends Thread{
private int tickets=100;
public void run(){
while(true){
if(tickets>0)
System.out.println(Thread.currentThread().getName()+" is

saling ticket"+tickets--);
}
}
}
我们再次运行程序，从结果中我们看到了每一个票号都被打印了四遍，即是四个线程都各自卖各自的100张票，而不是去卖共同的100张票。我们需要的是多个线程去处理同一资源，一个资源只能对应一个对象，而在上面的程序中，我们创建了四个TestThread对象，就等同于创建了四个资源，每个TestThread对象中都有100张票，每个线程在独立的处理各自的资源，因此相互之间没有关联。
到现在为止我们已经修改了两次，还是没有达到我们想要的结果，要想实现这个模拟程序，我们只能创建一个资源对象，但要创建多个线程去处理同一资源对象，并且每个线程上所运行的是相同的程序代码。回顾一下我们在前面使用接口编写多线的过程，现在我们把继承Thread类的模拟程序改写为实现Runnable接口的程序，修改的代码如下：
public class ThreadDemo{
public static void main(String args[]){
TestThread tt=new TestThread();
Thread t1=new Thread(tt);
Thread t2=new Thread(tt);
Thread t3=new Thread(tt);
Thread t4=new Thread(tt);
t1.start();
t2.start();
t3.start();
t4.start();
}
}

class TestThread implements Runnable{
private int tickets=100;
public void run(){
while(true){
if(tickets>0)
System.out.println(Thread.currentThread().getName()+" is

saling ticket"+tickets--);
}
}
}
在这个程序中，通过Thread类创建了四个线程，每个线程调用的都是同一个TestThread对象中的run方法，访问的是同一个对象中的变量实例，这个程序就刚好满足了我们的需求。可以，实现Runnable接口相对于继承Thread类来说，有下面的好处：
(1)适合多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU同程序的代码、数据有效分离，较好地体现了面向对象的设计思想。
(2)可以避免由于Java的单继承带来的局限。
(3)有利于程序的健壮性，代码能够被多个线程共享，代码与数据是对立的。事实上，几乎所有多线程应用都可用第二种方式，即实现Runnable接口。我们既然谈到了线程，那就应该更深的去了解一下。

后台线程和联合线程
(1)后台线程
在上面的模拟程序中，我们在main方法中创建并启动新的线程后，main方法便结束了，主线程也就随之结束了，在这样的情况下，虽然main线程结束了，但整个Java程序没有随之结束。对于Java程序来说，只要还有一个前台线程在运行，这个程序就不会结束。如果一个进程中只有后台线程运行，这个进行就会结束。前台线程是相对于后台线程而言的。如果对某个线程对象在启动之前调用了setDaemon(true)方法，这个线程就变成了后台线程。
下面我们就来看看，进程中只有后台线程运行时，进程就会结束的情况。我们修改一下上面的代码，详情如下：
public class ThreadDemo{
public static void main(String args[]){
TestThread tt=new TestThread();
Thread t=new Thread(tt);
t.setDaemon(true);
t.start();
}
}

class TestThread implements Runnable{
private int tickets=100;
public void run(){
while(true){
if(tickets>0)
System.out.println(Thread.currentThread().getName()+" is

saling ticket"+tickets--);
}
}
}
从上面程序的运行结果，我们可以看到，虽然创建了一个无限循环的线程，因为它是后台线程，整个进程在主线结束时就随之终止运行了。这久验证了进程中只有后台线程运行时，进程就会结束的说法。
(2)联合线程与join方法
先不谈联合线程，我们先看看下面这段程序，我们不用重新新程序，我们只需要将前面的程序拿过来修改就可以了，详细代码如下：
public class JoinThread{
public static void main(String args[]){
TestThread tt=new TestThread();
Thread t=new Thread(tt);
t.start();
int i=0；
while(true){
if(i==100){
try{
t.join();
}
catch(Exception e){
System.out.println(e.getMessage());
}
}
System.out.println("main thread is running"+i++);
}
}
}

class TestThread implements Runnable{
public void run(){
int i=0;
while(true){
System.out.println(Thread.currentThread().getName()+" is

running"+""+i++);
}
}
}
在这个程序中用到了Thread类的join方法，即t.join();语句，它的作用就是把t所对应的线程合并到调用t.join();语句的线程中。我们查看JDK文档发现，除了有无参数的join方法外，还有两个带参数的join方法，分别是join(long millis)和join(long millis,int nanos)

，它们的作用就是指定合并时间，前者精确到毫秒，后者精确到纳秒，意思就是两个线程合并指定的时间后，又开始分离，回到合并前的状态。
总之，多线程的用途非常广泛，比如网络聊天程序、复制表记录、www服务器等

Answer 2

进程中只有后台线程运行时，进程就会结束 好绕啊。

Answer 3

一旦你编写的程序的所有裤岁滑线程的状态由前台变成后台状雀扰态时，该进程已经没有了前台胡腊控制线程，如果进程不结束的话，你让他干什么？让他无休止的占用系统资源？

Answer 4

你好，我们从java类中去分析一下：
Thread类提供了IsBackground{get;set}的布尔属性。当前台线程还在运行时，它会阻止进程被终止。另一方面，一旦所指的进程中尘搏不再有前台线早兄锋程，后台线程就会被CLR自动终止（调用Abort()方法）。IsBackground的默陆晌认值为false，这意味着所有的线程默认情况处于前台状态。
结束他就是为了节省系统资源。