201777010217-金云馨《面向对象程序设计（java）》第十六周学习总结

项目	内容
这个作业属于哪个课程	https://www.cnblogs.com/nwnu-daizh/
这个作业的要求在哪里	https://www.cnblogs.com/nwnu-daizh/p/12031970.html
作业的学习目标	(1) 掌握Java应用程序的打包操作； (2) 掌握线程概念； (3) 掌握线程创建的两种技术。 (4) 学习设计应用程序的GUI。

第一部分：知识总结

1、程序与进程的概念

l 程序是一段静态的代码，它是应用程序执行的蓝本。

l 进程是程序的一次动态执行，它对应了从代码加载、执行至执行完毕的一个完整过程。

l 操作系统为每个进程分配一段独立的内存空间和系统资源，包括：代码数据以及堆栈等资源。每 一个进程的内部数据和状态都是完全独立的。

l 多任务操作系统中，进程切换对CPU资源消耗较大。

2、多线程的概念

l 多线程是进程执行过程中产生的多条执行线索。

l 线程是比进程执行更小的单位。

l 线程不能独立存在，必须存在于进程中，同一进程的各线程间共享进程空间的数据。

l 每个线程有它自身的产生、存在和消亡的过程， 是一个动态的概念。

l 多线程意味着一个程序的多行语句可以看上去几 乎在同一时间内同时运行。

l 线程创建、销毁和切换的负荷远小于进程，又称为轻量级进程（lightweight process）。

3、Java实现多线程有两种途径：

l 创建Thread类的子类

l 在程序中定义实现Runnable接口的类

4、用Thread类子类创建线程

首先需从Thread类派生出一个子类，在该子类中重写run()方法。

class hand extends Thread

{

    public void run()

    {……}

}

5、用Thread类的子类创建多线程的关键性操作

–定义Thread类的子类并实现用户线程操作，即 run()方法的实现。

–在适当的时候启动线程。

由于Java只支持单重继承，用这种方法定义的类不可再继承其他父类。

6、用Runnable()接口实现线程

l 首先设计一个实现Runnable接口的类；

l 然后在类中根据需要重写run方法；

l 再创建该类对象，以此对象为参数建立Thread 类的对象；

l 调用Thread类对象的start方法启动线程，将 CPU执行权转交到run方法。

7、线程的终止

l 当线程的run方法执行方法体中最后一条语句后，或者出现了在run方法中没有捕获的异常时，线程将终止，让出CPU使用权。

l 调用interrupt()方法也可终止线程。

l void interrupt()

l 向一个线程发送一个中断请求，同时把这个线程的“interrupted”状态置为true。

l 若该线程处于 blocked 状态 ，会抛出 InterruptedException。

8、测试线程是否被中断的方法

Java提供了几个用于测试线程是否被中断的方法。

1) static boolean interrupted()

检测当前线程是否已被中断 ，并重置状态 “interrupted”值为false。 

2) boolean isInterrupted()

检测当前线程是否已被中断 ，不改变状态 “interrupted”值 。

9、线程的状态

l 利用各线程的状态变换，可以控制各个线程轮流使用CPU，体现多线程的并行性特征。 

l 线程有如下7种状态：

1)  New (新建)

2)  Runnable (可运行)

3)  Running(运行)

4)  Blocked (被阻塞)

5)  Waiting (等待)

6)  Timed waiting (计时等待)

7)  Terminated (被终止)

10、新创建线程

new（新建）

线程对象刚刚创建，还没有启动，此时线程还处于不可运行状态。例如: Thread thread=new Thread(r); 此时线程thread处于新建状态，有了相应的内存空间以及其它资源。

11、可运行线程

-runnable（可运行状态)

l  此时线程已经启动，处于线程的run()方法之中。

l  此时的线程可能运行，也可能不运行，只要 CPU一空闲，马上就会运行。

l  调用线程的start()方法可使线程处于“可运行”状态。例如： thread.start();

12、被阻塞线程和等待线程

-blocked (被阻塞)

l 一个正在执行的线程因特殊原因，被暂停执行， 进入阻塞状态。

l 阻塞时线程不能进入队列排队，必须等到引起阻塞的原因消除，才可重新进入排队队列。

l 引起阻塞的原因很多，不同原因要用不同的方法解除。

13、线程阻塞的三种情况

l 等待阻塞 -- 通过调用线程的wait()方法，让线程等待某工作的完成。

l 同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态。

l 其他阻塞 -- 通过调用线程的sleep()或join() 或发出了I/O请求时，线程会进入到阻塞状态。当 sleep()状态超时、join()等待线程终止或者超 时、或者I/O处理完毕时，线程重新转入就绪状态。

14、被终止的线程

Terminated (被终止) 线程被终止的原因有二：

l  一是run()方法中最后一个语句执行完毕而自然死亡。

