实验五 Java多线程程序设计

目的

1．    掌握Runnable接口实现多线程的方法

2．    掌握Thread类实现多线程的用法

3．    掌握Java语言中多线程编程的基本方法

1. 线程接力(45分)

要求：编写一个应用程序，除了主线程外，还有三个线程：first、second和third。
first负责模拟一个红色的按钮从坐标（10，60）运动到（100，60）；
second负责模拟一个绿色的按钮从坐标（100，60）运动到（200，60）；
third线程负责模拟一个蓝色的按钮从坐标（200，60）运动到（300，60）。
2. 线程的控制(45分)

要求:编写一个程序，动画显示文本域中的字符串。在窗体的南面添加三个按钮，为程序添加线程控制功能。
点击开始按钮（startBtn），线程开始启动，文字逐个显示，并且将按钮状态改变为禁用（因为线程不能重复启动）
点击暂停按钮（pauseBtn），线程暂停，文字显示停止
点击恢复按钮（resumeBtn），线程恢复运行，文字继续显示
当线程执行完毕后，恢复开始按钮的状态为可用。
线程接力

1. import javax.swing.*;
2. import java.awt.*;
3. import java.awt.event.*;
5. public class MoveButton extends Frame implements Runnable, ActionListener {
6.     // 用Thread类声明first,second,third三个线程对象
7.         Thread first,second,third;
8.     Button redButton, greenButton, blueButton, startButton;
9.     int distance = 10;
11.     MoveButton() {
12.         //分别创建first,second,third三个线程，用当前窗口做为该线程的目标对象
13.         first =new Thread(this);
14.         second = new Thread(this);
15.         third = new Thread(this);
16.         redButton = new Button();
17.         greenButton = new Button();
18.         blueButton = new Button();
19.         redButton.setBackground(Color.red);
20.         greenButton.setBackground(Color.green);
21.         blueButton.setBackground(Color.blue);
22.         startButton = new Button("start");
23.         startButton.addActionListener(this);
25.         setLayout(null);
26.         add(redButton);
27.         redButton.setBounds(10, 60, 15, 15);
28.         add(greenButton);
29.         greenButton.setBounds(100, 60, 15, 15);
30.         add(blueButton);
31.         blueButton.setBounds(200, 60, 15, 15);
32.         add(startButton);
33.         startButton.setBounds(10, 100, 30, 30);
35.         JLabel label1 = new JLabel("your name   不啦不啦不啊咯");
36.         add(label1);
37.         label1.setBounds(50, 105, 150, 25);
39.         setTitle("线程接力");
40.         setBounds(0, 0, 400, 200);
41.         setVisible(true);
42.         validate();
43.         addWindowListener(new WindowAdapter() {
44.             public void windowClosing(WindowEvent e) {
46.                                 System.exit(0);
47.             }
48.         });
49.     }
51.     public void actionPerformed(ActionEvent e) {
52.         try {
53.             // 分别启动三个线程
54.             first.start();
55.             second.start();
56.             third.start();
58.         } catch (Exception exp) {
59.         }
60.     }
62.     public void run() {
63.         while (true) {
64.             // 判断当前占有CPU资源的线程是否是first
65.             if (Thread.currentThread()==first) {
66.                 moveComponent(redButton);
67.                 try {
68.                     Thread.sleep(20);
69.                 } catch (Exception exp) {
70.                 }
71.             }
72. // 判断当前占有CPU资源的线程是否是second
73.             if (Thread.currentThread()==second) {
74.                 moveComponent(greenButton);
75.                 try {
76.                     Thread.sleep(10);
77.                 } catch (Exception exp) {
78.                 }
79.             }
80. // 判断当前占有CPU资源的线程是否是third
81.             if (Thread.currentThread()==third) {
82.                 moveComponent(blueButton);
83.                 try {
84.                     Thread.sleep(20);
85.                 } catch (Exception e) {
87.                 }
88.             }
89.         }
90.     }
92.     public synchronized void moveComponent(Component b) {
93.         if (Thread.currentThread() == first) {
94.             while (distance > 100 && distance <= 300)
95.                 try {
96.                     wait();
97.                 } catch (Exception exp) {
98.                 }
99.             distance = distance + 1;
100.             b.setLocation(distance, 60);
101.             if (distance >= 100) {
102.                 b.setLocation(10, 60);
103.                 notifyAll();
104.             }
105.         }
106.         if (Thread.currentThread() == second) {
107.             while ((distance>10 && distance<100) && (distance>200 && distance<300) )
108.                 try {
109.                     wait();
110.                 } catch (Exception exp) {
111.                 }
112.             distance = distance + 1;
113.             b.setLocation(distance, 60);
114.             if (distance > 200) {
115.                 b.setLocation(100, 60);
116.                 notifyAll();
117.             }
118.         }
119.         if (Thread.currentThread() == third) {
120.             while (distance<200)
121.                 try {
122.                     wait();
123.                 } catch (Exception exp) {
124.                 }
125.             distance = distance + 1;
126.             b.setLocation(distance, 60);
127.             if (distance > 300) {
128.                 distance = 10;
129.                 b.setLocation(200, 60);
130.                 notifyAll();
131.             }
132.         }
133.     }
135.     public static void main(String[] args) {
136.         new MoveButton().setLocationRelativeTo(null);
137.     }
138. }

