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多线程的优点
它不会阻塞用户,因为线程是独立的,你可以同时执行多个操作,举个栗子,你需要一个延时,等待三秒钟再进行接下来的操作,如果你使用单线程,它就真的等了你三秒,这三秒,啥都不干,啥都得放一边,就等。。。这明显是不可接受的。
你可以同时执行多个操作,节省时间。这里面又牵扯到CPU密集型和IO密集型的问题
线程是独立的,死掉一个,不影响另一个。
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分)
通过实现Runnable接口,重写其中的run()方法,再调用Thread类的构造方法Thread(Runnable,Threadname)来实现
通过创建Thread类的子类来实现,即继承Thread类,重写其中的run()方法