l  二是因为一个没有捕获的异常终止了run方法而意外死亡。

l  可以调用线程的 stop 方 法 杀 死 一 个 线 程（thread.stop();)，但是，stop方法已过时， 不要在自己的代码中调用它。

15、多线程调度

-Java 的线程调度采用优先级策略:

l 优先级高的先执行，优先级低的后执行；

l 多线程系统会自动为每个线程分配一个优先级，缺省时，继承其父类的优先级；

l 任务紧急的线程，其优先级较高；

l 同优先级的线程按“先进先出”的队列原则；

 第二部分：实验部分

实验1： 导入第13章示例程序，测试程序并进行代码注释。

测试程序1

在elipse IDE中调试运行教材585页程序13-1，结合程序运行结果理解程序；

将所生成的JAR文件移到另外一个不同的目录中，再运行该归档文件，以便确认程序是从JAR文件中，而不是从当前目录中读取的资源。

掌握创建JAR文件的方法；

package resource;

import java.awt.*;
import java.io.*;
import java.net.*;
import java.util.*;
import javax.swing.*;

/**
 * @version 1.41 2015-06-12
 * @author Cay Horstmann
 */
public class ResourceTest
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         JFrame frame = new ResourceTestFrame();
         frame.setTitle("ResourceTest");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
      });
   }
}

/**
 * A frame that loads image and text resources.
 */
class ResourceTestFrame extends JFrame
{
   /**
     * 
     */
    private static final long serialVersionUID = 1L;
private static final int DEFAULT_WIDTH = 300;
   private static final int DEFAULT_HEIGHT = 300;

   public ResourceTestFrame()
   {
      setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
      URL aboutURL = getClass().getResource("about.gif");  //在getclass方法的getResourse下查找about.gif文件
      System.out.println(aboutURL);
      Image img = new ImageIcon(aboutURL).getImage();//利用about.gif图像文件制作图标
      setIconImage(img);

      JTextArea textArea = new JTextArea();//创建一个textArea对象
      InputStream stream = getClass().getResourceAsStream("about.txt");//读取about.txt文件
      try (Scanner in = new Scanner(stream, "UTF-8"))
      {
         while (in.hasNext())
             textArea.append(in.nextLine() + "
");
      }
      add(textArea);
   }
}

运行结果：

导出文件：

测试程序2：

在elipse IDE中调试运行ThreadTest，结合程序运行结果理解程序；

掌握线程概念；

掌握用Thread的扩展类实现线程的方法；

利用Runnable接口改造程序，掌握用Runnable接口创建线程的方法。

程序代码：

class Lefthand extends Thread { 
   public void run()
   {
       for(int i=0;i<=5;i++)
       {  System.out.println("You are Students!");
           try{   sleep(500);   }    //用了sleep()方法，休眠500毫秒
           catch(InterruptedException e)
           { System.out.println("Lefthand error.");}    
       } 
  } 
}
class Righthand extends Thread {
    public void run()     //重写run方法
    {
         for(int i=0;i<=5;i++)
         {   System.out.println("I am a Teacher!");
             try{  sleep(300);  }     //用了sleep()方法，休眠300毫秒
             catch(InterruptedException e)
             { System.out.println("Righthand error.");}
         }
    }
}
public class ThreadTest 
{
     static Lefthand left;
     static Righthand right;
     public static void main(String[] args)
     {     left=new Lefthand();
           right=new Righthand();
           left.start();
           right.start();
     }
}

运行结果：

 Runnable接口改造的程序如下：

class Lefthand implements Runnable{             //用Runnable（）接口实现线程
   public void run()
   {
      
       for(int i=0;i<=5;i++)
       {  System.out.println("You are Students!");
           try{ Thread.sleep(500);   }    //调用了Thread类的start方法
           catch(InterruptedException e)
           { System.out.println("Lefthand error.");}    
       } 
  } 
}
class Righthand implements Runnable {
    public void run()
    {
        
          for(int i=0;i<=5;i++)
         {   System.out.println("I am a Teacher!");
             try{  Thread.sleep(300);  }
             catch(InterruptedException e)
             { System.out.println("Righthand error.");}
         }
    }
}
public class Thread1
{
     static Lefthand left;
     static Righthand right;
     public static void main(String[] args)
     {      //创建Runnable类型的对象，以此类对象为参数建立Thread类的对象
           Runnable lefthand = new Lefthand();    
           Thread left=new Thread(lefthand);    
            left.start();              //调用left这个对象变量的start方法
            Runnable righthand = new Righthand();
            Thread right=new Thread(righthand);
              right.start();  
     }
}

运行结果：

测试程序3：

l 在Elipse环境下调试教材625页程序14-1、14-2 、14-3，结合程序运行结果理解程序；

l 在Elipse环境下调试教材631页程序14-4，结合程序运行结果理解程序；

l 对比两个程序，理解线程的概念和用途；

l 掌握线程创建的两种技术。

程序代码如下：

Bounce.java

package bounce;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

/**
 * 显示一个动态弹跳球。
 * @version 1.34 2015-06-21
 * @author Cay Horstmann
 */
public class Bounce
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         JFrame frame = new BounceFrame();
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
      });
   }
}

