第二十章多线程

?

20.1线程介绍
世间有很多工作都是可以同时完成的。例如，人体可以同时进行呼吸、血液循环、思考问题等活动；用户既可以使用计算机听歌，也可以使用它打印文件。同样，计算机完全可以将多种活动同时进行，这种思想放在 Java 中被称为并发，而将并发完成的每一件事情称为线程。

在Java 中，并发机制非常重要。在以往的程序设计中，我们都是一个任务完成后再进行下一个任务。这样下一个任务的开始必须等待前一个任务的结束。Java 语言提供了并发机制，程序员可以在程序中执行多个线程，每一个线程完成一个功能，并与其他线程并发执行，这种机制被称为多线程。然而，有必要强调的是，并不是所有编程语言都支持多线程。

多线程是非常复杂的机制，比如同时阅读 3 本书，首先阅读第 1本书第1章，然后再阅读第2本书第1章，再阅读第3本书第 1章，回过头再阅读第1本书第2章，以此类推，就体现了多线程的复
杂性。

既然多线程这样复杂，那么它在操作系统中是怎样工作的呢?其实 Java 中的多线程在每个操作系统中的运行方式也存在差异，在此着重说明多线程在 Windows 操作系统中的运行模式。Windows操作系统是多任务操作系统，它以进程为单位。一个进程是一个包含有自身地址的程序，每个独立执行的程序都称为进程。也就是说每个正在执行的程序都是一个进程。系统可以分配给每个进程一段有限的使用CPU 的时间(也可以称为 CPU 时间片)，CPU 在这段时间中执行某个进程，然后下一个时间片又跳至另一个进程中去执行。由于 CPU 转换较快，所以使得每个进程好像是同时执行一样。

一个线程则是进程中的执行流程，一个进程中可以同时包括多个线程，每个线程也可以得到一小段程序的执行时间，这样一个进程就可以具有多个并发执行的线程。在单线程中，程序代码按调用顺序依次往下执行。如果需要一个进程同时完成多段代码的操作，就需要使用多线程。

20.2创建线程
20.2.1继承Thread类
Thread 类是java.lang 包中的一个类，从这个类中实例化的对象代表线程，程序员启动一个新线程需要建立 Thread 实例。Thread 类中常用的两个构造方法如下:
public Thread0:创建一个新的线程对象。

public Thread(String threadName): 创建一个名称为 threadName 的线程对象继承 Thread 类创建一个新的线程的语法如下:

public class ThreadTest extends Thread{
}

完成线程真正功能的代码放在类的 run()方法中，当一个类继承 Thread 类后，就可以在该类中覆盖run()方法，将实现该线程功能的代码写入 run()方法中，然后调用 Thread 类中的 start0方法执行线程也就是调用 run()方法。
Thread 对象需要一个任务来执行，任务是指线程在启动时执行的工作，该工作的功能代码被写在run()方法中。run0方法必须使用以下语法格式:
?

public void run(){
}
当执行一个线程程序时，就自动产生一个线程，主方法正是在这个线程上运行的。当不再启动其他线程时，该程序航为单线程程序，如本章以前的程序都是单线程程序。主方法线程启动由 Java 虚拟机负责，程序员负责启动自己的线程。代码如下:
?

public static void main(String[] args) {
new ThreadTest().start();
}
例20.1让线程循环打印1~10的数字

package 二十章;
?
public class ThreadTest {
?
?? ?public static void main(String[] args) {
?? ??? ?Thread th=new Thread() {
?? ??? ??? ?public void run() {
?? ??? ??? ??? ?System.out.println("happpy");
?? ??? ??? ?}
?? ??? ?};
?? ??? ?th.start();
?? ?}
?
}

20.2.2实现Runnable接口
到目前为止，线程都是通过扩展 Thread 类来创建的，如果程序员需要继承其他类(非 Thread类)而且还要使当前类实现多线程，那么可以通过 Runnable 接口来实现。例如，一个扩展JFrame 类的GUI程序不可能再继承 Thread 类，因为 Java 语言中不支持多继承，这时该类就需要实现 Runnable 接口使其具有使用线程的功能。实现 Runnable 接口的语法如下:
?

public class Thread extends Object implements Runnable
例20.2让窗口中的图标动起来

