Java中的多线程机制

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();// 中断线程
	}
}