java 的小问题

2024-12-05 00:52:40

推荐回答（4个）

回答（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服务器等

回答（2）：

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

回答（3）：

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

回答（4）：

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