Java中的多线程机制
如果一次只能完成一件事会很容易,但是现实生活中很多事情都是同时进行的所以Java中为了模拟这种状态,引入了线程机制。
世间万物都可以同时完成很多的工作,列如,人体可以同时进行呼吸、血液循环、思考问题等活动。用户可以在使用计算机的同时听音乐,也可以使用计算机看贴吧,而这些活动完全是可以同时进行,这种思想放在Java中被称为并发机制,而将这些并发完成的每一件事情称为线程。
在Java,并发机制非常重要,但并不是所有程序语言都支持多线程机制。在以往的程序中,多以一个任务完成在进行下一个项目的模式进行开发,这样下一个任务就必须等上一个任务完成才能进。Java语言提供了并发机制,程序员可以在程序中执行多个线程,每一个线程完成一个功能,并与其他线程并发进行,这种机制被称为多线程。
一个线程则是一个进程的执行流程,一个进程中也可以同时包含多个线程,每个线程也可以分配到小段程序的执行时间,这样一个线程就可以具有多个并发执行的线程。在单线程中,程序调用代码依次执行,如果需要一个进程同时完成多段代码就可以开多个线程。
实现线程的两种方式
在Java中主要提供两种方式实现多线程机制,分别为继承java.lang.Thread类和实现java.lang.Runnable接口。
1.继承Thread类
Thread类是java.lang包中的一个类,从这个类中实例化的对象代表线程,程序员启动一个新线程就需要建立Tread实例。Thread类中常用的两种构造方法如下:
- public Thread():创建一个新的线程对象
- public Thread(String threadName):创建一个名称为threadName的线程对象
继承Thread类创建一个新的线程的语法如下:
public ThreadTest extends Thread{
//ThreadTest 这是小编取的一个类名可以为其他
}
完成线程的真正功能代码放在run()方法中,当类继承Thread类后就可以在该类中覆盖run()方法,将实现线程功能的代码写入run()方法中,然后同时在类中调用strat()方法启动线程。
注意:如果strat()方法调用一个已经启动的线程,程序就会抛出一个IllegaThreadStateExceptionl异常
Thread对象需要一个任务来执行,就是线程在启动时执行的工作,工作方式就是在run()方法中。run()方法语法格式:
public void run(){
}
当执行一个线程程序时会自动,会自动启动一个线程给主方法运行,当不需要启动其他线程是,程序为单线程。主方法线程启动有Java虚拟机负责,程序员需要启动自己的线程。
public static void main(String[] args){
new ThreadTest().strat();//启动线程
}
例
public class Test extends Thread{ //指定类继承Thread类
private int count=10;
public void run(){ //重写run()方法
while(true){
System.out.print(count+" "); //打印count变量
if(--count==0){ //使count变量自减,当自减为0时,退出循环
return;
}
}
}
public static void main(String[] args){
new Test().start; // 启动线程
}
2.实现Runnable接口
当我们需要继承其他类(非Thread类),而且需要实现多线程就可以通过 Runnable 接口来实现。
实现 Runnable 接口的语法:
- public class Thread extends Object implements Runnable
实现 Runnable 接口的程序会创建一个Thread 对象,并将 Runnable 对象与 Thread 对象相关联。Thread 类中有以下两种构造方法:
- public Thread(Runnable target).
- public Thread(Runnable target, String name)
使用 Runnable 接口启动新线程的步骤如下: - 建立 Runnable 对象。
- 使用参数为 Runnable 对象的构造方法创建 Thread实例。
- 调用 start() 方法启动线程。
例
import java.awt.Container;
import java.net.URL;
import java.swing.*;
public class SwingTest extends JFrame{
private JLable jl = new JLable(); //声明JLable对象
private static Thread t; //声明线程对象
private int count = 0; //声明计数变量
private Container coutainer = getContenPane(); //声明容器
public SwingTest(){
setBounds(300,200,250,100); //决对定位窗体大小与位置
coutainer.setLayout(null); //使窗体不使用任何布局管理器
URL url = SwingAndThread.class.getResource("/1.gif"); //获取图片URL
Icon icon = new ImageIcon(url); //实例化一个icon
jl.setIcon(icon); //将图标放置在标签中
//设置图片在标签的最左方
jl.setHorizontalAlignment(SwingConstans.LEFT);
jl.setBounds(10,10,200,50); //设置标签的大小与位置
jl.setOpaque(true);
t = new Thread(new Runnable){
public void run(){ //复写run()方法
while(count<=200){ //设置循环条件
//将标签的横坐标用变量表示
jl.setBounds(count,10,200,50);
try{
Thread.sleep(1000); //使线程休眠
}cath(Exception e){
e.printStackTrace();
}
count+=4; //横坐标每次自增4
if(count==20){
//当图标到达标签的最右边时,使其回到最左
count = 10;
}
}
}
});
t.start(); //启动线程
container.add(jl); //将标签添加到容器中
setVisible(true); //使窗体可见
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); //设置窗体的关闭方式
}
public static void main(String[] args){
new SwingTest(); //实例化一个SwingTest()对象
}
}
3.线程的生命周期
线程是具有生命周期,其中包含7种状态,分别是出生状态、就绪状态、运行状态、等待状态、休眠状态、阻塞状态和死亡状态。出生状态就是线程被创建时处于的状态,在用户使用该线程实例调用 start() 方法之前线程都处于出生状态,当用户调用 start() 方法之后 ,线程处于就绪状态(又被称为可执行状态);当线程得到系统资源后就进入运行状态。
一旦线程进入可执行状态,它就会在就绪与运行状态下转换,同时也有可能进入等待、休眠。阻塞或死亡状态。当处于运行状态下的线程调用 Thread 类中的 wait() 方法时,该线程便会进入等待状态,进入等待状态下的线程必须调用 Thread 类中的 notify() 方法才能被唤醒,而notifyAll() 方法是将所有处于等待状态下的线程唤醒;当线程调用 Thread 类中的 sleep() 方法使,则会进入休眠状态。如果一个线程在运行状态发出输出/输入请求,该线程将进入阻塞状态,在其等待输入/输出结束时线程进入就绪状态,对于阻塞的线程来说,即使系统资源空闲,线程依然不能回到运行状态。当线程的 run()方法执行完毕时线程进入死亡状态。
线程处于就绪状态的方法有:
- 调用 sleep() 方法。
- 调用 wait() 方法。
- 等待输入/输出完成
线程处于就绪状态后,以下方法可以使线程再次进入运行状态: - 线程调用 notify() 方法。
- 线程调用 notifyAll() 方法。
- 线程调用 interrupt() 方法。
- 线程的休眠时间结束。
- 输入/输出结束。
4.操作线程的方法
1.线程休眠
一种能控制线程行为的方法就是调用 sleep() 方法,sleep() 方法需要一个参数用于指定该线程休眠时间,该时间以毫秒为单位。
由于 sleep() 方法的执行会抛出 InterruptedException 异常,所以将 sleep() 方法的调用放在 try-catch 块中。虽然调用 sleep() 方法的线程在一段时间内会醒来,但是并不能保证醒来后就会进入运行状态,只能保证它进入就绪状态。
例
import java.awt.*;
import java.util.Random;
import javax.swing.*;
import com.sun.org.apache.xml.internal.security.Init;
public class SleepTest extends JFrame {
/**
*
*/
private Thread thread;
// 定义颜色数组
private static Color[] colors = { Color.BLACK, Color.BLUE, Color.CYAN, Color.GREEN, Color.ORANGE, Color.YELLOW,
Color.RED, Color.PINK, Color.LIGHT_GRAY };
private static final Random rand = new Random(); // 创建随机对象
private static Color getC() {
return colors[rand.nextInt(colors.length)];
}
public SleepTest() {
/**
*创建匿名线程对象
*/
thread = new Thread(new Runnable() {
// 定义初始坐标
int x = 30;
int y = 50;
public void run() {
while (true) {
try {
Thread.sleep(100);// 线程休眠0.1秒
} catch (InterruptedException e) {
e.printStackTrace();
}
// 获取组件绘图上下文对象
Graphics graphics = getGraphics();
graphics.setColor(getC());// 设置绘图颜色
// 绘制直线并递增垂直坐标
graphics.drawLine(x, y, 100, y++);
if (y >= 80) {
y = 50;
}
}
}
});
thread.start();// 启动线程
}
public static void main(String[] args) {
/**
*主方法
*/
init(new SleepTest(), 100, 100);
}
public static void init(JFrame frame, int width, int height) {
/**
*初始化程序界面的方法
*/
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(width, height);
frame.setVisible(true);
}
}
2.线程的加入
如果一个程序为多线程程序,存在一个线程A,现在需要加入线程B,并要求先执行线程B完毕,在执行线程A,此时可以使用 Thread 类中的 join()方法来完成。当某个线程使用 join() 方法加入到另一个线程时,另一个线程会等待该线程执行完毕后再继续执行。
import java.awt.BorderLayout;
import javax.swing.*;
public class JoinTest extends JFrame {
/**
*
*/
private Thread threadA;
private Thread threadB;
final JProgressBar progressBar = new JProgressBar();// 定义两个进度条组件
final JProgressBar progressBar2 = new JProgressBar();
int count = 0;
public static void main(String[] args) {
JoinTest frame = new JoinTest();
frame.setVisible(true);
}
public JoinTest() {
super();
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(100, 100);
// 将进度条设置在窗体最北面
getContentPane().add(progressBar, BorderLayout.NORTH);
// 将进度条设置在窗体最南面
getContentPane().add(progressBar2, BorderLayout.SOUTH);
progressBar.setStringPainted(true);// 设置进度条显示数字字符
progressBar2.setStringPainted(true);
// 使用匿名内部类形式初始化Thread 实例
threadA = new Thread(new Runnable() {
int count = 0;
public void run() {
while (true) {
progressBar.setValue(++count);// 设置进度条的当前值
try {
Thread.sleep(100);// 线程A休眠100毫秒
threadB.join();// 使线程B调用join()方法
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
}
});
threadA.start();// 启动线程A
threadB = new Thread(new Runnable() {
int count = 0;
public void run() {
while (true) {
progressBar2.setValue(++count);// 设置进度条当前值
try {
Thread.sleep(100);// 线程休眠100毫秒
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
if (count == 100) {
break;// 当count为100时跳出循环
}
}
}
});
threadB.start();
}
}
}
3.线程的中断
以往有的时候回使用 stop() 方法停止线程,但当前版本的 JDK 早已废除了 stop() 方法,不建议使用 stop() 方法来停止一个线程的运行。现在提倡在 run() 方法中使用无线循环的形式,然后使用一个布尔型标记控制循环的停止。
如果线程是因为使用了 slepp() 或 wait() 方法进入了就绪状态,可以使用Thread 类中 interrupt() 方法是线程离开 run() 方法,同时结束线程,但程序会抛出 InterruptedException 异常,用户可以在处理该异常时完成线程的中断业务处理,如终止 while 循环。
import java.awt.BorderLayout;
import javax.swing.*;
public class InterruptedSwing extends JFrame {
/**
*
*/
Thread thread;
public static void main(String[] args) {
InterruptedSwing frame = new InterruptedSwing();
frame.setVisible(true);
}
/**
* 构造函数
*/
public InterruptedSwing() {
super();
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(100, 100);
final JProgressBar progressBar = new JProgressBar();// 创建进度条
getContentPane().add(progressBar, BorderLayout.NORTH);// 将进度条放在窗体合适的位置
progressBar.setStringPainted(true);// 设置进度条上显示数字
thread = new Thread(new Runnable() {
int count = 0;
public void run() {
while (true) {
progressBar.setValue(++count);// 设置进度条的值
try {
thread.sleep(1000);// 使线程休眠1000毫秒
// 捕捉异常
} catch (InterruptedException e) {
System.out.println("当前线程被中断");
break;
}
}
}
});
thread.start();// 启动线程
thread.interrupt();// 中断线程
}
}