201871010128-杨丽霞《面向对象程序设计（java）》第十六周学习总结

201871010128-杨丽霞《面向对象程序设计（java）》第十六周学习总结（1分）

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

第一部分：总结教材14.1-14.3知识内容（20分）

14.1什么是线程

• 进程与线程
  1，多个进程额内部数据和状态是完全独立的，而多个线程是共享一块内存空间和一组资源，有可能互相影响；
  2，每个进程都有一段专用的内存区域，而线程间可以共享相同的内存单元，（包括代码和数据）并利用这些共享单元来实现数据交换，实时通信与必要的同步操作。

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

  ‐创建Thread类的子类

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

• 主线程
  每个java程序都至少有一个线程，即主线程，当一个Java程序启动时，jvm会创建主线程，并在该线程中调用程序的main（）方法。
  主线程的作用是：

  1.它是产生其他子线程的线程。
  2.通常它必须最后完成执行，因为它执行各种关闭动作。
  尽管主线程在程序启动时自动创建，但它可以由一个Thread对象控制。
  eg：调用Thread.currentThread()静态方法，返回调用该方法的当前线程的引用；

Thread th1= Thread.currentThread();System.out.println("我是主线程："+th1.getName());

·  创建线程的两种方法：
1，通过实现Runnable接口，重写其中的run（）方法，再调用Thread类的构造方法Thread（Runnable,Threadname）来实现
2，通过创建Thread类的子类来实现，即继承Thread类，重写其中的run（）方法
eg：创建一个线程，可以之定义线程名字

class HelloThread extends Thread{String name;public HelloThread(String name) {

super(name);}

@Overridepublic void run() {

}}

Java中线程的方法
start（）通过调用本线程的run（）方法，使调用该方法的线程开始执行
run（） 当一个线程初始化之后，start（）方法会自动的调用run（）方法，在该方法内编写运行本线程时需要执行的代码，也是Runnable接口的唯一方法，一旦run（）方法返回，本线程也就终止了。（一般不再线程中直接调用此方法）
final void join（） //等待该线程结束，调用了该方法的线程拥有高于其他线程的优先级
static void yield（） //把正在执行的线程临时暂停，其实就是使当前线程放弃cpu，进入就绪状态，重新排队，所以可以允许其他线程运行
final boolean isAlive() //返回线程是否处于活动状态

Java多线程的优点

1. 它不会阻塞用户，因为线程是独立的，你可以同时执行多个操作，举个栗子，你需要一个延时，等待三秒钟再进行接下来的操作，如果你使用单线程，它就真的等了你三秒，这三秒，啥都不干，啥都得放一边，就等。。。这明显是不可接受的。

2. 你可以同时执行多个操作，节省时间。这里面又牵扯到CPU密集型和IO密集型的问题

3. 线程是独立的，死掉一个，不影响另一个。

14.2中断线程

JAVA中断线程三大基本方法

方法一

程正常执行完毕，正常结束。也就是让run方法执行完毕，该线程就会正常结束。

方法二

监视某些条件，结束线程的不间断运行。然而，通常有些线程是伺服线程，它们往往需要长时间的运行，只有在外部某些条件满足的情况下，才能关闭这些线程。一般情况下，它们执行在一个while(true)的死循环中。我们可以在while死循环内，每次循环时，察看外部条件，看看是否需要关闭当前线程。如果是，就break，跳出死循环，或者是抛出异常，跳出死循环，结束线程。

方法三

捕获InterruptedException运行时异常，中断当前线程。有些执行伺服任务的线程，在while(true)这样的死循环内部，是一个阻塞中的方法。此时，就不能采用第二种方法了。因为，当该方法没有返回时，该线程会一直处于阻塞当中，根本无法执行其他语句。这时候就需要调用该线程的interrupt方法，产生一个InterruptedException运行时异常，是阻塞中的那个方法抛出这个异常，从而让我们有机会结束这个线程的执行。一个外部的Thread 对象 指向这个线程。 需要结束这个线程时，只需要调用thread对象的interrupt() 方法，就会在responseMessage = this.getSendMessages().take();这条语句中产生一个InterruptedException异常，从而结束该线程的阻塞状态，通过抛出异常，或者break跳出死循环，结束这个线程。

14.3 线程状态

Java中线程的状态分为6种：

1.初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。

实现Runnable接口和继承Thread可以得到一个线程类，new一个实例出来，线程就进入了初始状态。

2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态统的称为“运行”。

线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。

3.阻塞(BLOCKED)：表示线程阻塞于锁。

阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态

4. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）

处于这种状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态

5. 超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自返回。

处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒

6.终止(TERMINATED)：表示该线程已经执行完毕。

当线程的run()方法完成时，或者主线程的main()方法完成时，我们就认为它终止了。这个线程对象也许是活的，但是，它已经不是一个单独执行的线程。线程一旦终止了，就不能复生。

在一个终止的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常

第二部分：实验部分

实验1：测试程序1（10分）

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

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

l 掌握创建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 int DEFAULT_WIDTH = 300;
   private static final int DEFAULT_HEIGHT = 300;

   public ResourceTestFrame()
   {
      setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
      URL aboutURL = getClass().getResource("about.gif");//找到指定位置的图像文件，返回一个可以加载资源的URL
      Image img = new ImageIcon(aboutURL).getImage();//将加载的about.gif图像设置为图标
      setIconImage(img);

      JTextArea textArea = new JTextArea();
      InputStream stream = getClass().getResourceAsStream("about.txt");//读取about.txt文本文件内容
      try (Scanner in = new Scanner(stream, "UTF-8"))//将读取到的about.txt文本文件里内容显示到文本区
      {
         while (in.hasNext())//读取文本文件
            textArea.append(in.nextLine() + "\n");
      }
      add(textArea);
   }
}

运行截图：

归档截图：

打开后：

实验1：测试程序2（10分）

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

l 掌握线程概念；

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

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

class Lefthand extends Thread {
   public void run()
   {
       for(int i=;i<=;i++)
       {  System.out.println("You are Students!");
           try{   sleep();   }
           catch(InterruptedException e)
           { System.out.println("Lefthand error.");}
       }
  }
}
class Righthand extends Thread {
    public void run()
    {
         for(int i=;i<=;i++)
         {   System.out.println("I am a Teacher!");
             try{  sleep();  }
             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();
     }
}

packageThread;
//创建Thread类的子类实现多线程
class Lefthand extends Thread {
       public void run()
       {
           for(int i=;i<=;i++)
           {  System.out.println("You are Students!");
               try{   sleep();    }//给定休眠的500毫秒,500毫秒打印一次输出语句
               catch(InterruptedException e)//中断异常情况
               { System.out.println("Lefthand error.");}
           }
      }
    }
    class Righthand extends Thread {
        public void run()
        {
             for(int i=;i<=;i++)
             {   System.out.println("I am a Teacher!");
                 try{  sleep();  }//给定休眠的300毫秒,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();//启动线程，调用run()方法，此方法立即返回，新线程并发运行
         }
    }

实现Runnable之后的代码：

package Thread
//实现Runnable接口的类实现多线程
class Lefthand implements Runnable{
   public void run()
   {

       for(int i=;i<=;i++)
       {  System.out.println("You are Students!");
           try{ Thread.sleep();   }//500毫秒打印一次
           catch(InterruptedException e)//中断异常
           { System.out.println("Lefthand error.");}
       }
  }
}
class Righthand implements Runnable {
    public void run()
    {
        for(int i=;i<=;i++)
         {   System.out.println("I am a Teacher!");
             try{  Thread.sleep();  }//300毫秒打印一次
             catch(InterruptedException e)
             { System.out.println("Righthand error.");}
         }
    }
}
public class ThreadTest
{
     static Thread left;
     static Thread right;
     public static void main(String[] args)
     {
           Runnable lefthand = new Lefthand();
           left=new Thread(lefthand);
           left.start();
           Runnable righthand = new Righthand();
           right=new Thread(righthand);
           right.start();

     }
}

 

运行截图：

实验1：测试程序3（10分）

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

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

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

掌握线程创建的两种技术

程序14-1、14-2 、14-3如下：

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 = ;
   public static final int DELAY = ;

   /**
    * 创建面板容器显示滚动的小球和两个按钮
    */
   public BounceFrame()
   {
      setTitle("Bounce");
      comp = new BallComponent();
      add(comp, BorderLayout.CENTER);
      JPanel buttonPanel = new JPanel();
      addButton(buttonPanel, "Start", event -> addBall());
      addButton(buttonPanel, "Close", event -> System.exit());
      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 = ; i <= STEPS; i++)
         {
            ball.move(comp.getBounds());//小球每一次移动的尺寸
            comp.paint(comp.getGraphics());
            Thread.sleep(DELAY);//3毫秒移动一次
          }
         }
catch (InterruptedException e)

 {
 }
}
 }

package bounce;

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

/**
 * The component that draws the balls.
 * @version 1.34 2012-01-26
 * @author Cay Horstmann
 */
public class BallComponent extends JPanel
{
   private static final int DEFAULT_WIDTH = ;
   private static final int DEFAULT_HEIGHT = ;

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

