201771010110孔维滢《面向对象程序设计Java》第十六周实验总结

理论知识部分：

1.程序与进程：

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

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

2.多线程

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

3.进程：

    线程是比进程执行更小的单位。线程不能独立存在，必须存在于进程中，同一进程的各线程间共享进程空间的数据。每个线程有它自身的产生、存在和消亡的过程， 是一个动态的概念。线程创建、销毁和切换的负荷远小于进程，又称 为轻量级进程（lightweight process）。

4.Java实现多线程：

    -创建Thread类的子类

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

5.用Thread类的子类创建线程：

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

        class hand extends Thread { public void run() {……} }

    然后用创建该子类的对象

        Lefthand left=new Lefthand();

        Righthand right=new Righthand();

    最后用start()方法启动线程

        left.start();

        right.start();

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

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

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

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

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

7.线程的终止

    调用interrupt()方法；

8.

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

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

-static boolean interrupted()

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

-boolean isInterrupted()

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

9、线程的状态

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

    -线程有如下7种状态：

         New (新建)

    Runnable (可运行)

    Running(运行)

    Blocked (被阻塞)

    Waiting (等待)

    Timed waiting (计时等待) 

    Terminated (被终止)

10、新创建线程

    -new（新建）

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

11、可运行线程

   - runnable（可运行状态)

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

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

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

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

    - blocked (被阻塞)

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

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

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

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

13、线程阻塞的三种情况

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

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

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

14、被终止的线程

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

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

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

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

15、多线程调度

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

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

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

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

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

16、Thread类有三个与线程优先级有关的静态量：

        MAX_PRIORITY：最大优先权,值为10；

       MIN_PRIORITY：最小优先权,值为1；

       NORM _PRIORITY：默认优先权,值为5。

实验部分：

测试程序1：

    

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

　　用runable接口实习

class Lefthand implements Runnable{
   public void run()
   {
      
       for(int i=0;i<=5;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=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 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();
              
     }
}

　　或

class Lefthand implements Runnable{
   public void run()
   {
      
       for(int i=0;i<=5;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=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 ThreadTest 
{
     static Lefthand left;
     static Righthand right;
     public static void main(String[] args)
     {    
           Runnable lefthand = new Lefthand();
           Thread left=new Thread(lefthand);
            left.start();
            Runnable righthand = new Righthand();
            Thread right=new Thread(righthand);
              right.start();
              
     }
}

　　

测试程序2：

package bounce;

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

　　 

package bounceThread;

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

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

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

   /**
    * 向面板中添加一个球。
    * @param b把球加到面板上
    */
   public void add(Ball b)
   {
      balls.add(b);
   }

   public void paintComponent(Graphics g)
   {
      Graphics2D g2 = (Graphics2D) g;
      for (Ball b : balls)
      {
         g2.fill(b.getShape());
      }
   }
   
   public Dimension getPreferredSize() { return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT); }
}

　　

package bounceThread;

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

　　

　

package bounceThread;

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

   /**
    * 将按钮添加到容器中。
    * @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);
   }

   /**
    * 在画布上添加一个弹跳球，并启动一根线使其弹跳
    */
   public void addBall()
   {
      Ball ball = new Ball();
      comp.add(ball);
      Runnable r = () -> { 
         try
         {  
            for (int i = 1; i <= STEPS; i++)
            {
               ball.move(comp.getBounds());
               comp.repaint();
               Thread.sleep(DELAY);
            }
         }
         catch (InterruptedException e)
         {
         }
      };
      Thread t = new Thread(r);
      t.start();
   }
}

　

 测试程序3：

class Race extends Thread {
  public static void main(String args[]) {
    Race[] runner=new Race[4];
    for(int i=0;i<4;i++) runner[i]=new Race( );
   for(int i=0;i<4;i++) runner[i].start( );
   runner[1].setPriority(MIN_PRIORITY);
   runner[3].setPriority(MAX_PRIORITY);}
  public void run( ) {
      for(int i=0; i<1000000; i++);
      System.out.println(getName()+"线程的优先级是"+getPriority()+"已计算完毕!");
    }
}

　　

测试程序4

package unsynch;

import java.util.*;

/**
 * 有许多银行账户的银行。
 * @version 1.30 2004-08-01
 * @author Cay Horstmann
 */
public class Bank
{
   private final double[] accounts;

