201871010135 张玉晶《面向对象程序设计（java）》第十六周学习总结

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

并发
 • 线程的概念
 • 中断线程
 • 线程状态
 • 多线程调度
 • 线程同步

一、线程的概念

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

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

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

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

二、多线程的概念

    1. 多线程是进程执行过程中产生的多条执行线索。 ‐线程是比进程执行更小的单位。

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

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

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

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

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

    • 创建Thread类的子类 

    • API :

           ➢ Therad (Runnable traget)   构造一个新线程，用于调用给定目标的run() 方法

           ➢ void start()    启动这个线程，讲引发调用 run()  方法 。这个方法将立即返回，并且新线程将并发运行。

           ➢ void run()    调用关联 Runnable 的 run 方法

           ➢ static void sleep (long millis)  休眠给定的毫秒数 

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

          ➢ void run ( ) 必须覆盖这个方法中提供索要执行的任务指令。

三、.中断线程

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

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

   • 当对一个线程调用 interrupt()  方法时，线程的中断状态将被置位。 这是每一个线程都具有的 boolean  标志 。每个线程都应该不时的检查这个标志，以判断线程是否被中断。

   • 要想弄清中断状态是否被置位，首先调用静态的  Thread.currentThread 方法获得当前线程，然后调用 isInterrupted 方法。

   • 如果线程被阻塞， 就无法检测中断状态 。这是产生 Interrupted Exception 异常的地方。

   • API : 

       ➢ void interrupt ()    像线程发送中断请求。 现成的中断状态将被设置为 true. 如果目前该线程被一个sleep 调用阻塞， 那么，InterruptedException 异常抛出。

       ➢ static boolean interupted ()    测试当前线程 （及正在执行这一命令的线程） 是否被中断。 注意， 这是一个静态方法。 这一调用会产生副作用------它将当前线程的中断状态重置为flase.

       ➢ boolean isInterrupted()    测试线程是否被终止。 不像静态的中断方法， 这一调用不改变线程的中断状态。

       ➢ static Thread currentThread ()   返回代表当执行线程的 Thread 对象。

四、. 线程状态

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

   • 线程有如下7种状态：

     ➢ New (新建)

     ➢ Runnable (可运行)

     ➢ Running(运行)

     ➢ Blocked (被阻塞)

     ➢ Waiting (等待)

     ➢ Timed waiting (计时等待)

     ➢ Terminated (被终止)

1、新创建线程

    • new（新建）线程对象刚刚创建，还没有启动，此时线程还处于不可运行状态。

2、可运行线程

  ➢ 一旦调用start方法，线程处于 runnable（可运行状态)

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

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

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

- blocked (被阻塞)

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

➢ 当线程处于阻塞或等待状态，它暂时不活动。 它不运行任何代码且消耗最少资源，直到线程调度器重新激活他。

➢ sleep(),wait()是两个常用引起线程阻塞的方法。

4、被终止的线程

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

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

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

API：

  ➢ void join()   等待终止线程

   ➢ void join(long millis)  等待指定的线程死亡或者经过指定的毫秒数

2、实验内容和步骤

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

测试程序1：

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

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

 掌握创建JAR文件的方法；

package 第十六周;
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);
      ///在找到ResourceTest类的地方查找about.gif文件
      URL aboutURL = getClass().getResource("about.gif");
      // //将此图像设置为框架的图标
      Image img = new ImageIcon(aboutURL).getImage();
      setIconImage(img);

      JTextArea textArea = new JTextArea();
      InputStream stream = getClass().getResourceAsStream("about.txt");//通过"about.txt"地址调用 getClass()方法，对文本资源进行加载
      try (Scanner in = new Scanner(stream, "UTF-8"))
      {
         while (in.hasNext())
            textArea.append(in.nextLine() + "
");//讲读到的内容显示在文本域
      }
      add(textArea);
   }
}

                

 运行结果：

    

测试程序2：

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

 掌握线程概念；

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

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

    1. Thread的扩展类实现线程的方法：

package 第十六周;

// 创建Thread类的子类实现多线程

