JAVA核心：多线程

1. 线程简介

完全可以同时进行的活动在Java中被称为并发，而将并发完成的每一件事情称为线程。

一个线程则是进程中的执行流程，一个进程中可以同时包括多个线程，每个线程也可以得到一小段程序的执行时间，这样一个进程就可以具有多个并发执行的线程。

1. 进程是资源分配的最小单位，线程是最小的执行单位。
2. 一个进程可以有多个线程
3. 线程共享进程资源

2. 实现线程的两种方式

在Java中主要提供2种方式实现线程，分别为继承java.lang.Thread类与实现java.lang.Runnable接口。

2.1 继承 Thread 类

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

public Thread(String threadName);
public Thread();

其中第一个构造方法是创建一个名称为threadName的线程对象。
继承Thread类创建一个新的线程的语法如下：

public class ThreadTest extends Thread{
	//...
}

完成线程真正的功能代码放在类的run()方法中，当一个类继承Thread类后，就可以在该类中覆盖run()方法，将实现该线程功能的代码写入run()方法中，然后同时调用Thread类中的start()方法执行线程，也就是调用run()方法。

例子：

public class Demo {
	public static void main(String[] args) {
		Thread a = new ThreadA();
		a.start();// 线程对象的start方法
		Thread b = new ThreadB();
		b.start();
	}
}