package 二十章;
?
import java.awt.Container;
?
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
?
public class SwingAndThread extends JFrame{?? ?
?? ?int count=0;//图标横坐标
?
?? ?public SwingAndThread() {
?? ??? ?setBounds(300,200,150,100);//绝对定位窗口大小与位置
?? ??? ?Container container=getContentPane();//主容器
?? ??? ?container.setLayout(null);//使窗口不使用任何布局管理器
?? ??? ?
?? ??? ?Icon icon=new ImageIcon("D:\\eclipse\\wc\\二十章\\1.gif");//图标对象
?? ??? ?JLabel jl=new JLabel(icon);//显示图标的标签
?? ??? ?jl.setBounds(10,10,200,50);//设置标签的大小与位置
?? ??? ?Thread t=new Thread() {//定义匿名线程对象
?? ??? ??? ?public void run() {
?? ??? ??? ??? ?while(true) {
?? ??? ??? ??? ??? ?jl.setBounds(count,10,200,50);//将标签的横坐标用变量表示
?? ??? ??? ??? ??? ?try {
?? ??? ??? ??? ??? ??? ?Thread.sleep(500);//使线程休眠500毫秒
?? ??? ??? ??? ??? ?}catch(InterruptedException e) {
?? ??? ??? ??? ??? ??? ?e.printStackTrace();?? ??? ?
?? ??? ??? ??? ??? ?}
?? ??? ??? ??? ?count+=4;//使横坐标每次加4
?? ??? ??? ??? ?if(count>=200) {
?? ??? ??? ??? ??? ?count=10;//当图标到达标签的最右边时，使其回到标签最左边
?? ??? ??? ??? ?}
?? ??? ??? ?}
?? ??? ?}
?? ?};
?? ?t.start();//启动线程
?? ?container.add(jl);//将标签添加到容器
?? ?setVisible(true);//使窗口可见
?? ?setDefaultCloseOperation(EXIT_ON_CLOSE);//设置窗口的关闭方式
?? ?}
?? ?public static void main(String[] args) {
?? ??? ?new SwingAndThread();
?? ?}
?
}

————————————————
?

20.3? ?线程的生命周期

线程的生命周期
线程具有生命周期，其中包含7种状态，分别为出生状态、就绪状态、运行状态、等待状态、休眠状态、阻塞状态和死亡状态。出生状态就是线程被创建时处于的状态，在用户使用该线程实例调用 start()方法之前线程都处于出生状态;当用户调用start()方法后，线程处于就绪状态(又被称为可执行状态);当线程得到系统资源后就进入运行状态。
一旦线程进入可执行状态，它会在就绪与运行状态下转换，同时也有可能进入等待、休眠、阻塞或死亡状态。当处于运行状态下的线程调用Thread类中的wait()方法时，该线程便进入等待状态，进入等待状态的线程必须调用Thread类中的notify()方法才能被唤醒，而调用notifyAlI()方法可将所有处于等待状态下的线程唤醒;当线程调用Thread 类中的sleep()方法时，则会进入休眠状态。如果一个线程在运行状态下发出输入/输出请求，该线程将进入阻塞状态，在其等待输入/输出结束时线程进入就绪状态，对于阻塞的线程来说，即使系统资源空闲，线程依然不能回到运行状态。当线程的run()方法执行完毕时，线程进入死亡状态。

虽然多线程看起来像同时执行，但事实上在同一时间点上只有一个线程被
执行，只是线程之间切换较快，所以才?? ?T.notif?? ?
图5 模块资源库和项
会使人产生线程是同时进行的假象。在 Windows 操作系统中，系统会为每个线程分配一小段CPU 时间片，一旦CPU时间片结束就会将当前线程换为下一个线程，即使该线程没有结束。
要使线程处于就绪状态。

20.4操作线程的方法
提作线程有很多方法，这些方法可以使线程从某一种状态过波到另一种状态，
%0.4.1 线程的休眠
-种能控制线程行为的方法是调用 slep0方法,sleep0方法需要一个参数用于指定该线程休间该时间以毫秒为单位。在前面的实例中，已经演示过 sleep0方法，它通常是在 un0方法内被使用。sleep0方法的语法如下:
tryl
Thread.sleep(2000);Jcatch(lnterruptedException e)e,printStackTrace();

上述代码会使线程在2秒之内不会进入就绪状态。由于sleep0方法的执行有可能抛出 ieruptedException异常，所以将sleep()方法的调用放在try-catch 块中。虽然使用了s00p0万法的线程在一段时间内会醒来，但是并不能保证它醒来后进入运行状态，只能保证它进入就绪状态。为了使读者更深入地了解线程的休眠方法，来看下面的实例。

package 线程;

import java.awt.Color;
import java.awt.Graphics;
import java.util.Random;

import javax.swing.*;