   /**
    * 在容器上添加一个球
    * @param b the ball to add
    */
   public void add(Ball b)
   {
      balls.add(b);
   }

   public void paintComponent(Graphics g)
   {
      super.paintComponent(g);//清除背景
      Graphics2D g2 = (Graphics2D) g;
      for (Ball b : balls)
      {
         g2.fill(b.getShape());
      }
   }

   public Dimension getPreferredSize() { return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT); }
}

package bounce;

import java.awt.geom.*;

/**
 * A ball that moves and bounces off the edges of a rectangle
 * @version 1.33 2007-05-17
 * @author Cay Horstmann
 */
public class Ball
{
   private static final int XSIZE = ;
   private static final int YSIZE = ;
   private double x = ;
   private double y = ;
   private double dx = ;
   private double dy = ;

   /**
    * 将小球移向像一个方向，若打到任何一条边，就颠倒方向
    */
   public void move(Rectangle2D bounds)
   {
      x += dx;
      y += dy;
      if (x < bounds.getMinX())
      {
         x = bounds.getMinX();
         dx = -dx;
      }
      if (x + XSIZE >= bounds.getMaxX())
      {
         x = bounds.getMaxX() - XSIZE;
         dx = -dx;
      }
      if (y < bounds.getMinY())
      {
         y = bounds.getMinY();
         dy = -dy;
      }
      if (y + YSIZE >= bounds.getMaxY())
      {
         y = bounds.getMaxY() - YSIZE;
         dy = -dy;
      }
   }

   /**
    *在当前位置得到小球的形状
    */<br>//定义球外形

public Ellipse2D getShape() {
   return new Ellipse2D.Double(x, y, XSIZE, YSIZE);
}

运行截图：

14-4程序：

package bounceThread;

import java.awt.*;
import java.awt.event.*;

import javax.swing.*;

/**
 * Shows animated bouncing balls.
 * @version 1.34 2015-06-21
 * @author Cay Horstmann
 */
public class BounceThread
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         JFrame frame = new BounceFrame();
         frame.setTitle("BounceThread");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
      });
   }
}

/**
 *  框架与球组件和按钮
 */
class BounceFrame extends JFrame
{
   private BallComponent comp;
   public static final int STEPS = ;
   public static final int DELAY = ;

   /**
    * Constructs the frame with the component for showing the bouncing ball and
    * Start and Close buttons
    */
   //用显示弹跳球以及开始和关闭按钮的组件构建框架
   public BounceFrame()
   {
      comp = new BallComponent();
      add(comp, BorderLayout.CENTER);
      JPanel buttonPanel = new JPanel();
      addButton(buttonPanel, "Start", event -> addBall());
      addButton(buttonPanel, "Close", event -> System.exit());
      add(buttonPanel, BorderLayout.SOUTH);
      pack();
   }
   // 添加按钮
   /**
    * Adds a button to a container.
    * @param c the container
    * @param title the button title
    * @param listener the action listener for the button
    */
   public void addButton(Container c, String title, ActionListener listener)
   {
      JButton button = new JButton(title);
      c.add(button);
      button.addActionListener(listener);
   }

   /**
    * Adds a bouncing ball to the canvas and starts a thread to make it bounce
    */
   //在画布上添加一个弹跳球，并启动一个线程使其弹跳
   public void addBall()
   {
      Ball ball = new Ball();
      comp.add(ball);
      //多线程
      Runnable r = () -> {
         try
         {
            for (int i = ; i <= STEPS; i++)
            {
               ball.move(comp.getBounds());//将球移动到下一个位置，如果碰到其中一个边缘则反转方向
               comp.repaint();//重绘此组件
               Thread.sleep(DELAY);//在指定的毫秒数内让当前正在执行的线程休眠
            }
         }
         catch (InterruptedException e)
         {
         }
      };
      Thread t = new Thread(r);
      t.start();
   }
}

运行截图：

实验总结：（15分）

本周学习了线程，实现多线程，通过创建Thread类的子类，在程序中实现Runnable接口的类，创建线程的两种方法：
通过实现Runnable接口，重写其中的run（）方法，再调用Thread类的构造方法Thread（Runnable,Threadname）来实现
通过创建Thread类的子类来实现，即继承Thread类，重写其中的run（）方法

Java 的线程调度采用优先级策略:优先级高的先执行，优先级低的后执行；多线程系统会自动为每个线程分配一个优先级，缺省时，继承其父类的优先级；任务紧急的线程，其优先级较高； 同优先级的线程按“先进先出”的队列原则。线程的六种状态，以及他们之间的状态变换，各个状态的特征，3个测试程让我们对线程有了更直观的体验。