class ThreadA extends Thread {// 线程
	@Override
	public void run() {
		for (int i = 0; i <= 10; i++) {
			System.out.println(i);
			try {
				Thread.sleep(200);// 休眠0.2秒
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

class ThreadB extends Thread {
	@Override
	public void run() {
		for (char i = 'a'; i <= 'l'; i++) {
			System.out.println(i);
			try {
				Thread.sleep(200);// 休眠0.2秒
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

运行得到结果：

0
a
1
b
2
c
3
d
4
e
5
f
6
g
7
h
8
i
9
j
10
k
l

可以看出来，线程对象a和b是使同时进行的。

2.2 实现 Runnable 接口

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

实现Runnable接口的语法如下：

public class Thread extends Object implements Runnable

如果我们需要继承其他类（非Thread类），而且还要使当前类实现多线程，那么可以通过Runnable接口来实现。


实现Runnable接口的程序会创建一个Thread对象，并将Runnable对象与Thread对象相关联。

例子：

import java.awt.Container;
import java.net.URL;
import java.security.DomainCombiner;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.SwingConstants;
import javax.swing.WindowConstants;

public class SwingAndThread extends JFrame implements Runnable {
	private JLabel jl = new JLabel();// 声明JLabel对象
	private Container container = getContentPane();// 声明容器

	public SwingAndThread() {
		setBounds(800, 800, 400, 400);// 绝对定位窗体大小与位置
		container.setLayout(null);// 使窗体不使用任何布局管理器
		try {
			URL url = SwingAndThread.class.getResource("1.gif");
			Icon icon = new ImageIcon(url);
			jl.setIcon(icon);
		} catch (NullPointerException ex) {
			System.out.println("图片不存在！");
			return;
		}
		// 设置图片在标签的最左边
		jl.setHorizontalAlignment(SwingConstants.LEFT);
		jl.setBounds(10, 50, 200, 50);
		jl.setOpaque(true);
		container.add(jl);
		setVisible(true);
		setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);// 设置窗体关闭方式
	}

	public static void main(String[] args) {
		SwingAndThread frame = new SwingAndThread();// 实例化一个SwingAndThread对象
		Thread t = new Thread(frame);
		t.start();
	}

	@Override
	public void run() {
		int count = 10;
		while (true) {
			jl.setBounds(count, 50, 200, 50);
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			} // 每移动一次停顿1秒
			count += 5;
			if (count >= 200) {
				count = 10;
			}
		}
	}
}

注意：启动一个新的线程，不是直接调用Thread子类对象的run()方法，而是调用Thread子类的start()方法，Thread类的start()方法产生一个新的线程，该线程运行Thread子类的run()方法。

3. 线程的生命周期

线程具有生命周期，其中包含7种状态，分别为出生状态、就绪状态、运行状态、等待状态、休眠状态、阻塞状态和死亡状态。出生状态就是用户在创建线程时处于的状态，在用户使用该线程实例调用start()方法之前线程都处于出生状态；当用户调用start()方法后，线程处于就绪状态（又被称为可执行状态）；当线程得到系统资源后就进入运行状态。

一旦线程进入可执行状态，它会在就绪与运行状态下转换，同时也有可能进入等待、休眠、阻塞或死亡状态。当处于运行状态下的线程调用Thread类中的wait()方法时，该线程便进入等待状态，进入等待状态的线程必须调用Thread类中的notify()方法才能被唤醒，而notify()方法时将所有处于等待状态下的线程唤醒；当线程调用Thread类中的sleep()方法时，则会进入休眠状态。如果一个线程在运行状态下发出输入/输出请求，该线程将进入阻塞状态，在其等待输入/输出结束时线程进入就绪状态，对于阻塞的线程来说，即使系统资源空闲，线程依然不能回到运行状态。当线程的run()方法执行完毕时，线程进入死亡状态。

7状态示意图：

5状态示意图：

4. 操作线程的方法

4.1 线程的休眠

一种能控制线程行为的方法是调用sleep()方法，sleep()方法需要一个参数用于指定该线程休眠的时间，该时间使用毫秒为单位。在前面的实例中已经演示过sleep()方法，它通常是在run()方法内的循环中被使用。

sleep()方法的语法如下：

try{
    Thread.sleep(2000);
}catch(InterruptedException e){
	e.printStackTrace();
}

public class Demo {
	public static void main(String[] args) {
		for(int i=0;i<100;i++) {
			System.out.println(i);
			try {
				Thread.sleep(250);// 让程序停顿的效果
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

4.2 线程的加入

如果当前某程序为多线程程序，假如存在一个线程A，现在需要插入线程B，并要求线程B先执行完毕，然后再继续执行线程A，此时可以使用Thread类中的join()方法来完成。

当某个线程使用join()方法加入到另外一个线程时，另一个线程会等待该线程执行完毕再继续执行。

例子：

import java.awt.BorderLayout;

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

public class JoinTest extends JFrame {
	private static final long serialVersionUID = 1L;
	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) {
		init(new JoinTest(), 200, 100);
	}

	public JoinTest() {
		super();
		// 将进度条设置在窗体最北面
		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() {// 重写run()方法
				while (true) {
					progressBar.setValue(++count);// 设置进度条的当前值
					try {
						Thread.sleep(100);// 使线程A休眠100毫秒
						threadB.join();// 线程B加入线程A当中
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
			}
		});
		threadA.start();// 启动线程A

		threadB = new Thread(new Runnable() {
			int count = 0;

			public void run() {// 重写run()方法
				while (true) {
					progressBar2.setValue(++count);// 设置进度条的当前值
					try {
						Thread.sleep(100);// 使线程B休眠100毫秒
					} catch (Exception e) {
						e.printStackTrace();
					}
					if (count == 100) {// 当count变量增长为100时
						break;// 跳出循环
					}
				}
			}
		});
		threadB.start();// 启动线程B
	}

	public static void init(JFrame frame, int width, int height) {
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setSize(width, height);
		frame.setVisible(true);
	}
}

运行结果如下图：

4.3 线程的中断

在以往时候会使用stop()方法停止线程，但当前版本的JDK早已废除了stop()方法，同时也不建议使用stop()方法来停止一个线程的运行。现在提倡在run()方法中使用无限循环的形式，然后使用一个布尔型标记控制循环的停止。

如果线程是因为使用了sleep()或者wait()方法进入了就绪状态，可以使用Thread类中interrupt()方法使线程离开run()方法，同时结束线程，但程序会抛出InterruptedException异常，用户可以在处理该异常时完成线程的中断业务处理，如终止while循环。

import java.awt.BorderLayout;

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

public class InterruptedSwing extends JFrame {
	Thread thread;

	public static void main(String[] args) {
		init(new InterruptedSwing(), 100, 100);

	}

	public InterruptedSwing() {
		super();
		final JProgressBar progressBar = new JProgressBar();// 创建进度条
		getContentPane().add(progressBar, BorderLayout.NORTH);// 将进度条放置在窗体北面
		progressBar.setStringPainted(true);// 设置进度条上显示数字
		thread = new Thread(new Runnable() {
			int count = 0;

			@Override
			public void run() {
				while (true) {
					progressBar.setValue(++count);
					try {
						thread.sleep(50);// 使线程休眠1000毫秒
						if (count == 49) {
							thread.interrupt();// 中断线程
						}
					} catch (InterruptedException e) {// 捕捉InterruptedException异常
						System.out.println("当前线程序被中断");
						break;
					}
				}
			}
		});
		thread.start();// 启动线程
	}

	public static void init(JFrame frame, int width, int height) {
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setSize(width, height);
		frame.setVisible(true);
	}

}

运行结果：

4.4 线程的礼让

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

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

5. 线程的优先级

每个线程都具有各自的优先级，线程的优先级可以在程序中表明该线程的重要性，如果有很多线程处于就绪状态，系统会根据优先级来决定首先使哪个线程进入运行状态。但这并不意味着低优先级的线程得不到运行，而只是它运行的几率比较小，比如垃圾回收线程的优先级就较低。

Thread类中包含的成员变量代表了线程的某些优先级，比如Thread.MIN_PRIORITY（常数1）、Thread.MAX_PRIORITY（常数2）、Thread.NORM_PRIORITY（常数5）。其中每个线程的优先级都在Thread.MIN_PRIORITY~Thread.MAX_PRIORITY之间，在默认情况下其优先级都是Thread.NORM_ PRIORITY。每个新产生的线程都继承了父线程的优先级。

例子：

public class Demo {
	public static void main(String[] args) {
		for (int i = 0; i < 5; i++) {
			MyThread t1 = new MyThread("加", "+");
			t1.setPriority(Thread.MIN_PRIORITY);
			MyThread t2 = new MyThread("减", "-");
			t2.setPriority(3);
			MyThread t3 = new MyThread("乘", "*");
			t3.setPriority(8);
			MyThread t4 = new MyThread("除", "/");
			t4.setPriority(Thread.MAX_PRIORITY);
			t1.start();
			t2.start();
			t3.start();
			t4.start();
		}

	}
}

class MyThread extends Thread {

	String name;
	String output;

	MyThread(String name, String output) {
		this.name = name;
		this.output = output;
	}

	@Override
	public void run() {
		System.out.println(name + ":" + output);
	}
}

运行结果：

加:+
加:+
加:+
乘:*
除:/
除:/
减:-
乘:*
除:/
乘:*
减:-
减:-
加:+
除:/
乘:*
加:+
除:/
乘:*
减:-
减:-

可以看到，设置优先级效果并不明显。

6. 线程同步

在单线程程序中，每次只能做一件事情，后面的事情需要等待前面的事情完成后才可以进入，但是如果使用多线程程序，就会发生两个线程抢占资源的问题。所以在多线程编程中需要放在这些资源访问的冲突。

6.1 线程安全

实际开发中，使用多线程程序的情况很多，如银行排号系统、火车站售票系统等。这种多线程的程序通常会发生问题，以火车站售票系统为例，在代码中判断当前票数是否大于0，如果大于0则执行将该票出售给乘客功能，但当两个线程同时访问这段代码时（假如这时只剩下一张票），第一个线程将票售出，与此同时第二个线程也已经执行完成判断是否有票的操作，并得出结论票数大于0，于是它也执行售出操作，这样就会产生负数。所以在编写多线程程序时，应该考虑到线程安全问题。实质上线程安全问题来源于两个线程同时存取单一对象的数据。

public class Demo implements Runnable {
	int num = 10;// 票池

	public static void main(String[] args) {
		Demo d = new Demo();
		Thread t1 = new Thread(d, "线程1");
		Thread t2 = new Thread(d, "线程2");
		Thread t3 = new Thread(d, "线程3");
		Thread t4 = new Thread(d, "线程4");
		t1.start();
		t2.start();
		t3.start();
		t4.start();

	}

	@Override
	public void run() {
		while (true) {
			if (num > 0) {
				System.out.println("票数：" + num--);
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

运行结果：

6.2 线程同步机制

如何解决资源共享的问题？基本上所有解决多线程资源冲突问题都会采用给定时间只允许一个线程访问共享资源，这时就需要给共享资源上一道锁。这就好比一个人上洗手间，这个人进入洗手间后将门锁上，当他出来时再将锁打开，然后其他人才可以进入。

6.2.1 同步块

在Java中提供了同步机制，可以有效地防止资源冲突。同步机制使用Synchronized关键字。

继续使用上面的例子：

public class Demo implements Runnable {
	int num = 10;// 票池

	public static void main(String[] args) {
		Demo d = new Demo();
		Thread t1 = new Thread(d, "线程1");
		Thread t2 = new Thread(d, "线程2");
		Thread t3 = new Thread(d, "线程3");
		Thread t4 = new Thread(d, "线程4");
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}

	@Override
	public void run() {
		while (true) {
			synchronized (this) {// 同步代码块
				if (num > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println("票数：" + num--);
				}
			}
		}
	}
}

运行结果：

票数：10
票数：9
票数：8
票数：7
票数：6
票数：5
票数：4
票数：3
票数：2
票数：1

6.2.2 同步方法

此外，我们可以将代码改为同步的方法：

public class Demo implements Runnable {
	int num = 10;// 票池

	public static void main(String[] args) {
		Demo d = new Demo();
		Thread t1 = new Thread(d, "线程1");
		Thread t2 = new Thread(d, "线程2");
		Thread t3 = new Thread(d, "线程3");
		Thread t4 = new Thread(d, "线程4");
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}

	public synchronized void sell() {// 线程同步方法
		if (num > 0) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("票数：" + num--);
		}
	}

	@Override
	public void run() {
		while (true) {
			sell();
		}
	}
}

运行结果：

票数：10
票数：9
票数：8
票数：7
票数：6
票数：5
票数：4
票数：3
票数：2
票数：1

如果将Synchronized关键字删除，则又会出现脏数据。