public class SleepMethodTest extends JFrame{
	private static Color[]color= {Color.BLACK,Color.BLUE,Color.CYAN,Color.GREEN,
			Color.YELLOW,Color.RED,Color.PINK,Color.LIGHT_GRAY
	};
	private static final Random rand=new Random();
	private static Color getC() {
		return color[rand.nextInt(color.length)];
	}
public SleepMethodTest() {
	Thread t=new Thread(new Runnable() {
		int x=30;
		int y=50;
		public void run() {
			while(true) {
				try {
					Thread.sleep(100);
				}catch(InterruptedException e){
					e.printStackTrace();
				}
				Graphics g=getGraphics();
				g.setColor(getC());
				g.drawLine(x, y, 100, y++);
				if(y>=80) {
					y=50;
				}
			}
		}
	});
	t.start();
	
}
	public static void main(String[] args) {
		init(new SleepMethodTest(),100,100);
	}
	public static void init(JFrame f,int i,int h){
		f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
		f.setSize(i,h);
		f.setVisible(true);
	}

}

运行结果如图20.5 所示。
在本实例中定义了 gctC0方法，该方法用于随机产生 Color类型的对象并且在产生线程的匿名内部类中使用 getGraphics0方法获取 Graphics 对象,使用该对象调用 setColor0方法为图形设置颜色。调用 drawLine0方法绘制-条线段，同时线段会根据纵坐标的变化自动调整。

图 20.5 线程的休眼
20.4.2 线程的加入
如果当前某程序为多线程程序，假如存在一个线程 A，现在需要插入线程 B，并要求线程B您行完毕，然后再继续执行线程 A，此时可以使用 Thread 类中的 join0方法来完成。这就好比此时读在看电视，突然有人上门收水费，读者必须付完水费后才能继续看电视。当某个线程使用 join0方法加入另外一个线程时，另一个线程会等待该线程执行完毕后再继鳞下面来看一个使用join0方法的实例。行。

[例20.4]让进度条A 等待进度条 B(实位置:资源包TMsI204)在项目中创建 JoinTest 类，该类继承了 JFrame类。该实例包括两个进度条，进度条的进度由线程*控制，通过使用 join0方法使上面的进度条必须等待下面的进度条完成后才可以继续。

package 二十多线程;

import java.awt.BorderLayout;

import javax.swing.JFrame;
import javax.swing.JProgressBar;

public class JoinTest extends JFrame {
	private Thread threadA;
	private Thread threadB;
	private JProgressBar progressBar=new JProgressBar();
	private JProgressBar progressBar2=new JProgressBar();
	
