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

    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() + "\n");//讲读到的内容显示在文本域
       }
       add(textArea);
    }
 }

               

运行结果：

测试程序2：

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

掌握线程概念；

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

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

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

 package 第十六周;

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

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

 class Righthand implements Runnable {  // 实现Runnable接口的来实现多线程
     public void run() {
         for (int i = ; i <= ; i++) {
             System.out.println("I am a Teacher!");
             try {
                 Thread.sleep();//调用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 = ;
    public static final int DELAY = ;

    /**
     * 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());
       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 = ; 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 = ;
    private static final int YSIZE = ;
    private double x = ;
    private double y = ;
    private double dx = ;
    private double dy = ;

    /**
     * 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 = ;
    private static final int DEFAULT_HEIGHT = ;

    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 = ;
    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;
       }
    }

    /**
     * 获取球在其当前位置的形状
     */
    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 = ;
    private static final int DEFAULT_HEIGHT = ;

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

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

    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 = ; 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[];
     private String[] c1=new String[];
     private int[] list=new int[];
     int i=,i1=,sum = ;
     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(, , , );
         JLabel1.setFont(new Font("Courier",Font.PLAIN,));
         JButton Button = new JButton("生成题目");
         Button.setBounds(,,,);
         Button.setFont(new Font("Courier",Font.PLAIN,));
         Button.addActionListener(new Action());
         JButton Button2 = new JButton("确定答案");
         Button2.setBounds(,,,);
         Button2.setFont(new Font("Courier",Font.PLAIN,));
         Button2.addActionListener(new Action1());
         JButton Button3 = new JButton("读出文件");
         Button3.setBounds(,,,);
         Button3.setFont(new Font("Courier",Font.PLAIN,));
         Button3.addActionListener(new Action2());
          text=new JTextArea(,);text.setBounds(, , , );
          text.setFont(new Font("Courier",Font.PLAIN,));
          text1=new JTextArea(,);
          text1.setBounds(, , , );
          text1.setFont(new Font("Courier",Font.PLAIN,));

          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("");
         if(i<) {

         int a = +(int)(Math.random() * );
         int b = +(int)(Math.random() * );
         int m= (int) Math.round(Math.random() * );
       switch(m)
       {
       case :
           while(a<b){
               b = (int) Math.round(Math.random() * );
               a = (int) Math.round(Math.random() * );
           }
           c[i]=(i+":"+a+"/"+b+"=");
           list[i]=Math.floorDiv(a, b);
           text.setText(i+":"+a+"/"+b+"=");
           i++;
           break;
       case :
           c[i]=(i+":"+a+"*"+b+"=");
                 list[i]=Math.multiplyExact(a, b);
                 text.setText(i+":"+a+"*"+b+"=");
            i++;
           break;
        case :
           c[i]=(i+":"+a+"+"+b+"=");
                 list[i]=Math.addExact(a, b);
           text.setText(i+":"+a+"+"+b+"=");
           i++;
           break ;
       case :
           while(a<=b){
               b = (int) Math.round(Math.random() * );
               a = (int) Math.round(Math.random() * );
           }
           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<) {
                 text.setText(null);
                 String daan=text1.getText().toString().trim();
                 int a = Integer.parseInt(daan);
                 if(text1.getText()!="") {
                     if(list[i1]==a) sum+=;
                 }
                 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=;counter<;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(, ,(int)s.getWidth()/,(int)s.getHeight()/);
                 frame.setTitle("信息");
                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                 frame.setVisible(true);
              });
         }

 }

运行结果如下：

      

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