class Lefthand extends Thread { 
       public void run()
       {
           for(int i=0;i<=5;i++)
           {  System.out.println("You are Students!");
               try{   sleep(500);   }  //每500ms 休眠一次
               catch(InterruptedException e)
               { System.out.println("Lefthand error.");}    
           } 
      } 
    }
    class Righthand extends Thread {  //创建Thread类的子类实现多线程
        public void run()
        {
             for(int i=0;i<=5;i++)
             {   System.out.println("I am a Teacher!");
                 try{  sleep(300);  } //每300ms 休眠一次
                 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();
         }
    }

2.   用Runnable接口创建线程的方法：

// 实现Runnable接口的来实现多线程
class Lefthand implements Runnable {
    public void run() {
        for (int i = 0; i <= 5; i++) {
            System.out.println("You are Students!");
            try {
                Thread.sleep(500);//调用Thread类的sleep方法   每500ms 休眠一次
            } catch (InterruptedException e) {
                System.out.println("Lefthand error.");
            }
        }
    }
}

class Righthand implements Runnable {  // 实现Runnable接口的来实现多线程
    public void run() {
        for (int i = 0; i <= 5; i++) {
            System.out.println("I am a Teacher!");
            try {
                Thread.sleep(300);//调用Thread类的sleep方法   每500ms 休眠一次
            } catch (InterruptedException e) {
                System.out.println("Righthand error.");
            }
        }
    }
}

public class ThreadTest1 {
    static Lefthand left;
    static Righthand right;

    public static void main(String[] args) {
        Runnable left1 = new Lefthand();
        Runnable right1 = new Righthand() ;
        Thread left = new Thread(left1);
        Thread right = new Thread(right1);
        left.start();
        right.start();
    }
}

运行结果如下：

     

测试程序3：

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

package 第十六周;

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

/**
 * Shows an animated bouncing ball.
 * @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);
      });
   }
}

/**
 * The frame with ball component and buttons.
 */
class BounceFrame extends JFrame
{
   private BallComponent comp;
   public static final int STEPS = 1000;
   public static final int DELAY = 3;

   /**
    * Constructs the frame with the component for showing the bouncing ball and
    * Start and Close buttons
    */
   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(0));
      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 panel and makes it bounce 1,000 times.
    */
   public void addBall()  //在面板中添加一个弹跳球，使其弹跳1000次
   {
      try
      {
         Ball ball = new Ball();
         comp.add(ball);

         for (int i = 1; i <= STEPS; i++)
         {
            ball.move(comp.getBounds());
            comp.paint(comp.getGraphics());
            Thread.sleep(DELAY);
         }
      }
      catch (InterruptedException e)
      {
      }
   }
}

package 第十六周;

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 = 15;
   private static final int YSIZE = 15;
   private double x = 0;
   private double y = 0;
   private double dx = 1;
   private double dy = 1;

   /**
    * Moves the ball to the next position, reversing direction if it hits one of the edges
    */
   public void move(Rectangle2D bounds)  //将球移动到下一个位置，如果碰到其中一个边，则反转方向
   { 
      x += dx;     //x y方向上依次加位移增量
      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;
      }
   }

   /**
    * Gets the shape of the ball at its current position.
    */
   public Ellipse2D getShape()  //获取球在其当前位置的形状。
   {
      return new Ellipse2D.Double(x, y, XSIZE, YSIZE);
   }
}

package 第十六周;

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 = 450;
   private static final int DEFAULT_HEIGHT = 350;

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

   /**
    * Add a ball to the component.
    * @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); }
}

运行结果如下：

            

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

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())
      {
         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;
      }
   }

   /**
    * 获取球在其当前位置的形状
    */
   public Ellipse2D getShape()
   {
      return new Ellipse2D.Double(x, y, XSIZE, YSIZE);
   }
}

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)
      {
         g2.fill(b.getShape());
      }
   }
   
   public Dimension getPreferredSize() { return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT); }
}

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

import javax.swing.*;

/**
 * 显示动画弹跳球。
 * @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 = 1000;
   public static final int DELAY = 5;


   /**
    * 构造包含用于显示弹跳球和开始和关闭按钮的组件的框架
    */
   public BounceFrame()
   {
      comp = new BallComponent();
      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();
   }

   public void addButton(Container c, String title, ActionListener listener)
   {
      JButton button = new JButton(title);
      c.add(button);
      button.addActionListener(listener);
   }

   /**
    * 在画布上添加一个弹跳球并开始一条线使其弹跳
    */
   public void addBall()
   {
      Ball ball = new Ball();
      comp.add(ball);
      Runnable r = () -> { 
         try
         {  
            for (int i = 1; i <= STEPS; i++)
            {
               ball.move(comp.getBounds());
               //调用组件的repaint方法，重新绘制组件
               comp.repaint();
               Thread.sleep(DELAY);
            }
         }
         catch (InterruptedException e)
         {
         }
      };
      
      //将Runnable对象作为入口参数传入Thread的构造函数，再调用start方法就可以启动线程
      Thread t = new Thread(r);
      t.start();
   }
}

运行结果如下：

         

实验2：结对编程练习：采用GUI界面设计以下程序，并创建程序归档文件。

设计一个100以内整数小学生四则运算练习程序，由计算机随机产生10道加减乘除练习题，学生输入答案，由程序检查答案是否正确，每道题正确计10分，错误不计分，10道题测试结束后给出测试总分；

将程序中测试练习题及学生答题结果输出到文件，文件名为test.txt。

 

package add;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Collections;
import java.util.Scanner;

import javax.swing.*;

import java.math.*;


public class Culu extends JFrame {
    
    private String[] c=new String[10];
    private String[] c1=new String[10];
    private int[] list=new int[10];
    int i=0,i1=0,sum = 0;
    private PrintWriter out = null;
    private JTextArea text,text1;
    private int counter;
    