	public static void main(String[]args) {
		JoinTest test=new JoinTest();
		test.setVisible(true);
	}
	public JoinTest() {
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setBounds(200,200,200,100);
		getContentPane().add(progressBar,BorderLayout.NORTH);
		getContentPane().add(progressBar2,BorderLayout.SOUTH);
		progressBar.setStringPainted(true);
		progressBar2.setStringPainted(true);
		threadA=new Thread(new Runnable() {
			int count=0;
			public void run() {
				while(true) {
					progressBar.setValue(++count);
					try {
						Thread.sleep(100);
						threadB.join();
					}catch(InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		});
		threadA.start();
		threadB=new Thread(new Runnable() {
			int count=0;
			public void run() {
				while(true) {
					progressBar2.setValue(++count);
					try {
						Thread.sleep(100);
						
					}catch(InterruptedException e) {
						e.printStackTrace();
				}
					if(count==100);
					break;
			}
		}
		});
		threadB.start();
	}
}
	

在本实例中同时创建了两个线程，这两个线程分别负责进度条的滚动。在线程A 的rm0方法线程B 的对象调用 join0方法，而 join0方法使当前运行线程暂停，直到调用 join0方法的线程执行后再执行，所以线程 A 等待线程 B 执行完毕后再开始执行，即下面的进度条滚动完毕后上面的进才开始滚动。
20.4.3线程的中断
以往有的时候会使用 stop0方法停止线程，但当前版本的JDK 早已废除了 stop0方法，不建议stop0方法来停止一个线程的运行。现在提倡在 run0方法中使用无限循环的形式，然后使用-个标标记控制循环的停止。
如果线程是因为使用了 sleep0或 wait0方法进入了就绪状态，可以使用 Thread 类中intemupi0龙使线程离开 run0方法，同时结束线程，但程序会抛出 InterruptedException 异常，用户可以在处游常时完成线程的中断业务处理，如终止 while 循环。
下面的实例演示了某个线程使用 interrupted0方法，同时程序抛出了 InterruptedExceptio 幕,t异常处理时结束了 while 循环。在项目中，经常在这里执行关闭数据库连接和关闭 Socket 连接等[例20.5]单击按钮停止进度条滚动(实例位置:资源包TMsI205)项目中创建 InterruptedSwing 类，该类实现了 Runnable 接口，创建一个进度条，让进条服
动。添加一个按钮，若用户单击按钮，滚动条则停止滚动。

import java.awt.BorderLayout;
import java.awt.event.*;
import javax.swing.*;
	public class InterruptedSwing extends JFrame {
		
		public InterruptedSwing(){
		JProgressBar progressBar = new JProgressBar();	//创建进度条	
		getContentPane().add(progressBar, BorderLayout.NORTH);//将进度条放置在窗体合适位置
		JButton button=new JButton("停止");
		getContentPane().add(button,BorderLayout.SOUTH);
		progressBar.setStringPainted(true);	//设置进度条上显示数字	
		Thread t = new Thread(new Runnable(){
		int count = 0; public void run() {
		while (true){
			progressBar.setValue(++count);//设置进度条的当前值
		try{ 
			Thread.sleep(100);	//使线程休眠 100毫秒	
		} catch (InterruptedException e){//捕捉InterruptedException 异常
			System.out.println("当前线程序被中断"); 
			break;}
		}
		}
		}
		);
		button.addActionListener(new ActionListener(){
		@Override
		public void actionPerformed(ActionEvent e){
		t.interrupt();	//中断线程	
		}
		});	t.start();	//启动线程	
		}
		public static void init(JFrame frame, int width, int height) {
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setSize(width, height); frame.setVisible(true);
		}
 
		public static void main(String[] args){
		init(new InterruptedSwing(),100,100);
		
	}
 
}

20.4.4 线程的礼让
图 20.7 线程的中断
Thread 类中提供了一种礼让方法，使用 yield0方法表示，它只是给当前正处于运行状态的线程个提醒，告知它可以将资源礼让给其他线程，但这仅是一种暗示，没有任何一种机制保证当前线程会

将资源礼让。
yield0方法使具有同样优先级的线程有进入可执行状态的机会，在当前线程放弃执行权时会再度回到就绪状态。对于支持多任务的操作系统来说，不需要调用 yield0方法，因为操作系统会为线程自动分配CPU 时间片来执行

20.5 线程的优先级
每个线程都具有各自的优先级，线程的优先级可以表明在程序中该线程的重要性，如果有很多程处于就绪状态，系统会根据优先级来决定首先使哪个线程进入运行状态。但这并不意味着低优先的线程得不到运行，而只是它运行的概率比较小，如垃圾回收线程的优先级就较低。
Thread 类中包含的成员变量代表了线程的某些优先级，如 Thread.MIN_PRIORITY (常数 1)Thread.MAX PRIORITY(常数 10)、Thread.NORM_PRIORITY (常数 5)。其中，每个线程的优先级在 ThreadMIN PRIORITY~Thread.MAX_PRIORITY，在默认情况下其优先级都是 ThreadNORMPRIORITY。每个新产生的线程都继承了父线程的优先级。
在多任务操作系统中，每个线程都会得到一小段 CPU 时间片运行，在时间结束时，将轮换另-个线程进入运行状态，这时系统会选择与当前线程优先级相同的线程予以运行。系统始终选择就绪状态下优线程B先级较高的线程进入运行状态。处于各个优先级状态下的线程的运行顺序如图 20.8 所示。
优先级5
线程A
在图20.8 中,优先级为 5 的线程A 首先得到CPU时间片;当该时间结束后，轮换到与线程 A 相同优先级的线程 B;当线程 B 的运行时间结束后，会继续轮换到线程A，直到线程 A 与线程 B 都执行完毕，才会轮换到线程 C;当线程 C 结束后，才会轮换到线程 D线程的优先级可以使用 setPriority0方法调整，如果使用该方法设置的优先级不在 1~10, 将
优先级4
线程C
优先级3
线程D
图 20.8 处于各个优先级状态下的线程的运行顺
IllegalArgumentException 异常

由于线程的执行顺序是由 CPU 决定的，即使线程设定了优先级也是作为 CPU 的参考数据，所1实的运行结果可能并不一定按照优先级接序，例如笔者运行的结果如下;
D线程完成任务
B 线程完成任9
C 线程完成任9
从这个结果可以看出，优先级最大的 D线程是第一个完成的，优先级最小的 A 线程是最后一个完成的。但是，C 线程的优先级比 B 线程大，却仍然在 B 线程之后才完成，这是 CPU 的真实运行结果

20.6 线程同步
禅线程程序中，每次只能做一件事情，后面的事情需要等待前面的事情完成后才可以进行，

Java 从入门到精通(第6版)
是如果使用多线程程序，就会发生两个线程抢占资源的问题，如两个人同时说话、两个人同时过同个独木桥等。所以，在多线程编程中需要防止这些资源访问的冲突。Java 提供了线程同步的机制来止资源访问的冲突。
20.6.1线程安全
实际开发中，使用多线程程序的情况很多，如银行排号系统、火车站售票系统等。这种多线程的程序通常会发生问题，以火车站售票系统为例，在代码中判断当前票数是否大于 0，如果大于0则执行将该票出售给乘客的功能，但当两个线程同时访问这段代码时(假如这时只剩下一张票)，第一个线将票售出，与此同时第二个线程也已经执行完成判断是否有票的操作，并得出票数大于 0 的结论,于是它也执行售出操作，这样就会产生负数。所以，在编写多线程程序时，应该考虑到线程安全问题实质上线程安全问题来源于两个线程同时存取单一对象的数据。
例如，在项目中创建 ThreadSafeTest 类，该类实现了 Runnable 接口，在未考虑到线程安全问题基础上，模拟火车站售票系统的功能的代码如下:

package 线程;

public class ThreadSafeTest implements Runnable{
	int num=10;//设置当前总票数
	public void run() {
		while(true) {	//设置无限循环
			if(num>0) {//判断当前票数是否大于0
				try {
					Thread.sleep(100);//使当前线程休眠100毫秒
				}catch(InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"----票数"+num--);//票数减一
			}
		}
	}
	public static void main(String[] args) {
		ThreadSafeTest t=new ThreadSafeTest();//实例化类对象
		Thread tA=new Thread(t,"线程一");//以该类对象分别实例化四个线程
		Thread tB=new Thread(t,"线程二");
		Thread tC=new Thread(t,"线程三");
		Thread tD=new Thread(t,"线程四");//分别启动线程
		tA.start();
		tB.start();
		tC.start();
		tD.start();
	}

}

机制来防
线程的)则执行个线程徕蜘绔褒催隘，于问题。
问题的
第20章多线程
运行本实例，最后几行结果如图 20.9 所示。从这个结果可以看出，最后打印出的剩下的票数为负值，这样就出现了问题。这是由于同时创建了 4 个线程，这 4 个线程执行 run0方法，在 num 变量为1时，线程一、线程二、线程三、线程四都对 num 变量有存储功能，当线程一执行 run0方法时，还没有来得及做递减操作，就指定它调用 sleep0方法进入就绪状态，这时线程二、线程三和线程四也都进入了 run0方法，发现 num变量依然大于 0，但此时线程一休眠时间已到，将 num 变量值递减同时线程二、线程三、线程四也都对 num 变量进行递减操作，从而产生了负值。
20.6.2 线程同步机制
那么，该如何解决资源共享的问题呢?所有解决多线程资源冲突问题的方法基本上都是采用给定时间只允许一个线程访问共享资源的方法，这时就需要给共享资源上一道锁。这就好比一个人上洗手间时，他进入洗手间后会将门锁上，出来时再将锁打开，然后其他人才可以进入。
1.同步块
Java 中提供了同步机制，可以有效地防止资源冲突。同步机制使用 synchronized 关键字，使用该关键字包含的代码块称为同步块，也称为临界区，语法如下:

package 线程;

public class SynchronizedTest implements Runnable{
	int num=10;//设置当前总票数
	public void run() {
		while(true) {	//设置无限循环
			synchronized(this) {
			if(num>0) {//判断当前票数是否大于0
				try {
					Thread.sleep(100);//使当前线程休眠100毫秒
				}catch(InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"----票数"+num--);//票数减一
			}
		}
	}
	}
	public static void main(String[] args) {
		SynchronizedTest t=new SynchronizedTest();//实例化类对象
		Thread tA=new Thread(t,"线程一");//以该类对象分别实例化四个线程
		Thread tB=new Thread(t,"线程二");
		Thread tC=new Thread(t,"线程三");
		Thread tD=new Thread(t,"线程四");//分别启动线程
		tA.start();
		tB.start();
		tC.start();
		tD.start();
	}

}

从这个结果可以看出，打印到最后票数没有出现负数，这是因为将共享资源放置在了同步块中不管程序如何运行都不会出现负数。

2、同步方法
同步方法就是在方法前面用synchronized 关键字修饰的方法，其语法如下:
synchronized void f0
当某个对象调用了同步方法时，该对象上的其他同步方法必须等待该同步方法执行完毕后才董获行。必须将每个能访问共享资源的方法修饰为 synchronized，否则就会出错。修改剑20.7的代码，将共享资源操作放置在一个同步方法中，代码如下:
raum=10public synchronized void doit() (
//定义同步方法