   /**
    *构建了银行。
    * @param n账户数量
    * @param 每个帐户的初始余额
    */
   public Bank(int n, double initialBalance)
   {
      accounts = new double[n];
      Arrays.fill(accounts, initialBalance);
   }

   /**
    * 把钱从一个账户转到另一个账户。
    * @param 从账户转出
    * @param 到账转到
    * @param 转帐金额
    */
   public void transfer(int from, int to, double amount)
   {
      if (accounts[from] < amount) return;
      System.out.print(Thread.currentThread());
      accounts[from] -= amount;
      System.out.printf(" %10.2f from %d to %d", amount, from, to);
      accounts[to] += amount;
      System.out.printf(" Total Balance: %10.2f%n", getTotalBalance());
   }

   /**
    * 获取所有帐户余额的总和。
    * @return 总平衡
    */
   public double getTotalBalance()
   {
      double sum = 0;

      for (double a : accounts)
         sum += a;

      return sum;
   }

   /**
    * 获取银行中的帐户编号。
    * @return 账户数量
    */
   public int size()
   {
      return accounts.length;
   }
}

　　

package unsynch;

/**
 * 当多个线程访问一个数据结构时，这个程序显示数据损坏。
 * @version 1.31 2015-06-21
 * @author Cay Horstmann
 */
public class UnsynchBankTest
{
   public static final int NACCOUNTS = 100;
   public static final double INITIAL_BALANCE = 1000;
   public static final double MAX_AMOUNT = 1000;
   public static final int DELAY = 10;
   
   public static void main(String[] args)
   {
      Bank bank = new Bank(NACCOUNTS, INITIAL_BALANCE);
      for (int i = 0; i < NACCOUNTS; i++)
      {
         int fromAccount = i;
         Runnable r = () -> {
            try
            {
               while (true)
               {
                  int toAccount = (int) (bank.size() * Math.random());
                  double amount = MAX_AMOUNT * Math.random();
                  bank.transfer(fromAccount, toAccount, amount);
                  Thread.sleep((int) (DELAY * Math.random()));
               }
            }
            catch (InterruptedException e)
            {
            }            
         };
         Thread t = new Thread(r);
         t.start();
      }
   }
}

　　

综合编程练习

1 .

package 第十六周;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
 
public class Aaa extends JFrame {
    private JTextField name;
    private JTextField psw;
 