    public Culu()  {
        JPanel Panel = new JPanel();
        Panel.setLayout(null);
        JLabel JLabel1=new JLabel("");
        JLabel1.setBounds(500, 800, 400, 30);
        JLabel1.setFont(new Font("Courier",Font.PLAIN,35));
        JButton Button = new JButton("生成题目");
        Button.setBounds(50,150,150,50);
        Button.setFont(new Font("Courier",Font.PLAIN,20)); 
        Button.addActionListener(new Action());
        JButton Button2 = new JButton("确定答案");
        Button2.setBounds(300,150,150,50);
        Button2.setFont(new Font("Courier",Font.PLAIN,20));
        Button2.addActionListener(new Action1());
        JButton Button3 = new JButton("读出文件");
        Button3.setBounds(500,150,150,50);
        Button3.setFont(new Font("Courier",Font.PLAIN,20));
        Button3.addActionListener(new Action2());
         text=new JTextArea(30,80);text.setBounds(30, 50, 200, 50);
         text.setFont(new Font("Courier",Font.PLAIN,35));
         text1=new JTextArea(30,80);
         text1.setBounds(270, 50, 200, 50);
         text1.setFont(new Font("Courier",Font.PLAIN,35));

         Panel.add(text);
         Panel.add(text1);

         Panel.add(Button);
         Panel.add(Button2);
         Panel.add(Button3);
         Panel.add(JLabel1);
         add(Panel);                  
    }
    
    private class Action implements ActionListener
    {
    public void actionPerformed(ActionEvent event)
        {        
        text1.setText("0");
        if(i<10) {
        
        int a = 1+(int)(Math.random() * 99);
        int b = 1+(int)(Math.random() * 99);
        int m= (int) Math.round(Math.random() * 3);
      switch(m)
      {
      case 0:
          while(a<b){  
              b = (int) Math.round(Math.random() * 100);
              a = (int) Math.round(Math.random() * 100); 
          }  
          c[i]=(i+":"+a+"/"+b+"=");
          list[i]=Math.floorDiv(a, b);
          text.setText(i+":"+a+"/"+b+"=");
          i++;   
          break; 
      case 1:
          c[i]=(i+":"+a+"*"+b+"=");
                list[i]=Math.multiplyExact(a, b);
                text.setText(i+":"+a+"*"+b+"=");        
           i++;
          break;
       case 2:
          c[i]=(i+":"+a+"+"+b+"=");
                list[i]=Math.addExact(a, b);
          text.setText(i+":"+a+"+"+b+"=");
          i++;
          break ;
      case 3:
          while(a<=b){  
              b = (int) Math.round(Math.random() * 100);
              a = (int) Math.round(Math.random() * 100); 
          }    
          c[i]=(i+":"+a+"-"+b+"=");
          text.setText(i+":"+a+"-"+b+"=");
          list[i]=Math.subtractExact(a, b);
          i++;
          break ;
          }
        }
      }
    }      
    private class Action1 implements ActionListener
    {
        public void actionPerformed(ActionEvent event)
        {    
            if(i<10) {
                text.setText(null);        
                String daan=text1.getText().toString().trim();
                int a = Integer.parseInt(daan);
                if(text1.getText()!="") {
                    if(list[i1]==a) sum+=10;
                }        
                c1[i1]=daan;
                i1++; 
            }
        }
    }      
    

    private class Action2 implements ActionListener
    {
        public void actionPerformed(ActionEvent event)
            {
         
            try {
                out = new PrintWriter("text.txt");
            } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
                e.printStackTrace();
            }
            for(int counter=0;counter<10;counter++)
            {
                out.println(c[counter]+c1[counter]);
            }
            out.println("成绩"+sum);
            out.close();

            }

    }   
}

 

package add;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Toolkit;

import javax.swing.JFrame;

public class Main {

     public static void main (String args[])
        {
             Toolkit t=Toolkit.getDefaultToolkit();
            Dimension s=t.getScreenSize(); 
            EventQueue.invokeLater(() -> {
                JFrame frame = new Culu();
                frame.setBounds(0, 0,(int)s.getWidth()/2,(int)s.getHeight()/2);
                frame.setTitle("信息");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setVisible(true);
             });        
        }
 
}

运行结果如下：

         

 

 实验总结：本周实验主要学了线程。区分了程序，进程，和线程的概念区别。多线程是并发的 ，多线程是进程执行过程中产生的多条执行线索，多线程是一个程序的多行语句同时执行 ，线程是比进程执行更小的单位。本周学习的内容还是比较难的，特别难懂，我觉得掌握的不好，课后就多看看书，尽量多理解理解。本周的结对编程难度还是很大的我觉得，自己掌握的不多，编起来就很困难，程序也是用来很长的时间来琢磨消化的，但还是模模糊糊的。