复制代码

程序运行截图

自己截图粘贴进markdown
实验总结

“线程接力”体现了Java多线程编程的线程切换特性，通过三个线程对一个组件进行移动，实现了多个线程间的协同作用。
线程的控制

1. import java.awt.*;
2. import java.awt.event.ActionEvent;
3. import java.awt.event.ActionListener;
4. import javax.swing.*;
5. import javax.swing.border.BevelBorder;
7. public class RunnableDemo extends JFrame implements Runnable, ActionListener {
8.     private JTextArea textArea; // 文本域组件
9.     JLabel label;
10.     Button startBtn, pauseBtn, resumeBtn;
11.     Panel panel;
12.     Thread thread;
13.     boolean move = false;
15.     // 动画显示的文本字符串
16.     private String introduction = "现在大家已经对计算机很熟悉了，如今计算机的操作"
17.             + "系统可以同时执行多个任务，在听歌的同时能够打字、下载文件，在聊天窗口打"
18.             + "字的时候，对方同时还能通过视频看到你；听到你。这一切都是使用多任务实现"
19.             + "的，Java语言使用多线程实现一个程序中的多个任务同时运行。程序员可以在程"
20.             + "序中执行多个线程，每一个线程完成一个功能，并与其他线程并发执行，这种机"
21.             + "制被称为多线程。";
23.     public static void main(String args[]) {
24.         new RunnableDemo().setLocationRelativeTo(null); // 创建本类实例对象
25.     }
27.     public RunnableDemo() {
28.         setTitle("线程的控制");
29.         label = new JLabel("多线程简介： your name   不啦不啦不啊咯"); // 标签组件
30.         getContentPane().add(label, BorderLayout.NORTH);// 添加标签到窗体
31.         textArea = new JTextArea("\t"); // 初始化文本域组件
32.         textArea.setBorder(new BevelBorder(BevelBorder.LOWERED));// 设置边框
33.         textArea.setLineWrap(true); // 设置自动折行
34.         getContentPane().add(textArea, BorderLayout.CENTER);// 添加文本域组件到文本框
35.         startBtn = new Button("开始");
36.         pauseBtn = new Button("暂停");
37.         resumeBtn = new Button("恢复");
38.         startBtn.addActionListener(this);
39.         pauseBtn.addActionListener(this);
40.         resumeBtn.addActionListener(this);
41.         panel = new Panel();
42.         panel.add(startBtn);
43.         panel.add(pauseBtn);
44.         panel.add(resumeBtn);
45.         getContentPane().add(panel, BorderLayout.SOUTH);
46.         setBounds(0, 0, 383, 225); // 设置窗体大小位置
47.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
48.         setVisible(true); // 显示窗体
49.     }
51.     /**
52.      * Runnable接口方法，是线程的执行方法
53.      */
54.     @Override
55.     public void run() {
56.         textArea.setText("\t");
57.         String[] intros = introduction.split(""); // 将字符串分割为数组
58.         for (String ch : intros) { // ForEach遍历字符串数组
59.             while (!move) {
60.                 try {
61.                     synchronized (this) {
62.                         wait();
63.                     }
64.                 } catch (InterruptedException e) {
65.                     e.printStackTrace();
66.                 }
67.             }
68.             textArea.append(ch); // 添加一个字符到文本域
69.             try {
70.                 Thread.sleep(100); // 线程休眠0.1秒
71.             } catch (InterruptedException e) {
72.                 e.printStackTrace();
73.             }
74.         }
75.         startBtn.setEnabled(true);
76.     }
78.     @Override
79.     public void actionPerformed(ActionEvent e) {
80.         if (e.getSource() == startBtn) {
81.                 thread =new Thread(this);
82.                         thread.start();
83.                         move=true;
84.                         startBtn.setEnabled(false);
86.         } else if (e.getSource() == pauseBtn) {
87.                 move=false;
88.         } else if (e.getSource() == resumeBtn) {
89.                 move=true;
90.                 synchronized (this) {
91.                                 notifyAll();
92.                         }
93.         }
94.     }
95. }

复制代码

程序运行截图

自己截图粘贴进markdown
实验总结

这个实例体现了Java多线程编程的线程控制特性，通过线程的控制实现了动画效果的实时调整。
Java多线程编程非常重要，能够提高程序运行效率，但同时也需要注意线程之间的协作和控制，避免死锁。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！