    public Aaa() {
         
        JPanel panel = new JPanel();
        getContentPane().add(panel, BorderLayout.CENTER);
        panel.setLayout(new GridLayout(3, 2, 5, 2));
        
        JPanel panel_1 = new JPanel();
        panel.add(panel_1);
        JLabel label = new JLabel("Name:");
        panel_1.add(label);
        name = new JTextField();
        panel_1.add(name);
        name.setColumns(10);
 
        JPanel panel_4 = new JPanel();
        panel.add(panel_4);
        JLabel Label4 = new JLabel("Qualification:");
        panel_4.add(Label4);
        String[] nians = { "Graduate", "Academic degree", "Foundation degree", "Ungraduate" };
        final JComboBox comboBox = new JComboBox(nians);
        panel_4.add(comboBox);
        
        JPanel panel_2 = new JPanel();
        panel.add(panel_2);
        JLabel label2 = new JLabel("Address:");
        panel_2.add(label2);
        psw = new JTextField();
        panel_2.add(psw);
        psw.setColumns(10);
        
        JPanel panel_5 = new JPanel();
        panel.add(panel_5);
        JLabel Label5 = new JLabel("Hobby:");
        panel_5.setLayout(new GridLayout(3, 2, 0, 0));
        panel_5.add(Label5);
        final JCheckBox cb1 = new JCheckBox("Reading");
        panel_5.add(cb1);
        JLabel reginfo1 = new JLabel(" ");
        panel_5.add(reginfo1);
        final JCheckBox cb2 = new JCheckBox("Singing");
        panel_5.add(cb2);
        JLabel reginfo2 = new JLabel(" ");
        panel_5.add(reginfo2);
        final JCheckBox cb3 = new JCheckBox("Dancing");
        panel_5.add(cb3);
 
        JPanel panel_3 = new JPanel();
        panel.add(panel_3);
        panel_3.setLayout(new GridLayout(2, 2, 0, 0));
        JLabel Label3 = new JLabel("Sex:");
        panel_3.add(Label3);
        final JRadioButton rb1 = new JRadioButton("Female");
        panel_3.add(rb1);
        JLabel reginfo3 = new JLabel(" ");
        panel_3.add(reginfo3);
        JRadioButton rb2 = new JRadioButton("Male");
        panel_3.add(rb2);
        ButtonGroup bg = new ButtonGroup();
        bg.add(rb1);
        rb1.setSelected(true);
        bg.add(rb2);
        
        JPanel panel1 = new JPanel();
        getContentPane().add(panel1, BorderLayout.SOUTH);
        panel1.setLayout(new GridLayout(2, 1, 5, 2));
 
        JPanel panel_6 = new JPanel();
        panel1.add(panel_6);
 
        JButton jbreg = new JButton("Validate");
        panel_6.add(jbreg);
 
        JButton jbrest = new JButton("Reset");
        panel_6.add(jbrest);
 
        JPanel panel_7 = new JPanel();
        //getContentPane().add(panel_7, BorderLayout.SOUTH);
 
        JLabel reginfo4 = new JLabel(" ");
        panel_7.add(reginfo4);
 
        setSize(480,400);
        setLocationRelativeTo(null);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setTitle("信息采集");
         
        jbreg.addActionListener(new ActionListener() {
 
            @Override
            public void actionPerformed(ActionEvent e) {
                StringBuilder sb = new StringBuilder();
                String id = name.getText();
                sb.append("Name:" + id);
                if (name != null) {
                    System.out.println("Name:"+id);
                }
                
                String pas = psw.getText();
                sb.append("Address:" + pas);
                
                if (pas != null) {
                    System.out.println("Adress:"+pas);
                }

                System.out.println("Sex:");
                if (rb1.isSelected()) {
                    sb.append("Sex:" + "Female");
                    System.out.println(rb1.getText());
                } else {
                    sb.append("Sex:" + "Male");
                    System.out.println(rb2.getText());
                }
                
                sb.append("Qualification:" + comboBox.getSelectedItem().toString());
                sb.append("Hobby:");
                System.out.println("Hobby:");
                if (cb1.isSelected()) {
                    sb.append(cb1.getText());
                    System.out.println(cb1.getText());
                }
                if (cb2.isSelected()) {
                    sb.append(cb2.getText());
                    System.out.println(cb2.getText());
                }
                if (cb3.isSelected()) {
                    sb.append(cb3.getText());
                    System.out.println(cb3.getText());
                }
                reginfo4.setText(sb.toString());
            }
        });
        jbrest.addActionListener(new ActionListener() {
 
            @Override
            public void actionPerformed(ActionEvent e) {
                name.setText("");
                psw.setText("");
                rb1.setSelected(true);
                comboBox.setSelectedIndex(0);
                cb1.setSelected(false);
                cb2.setSelected(false);
                cb3.setSelected(false);
                reginfo4.setText(" ");
            }
        });
        
    }
 
    public static void main(String[] args) {
        new Aaa().setVisible(true);
    }
}

　

　

点击重置：

2.

package 第十六周;

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();
    }
}
class Lefthand extends Thread {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(i+":lefthand.你好!");
            try {
                sleep(300);
            } catch (InterruptedException e) {
                System.out.println("Lefthand error.");
            }
        }
    }
}

class Righthand extends Thread {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(i+":righthand.你好!");
            try {
                sleep(300);
            } catch (InterruptedException e) {
                System.out.println("Righthand error.");
            }
        }
    }
}

　　

实验总结：

 本周我们学习了线程，我明白了在java中，线程的重要性。但是有些问题我还是不太理解，比如如何判断线程终止，其次，在编程练习1中我的布局还是存在一些问题，我会再去继续改正。