第九章课后题

1. 线程和进程的联系和区别是什么？

 联系：线程是隶属于操作系统的概念，是程序执行中的单个顺序流程。与线程密切相关的另一个概念是进程，进程就是一个执行中的程序，是操作系统对其资源（内存和CPU时间等）进行分配的基本单位，每一个进程都有自己独立的一块内存空间、一组系统资源，其内部数据和状态都是完全独立的。

 区别：同类的多个线程共享一块内存空间和一组系统资源，二线程本身的数据通常只有微处理器的寄存器数据，以及一个供程序执行时使用的堆栈。所以系统在产生一个线程，或者在各个线程之间切换时，负担要比进程小的多，正因如此，线程被称为轻负荷进程。

2.什么是前台线程，什么是后台线程？

应用程序必须运行完所有的前台线程才可以退出；而对于后台线程，应用程序则可以不考虑其是否已经运行完毕而直接退出，所有的后台线程在应用程序退出时都会自动结束,后台线程不会阻止进程终止,一旦属于某一进程的所有前台线程都终止，公共语言运行库就会通过对任何仍然处于活动状态的后台线程调用 Abort 来结束该进程。
Thread.IsBackground 设置为 true，就可以将线程指定为后台线程。同样，通过将 IsBackground 设置为 false，就可以将线程指定为前台线程。线程的前后台属性在线程运行前制定。
通过创建并启动新的 Thread 对象而生成的所有线程都是前台线程。如果要创建希望用来侦听某些活动（如套接字连接）的前台线程，则应将 Thread.IsBackground 设置为 true，以便进程可以终止。

3.创建线程有几种方法？它们之间的区别是什么？

方式一：直接继承线程Thread类。该方法编写简单，可以直接操作线程，由于已经继承了Thread，不能再继承其他类了;

    public MyThread extends Thread{
             …… 
             public void run() {  线程体逻辑 }   
        }

方式二：实现Runnable接口。当一个类已继承了另一个类时，就只能用实现Runnable接口的方式来创建线程；另外，使用此方法的更多原因是多个线程共享某个对象的资源。

        public MyThread implements Runnable {
             …… 
             public void run() {  线程体逻辑 }    
        }

4.线程的生命周期有哪些状态？哪些方法可以改变这些状态？

五种状态：创建状态、就绪状态、运行状态、阻塞状态、死亡状态；
方法：
new Thread()(创建一个线程实例)
.start()(启动一个线程,但不一定运行,需要虚拟机调度)
.run()(只是thread的一个普通方法调用，还是在主线程里执行)
.sleep()(让线程进入睡眠,不释放锁)
.join()(当前线程中调用了其他线程)
.wait()(是线程进入等待池)
.notify()(随机唤醒一个等待线程)
.notifyAll()(唤醒所有等待线程)；

5.什么是线程安全？为什么会产生线程安全问题？如何解决线程安全问题？

如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他变量的值也和预期的是一样的，就是线程安全的，也就是说，多个线程同时运行同一段代码时不会造成资源冲突，产生错误结果。 线程安全的代码在多个线程中使用时不需要作同步处理；而线程不安全的代码在多个线程中使用时必须作同步处理，否则可能产生不可预期的后果。
解决办法：用监视器来保证共享数据操作的同步性，任何对象都可以作为一个监视器，关键字synchronized修饰某个对象后，该对象就成为监视器。
Synchronized的三种用法：
synchronized 代码块：监视器就是指定的对象。
synchronized 方法：监视器就是this对象。
synchronized 静态方法：监视器就是相应的Class对象。

class Resource implements Runnable {
  volatile public int i;        
  volatile public Integer it;
  public  Resource(int _i){
    i = _i;
    it = new Integer(i);
  }
  public  void run(){
   while(true){
    synchronized(it){
     if (i>0){
        try{
           Thread.sleep(200);
        }
        catch(Exception e){}
        i--;
        System.out.println(Thread.
        currentThread().getName()+"  "+i);
    }
    else{
        System.out.println(Thread.
        currentThread().getName());
        break; }}
}}}
public class TestSecurity{
public static void main(String[] args){
  Resource m = new Resource(9);
  Thread t1 = new Thread(m);
  Thread t2 = new Thread(m);
  t1.start();
  t2.start();
}
}

6.什么是线程的同步通信？同步通信又是如何实现的？

概念：一个线程一旦进入监控器，其它的线程必须等待，直到那个线程退出监控为止。通过这种方式，一个监控器可以保证共享资源在同一时刻只可被一个线程使用。这种方式称之为同步。
实现：使用wait和notifyAll实现线程间同步通信 （两个存钱线程，一个取钱线程）：

class Account{
    volatile private int value;
    //布尔标志              
    volatile private boolean isMoney = false;    
    //put设为同步方法
    synchronized void put(int i) {
      while(isMoney){
        try{ wait();} //线程等待
        catch(){Exception e}{} 
      }
      value = value + i; 
      System.out.println("存入"+i+" 账上金额为："+value);
      isMoney = true;//设置标志
      notifyAll(); //唤醒等待资源的所有线程
   }
synchronized int get(int i) {//同步方法 
    while(!isMoney) ){
        try { wait();}
        catch(){Exception e}{}
     }
     if (value>i)
          value = value - i;         
     else {  
          i = value;
          value = 0;                    
     }
     System.out.println("取走"+i+" 账上金额为："+value);
     isMoney = false;
     notifyAll(); 
     return i;                      
    } }
public class TestCommunicate{
 public static void main(String[] args){
    Account a1 = new Account();
    new Thread(new Save(a1)).start(); new Thread(new Save(a1)).start();      
    new Thread(new Fetch(a1)).start();
 }}

7.什么是死锁？

如果多个线程都处于等待状态，彼此需要对方所占用的监视器所有权，就构成死锁（deadlock），Java即不能发现死锁也不能避免死锁。 

注意:
1）可能发生死锁的代码执行中不一定会死锁，因为线程之间的执行存
在很大的随机性。
2）线程方法suspend()、resume()、stop()由于存在引起死锁的可能，
因而逐渐不用（Deprecated）。