/**
 * 带有球组件和按钮的框架。
 */
class BounceFrame extends JFrame
{
   private BallComponent comp;
   public static final int STEPS = 1000;
   public static final int DELAY = 3;

   /**
    * 使用组件构造框架，以显示弹跳球和开始和关闭按钮
    */
   public BounceFrame()
   {
      setTitle("Bounce");
      comp = new BallComponent();    //创建一个新的BallComponent类赋给comp
      add(comp, BorderLayout.CENTER);
      JPanel buttonPanel = new JPanel();
      addButton(buttonPanel, "Start", event -> addBall());
      addButton(buttonPanel, "Close", event -> System.exit(0));
      add(buttonPanel, BorderLayout.SOUTH);
      pack();
   }

   /**
    * 将按钮添加到容器中。
    * @param c容器
    * @param 按钮标题
    * @param 侦听器按钮的操作侦听器
    */
   public void addButton(Container c, String title, ActionListener listener)
   {
      JButton button = new JButton(title);
      c.add(button);
      button.addActionListener(listener);
   }

   /**
    * 向面板中添加一个弹跳球，使其弹跳1000次。
    */
   public void addBall()
   {
      try
      {
         Ball ball = new Ball();
         comp.add(ball);

         for (int i = 1; i <= STEPS; i++)
         {
            ball.move(comp.getBounds());      //调用ball这对象变量来移动球
            comp.paint(comp.getGraphics());   //调用comp的paint方法来绘画
            Thread.sleep(DELAY);       //调用Thread类的sleep方法
         }
      }
      catch (InterruptedException e)
      {
      }
   }
}

BallComponent.java

package bounce;

import java.awt.*;
import java.util.*;
import javax.swing.*;

/**
 * 画球的部件。
 * @version 1.34 2012-01-26
 * @author Cay Horstmann
 */
public class BallComponent extends JPanel
{
   private static final int DEFAULT_WIDTH = 450;
   private static final int DEFAULT_HEIGHT = 350;

   private java.util.List<Ball> balls = new ArrayList<>();

   /**
    * 向组件添加一个球。
    * 要添加的球
    */
   public void add(Ball b)
   {
      balls.add(b);
   }

   public void paintComponent(Graphics g)
   {
      super.paintComponent(g); // 擦除背景
      Graphics2D g2 = (Graphics2D) g;
      for (Ball b : balls)   //foreach循环
      {
         g2.fill(b.getShape());   //通过对象变量b的getShape方法来传参给fill
      }
   }
   
   public Dimension getPreferredSize() { return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT); }     //通过返回一个新建Dimension类来获取组件的大小
}

Ball.java

package bounce;

import java.awt.geom.*;

/**
 * 从长方形边缘上移动和弹跳的球
 * @version 1.33 2007-05-17
 * @author Cay Horstmann
 */
public class Ball
{
   private static final int XSIZE = 15;
   private static final int YSIZE = 15;
   private double x = 0;
   private double y = 0;
   private double dx = 1;
   private double dy = 1;

   /**
    * 将球移动到下一个位置，如果球碰到其中一条边，则反向移动
    */
   public void move(Rectangle2D bounds)
   {
      x += dx;
      y += dy;
      if (x < bounds.getMinX())  //通过bounds来获得宽度的最小值
      {
         x = bounds.getMinX();
         dx = -dx;
      }
      if (x + XSIZE >= bounds.getMaxX())    //通过bounds来获得宽度的最大值
      {
         x = bounds.getMaxX() - XSIZE;
         dx = -dx;
      }
      if (y < bounds.getMinY())    //通过bounds来获得高度的最小值
      {
         y = bounds.getMinY();
         dy = -dy;
      }
      if (y + YSIZE >= bounds.getMaxY())   //通过bounds来获得高度的最大值 
      {
         y = bounds.getMaxY() - YSIZE;
         dy = -dy;
      }
   }

   /**
    * 获取球在当前位置的形状。
    */
   public Ellipse2D getShape()
   {
      return new Ellipse2D.Double(x, y, XSIZE, YSIZE);      //用Ellipse2D类绘制圆作为返回值
   }
}

运行结果：

实验总结：

这周主要学习了线程的相关知识，这一部分感觉很实用，但是自己知识基础薄弱，有些地方还是不太理解，要多费些时间去学习。因为专业课的冲突，有些没有听的内容通过网课得到了很好的弥补，感觉自己会慢慢跟上大家的进度，继续加油。