线程是什么?
一个程序或进程能够包含多个线程,这些线程可以根据程序的代码执行相应的指令。多线程看上去似乎在并行执行它们各自的工作,就像在一台计算机上运行着多个处理机一样。在多处理机计算机上实现多线程时,它们确实 可以并行工作。和进程不同的是,线程共享地址空间。也就是说,多个线程能够读写相同的变量或数据结构。编写多线程程序时,你必须注意每个线程是否干扰了其他线程的工作
Thread
类(或其子类)的对象,并给这个对象发送 start()
消息。每个线程动作的定义包含在该线程对象的 run()
方法中。run 方法就相当于传统程序中的 main()
方法;线程会持续运行,直到 run()
返回为止,此时该线程便结束了。
上锁
大多数应用程序要求线程互相通信来同步它们的动作。在 Java 程序中最简单实现同步的方法就是上锁。为了防止同时访问共享资源,线程在使用资源的前后可以给该资源上锁和开锁。给共享变量上锁就使得 Java 线程能够快速方便地通信和同步。某个线程若给一个对象上了锁,就可以知道没有其他线程能够访问该对象。即使在抢占式模型中,其他线程也不能够访问此对象,直到上锁的线程被唤醒、完成工作并开锁。那些试图访问一个上锁对象的线程通常会进入睡眠状态,直到上锁的线程开锁。一旦锁被打开,这些睡眠进程就会被唤醒并移到准备就绪队列中。
在 Java 编程中,每个的对象会有一个锁。线程可以使用 synchronized
关键字来获得锁。在任一时刻对于给定的类的实例,所有同步方法或同步代码块只能被一个线程执行因为代码在执行之前要求获得对象的锁。
为了避免复印冲突,我们可以简单地对复印资源实行同步。如同下列的代码例子,任一时刻只允许一位职员使用复印资源。通过使用方法(在 Copier
对象中)来修改复印机状态。这个方法就是同步方法。只有一个线程能够执行一个 Copier
对象中同步代码,因此那些需要使用 Copier
对象的职员就必须排队等候。
class CopyMachine { public synchronized void makeCopies(Document d, int nCopies) { //only one thread executes this at a time } public void loadPaper() { //multiple threads could access this at once! synchronized(this) { //only one thread accesses this at a time //feel free to use shared resources, overwrite members, etc. } } } |
Fine-grain 锁
在对象级使用锁通常是一种比较粗糙的方法。为什么要将整个对象都上锁,而不允许其他线程短暂地使用对象中其他同步方法来访问共享资源?如果一个对象拥有多个资源,就不需要只为了让一个线程使用其中一部分资源,就将所有线程都锁在外面。由于每个对象都有锁,可以如下所示使用伪对象来上锁:
class FineGrainLock { MyMemberClass x, y; Object xlock = new Object(), ylock = new Object(); public void foo() { synchronized(xlock) { //access x here } //do something here - but don't use shared resources synchronized(ylock) { //access y here } } public void bar() { synchronized(this) { //access both x and y here } //do something here - but don't use shared resources } } |
这些方法不需要在方法级别上通过对整个方法使用synchronized关键字来被设置成同步的。它们使用的是成员锁(伪对象上的锁),而不是 synchronized 方法所获得的对象级锁。
常见的上锁问题
不幸的是,使用上锁会带来其他问题。让我们来看一些常见问题以及相应的解决方法:
- 死锁。 死锁是一个经典的多线程问题,因为不同的线程都在等待那些根本不可能被释放的锁,从而导致所有的工作都无法完成。假设有两个线程,分别代表两个饥饿的人,他们必须共享刀叉并轮流吃饭。他们都需要获得两个锁:共享刀和共享叉的锁。假如线程 "A" 获得了刀,而线程 "B" 获得了叉。线程 A 就会进入阻塞状态来等待获得叉,而线程 B 则阻塞来等待 A 所拥有的刀。这只是人为设计的例子,但尽管在运行时很难探测到,这类情况却时常发生。虽然要探测或推敲各种情况是非常困难的,但只要按照下面几条规则去设计系统,就能够避免死锁问题:
-
让所有的线程按照同样的顺序获得一组锁。这种方法消除了 X 和 Y 的拥有者分别等待对方的资源的问题。
-
将多个锁组成一组并放到同一个锁下。前面死锁的例子中,可以创建一个银器对象的锁。于是在获得刀或叉之前都必须获得这个银器的锁。
-
将那些不会阻塞的可获得资源用变量标志出来。当某个线程获得银器对象的锁时,就可以通过检查变量来判断是否整个银器集合中的对象锁都可获得。如果是,它就可以获得相关的锁,否则,就要释放掉银器这个锁并稍后再尝试。
-
最重要的是,在编写代码前认真仔细地设计整个系统。多线程是困难的,在开始编程之前详细设计系统能够帮助你避免难以发现死锁的问题。
-
- Volatile 变量.
volatile
关键字是 Java 语言为优化编译器设计的。以下面的代码为例:class VolatileTest { public void foo() { boolean flag = false; if(flag) { //this could happen } } }
一个优化的编译器可能会判断出
if
部分的语句永远不会被执行,就根本不会编译这部分的代码。如果这个类被多线程访问,flag
被前面某个线程设置之后,在它被if
语句测试之前,可以被其他线程重新设置。用volatile
关键字来声明变量,就可以告诉编译器在编译的时候,不需要通过预测变量值来优化这部分的代码。 - 无法访问的线程 有时候虽然获取对象锁没有问题,线程依然有可能进入阻塞状态。在 Java 编程中 IO 就是这类问题最好的例子。当线程因为对象内的 IO 调用而阻塞时,此对象应当仍能被其他线程访问。该对象通常有责任取消这个阻塞的 IO 操作。造成阻塞调用的线程常常会令同步任务失败。如果该对象的其他方法也是同步的,当线程被阻塞时,此对象也就相当于被冷冻住了。其他的线程由于不能获得对象的锁,就不能给此对象发消息(例如,取消 IO 操作)。必须确保不在同步代码中包含那些阻塞调用,或确认在一个用同步阻塞代码的对象中存在非同步方法。尽管这种方法需要花费一些注意力来保证结果代码安全运行,但它允许在拥有对象的线程发生阻塞后,该对象仍能够响应其他线程。
资源共享
在协作式模型中,是否能保证线程正常放弃处理器,不掠夺其他线程的执行时间,则完全取决于程序员。调用 yield()
方法能够将当前的线程从处理器中移出到准备就绪队列中。另一个方法则是调用sleep()
方法,使线程放弃处理器,并且在 sleep 方法中指定的时间间隔内睡眠。
如果线程正拥有一个锁(因为它在一个同步方法或代码块中),则当它调用 yield()
时不能够释放这个锁。这就意味着即使这个线程已经被挂起,等待这个锁释放的其他线程依然不能继续运行。为了缓解这个问题,最好不在同步方法中调用 yield
方法。将那些需要同步的代码包在一个同步块中,里面不含有非同步的方法,并且在这些同步代码块之外才调用 yield
。
另外一个解决方法则是调用 wait()
方法,使处理器放弃它当前拥有的对象的锁。如果对象在方法级别上使同步的,这种方法能够很好的工作。因为它仅仅使用了一个锁。如果它使用 fine-grained 锁,则wait()
将无法放弃这些锁。此外,一个因为调用 wait()
方法而阻塞的线程,只有当其他线程调用 notifyAll()
时才会被唤醒。
(See http://www.ibm.com/developerworks/cn/java/j-thread/)
---------------------------------------------------------------------------------------------------------------------------------------------------------------------
创建线程和启动线程并不相同
在一个线程对新线程的Thread对象调用start()方法之前,这个新线程并没有真正开始执行。Thread对象在其线程真正启动之前就已经存在了,而且其线程退出之后仍然存在。这可以让您控制或获取关于已创建的线程的信息,即使线程还没有启动或已经完成了。
通常在构造器中通过start()启动线程并不是好主意。这样做,会把部分构造的对象暴露给新的线程。如果对象拥有一个线程,那么它应该提供一个启动该线程的start()或init()方法,而不是从构造器中启动它。
结束Java线程
结束Java线程
Java线程会以以下三种方式之一结束:
1. Java线程到达其run()方法的末尾。
2. Java线程抛出一个未捕获到的Exception或Error。
3. 另一个Java线程调用一个弃用的stop()方法。弃用是指这些方法仍然存在,但是您不应该在新代码中使用它们,并且应该尽量从现有代码中除去它们。
当Java程序中的所有线程都完成时,程序就退出了。
加入Java线程
ThreadAPI包含了等待另一个线程完成的方法:join()方法。当调用Thread.join()时,调用线程将阻塞,直到目标线程完成为止。
Thread.join()通常由使用线程的程序使用,以将大问题划分成许多小问题,每个小问题分配一个线程。创建了线程并启动它们,然后使用Thread.join()等待它们全部完成。
Thread[] threads =
new Thread[5 ];for ( int i=0; i<5 ; i++){
MyProcessor proc = new MyProcessor ();
threads[i] = new Thread(proc , "" + i);
threads[i].start();
}
for(int i=0; i<5; i++){
try {
threads[i].join();
} catch (InterruptedException ie) {
logger.warn("InterruptedException happened!", ie);
}
}
休眠
ThreadAPI包含了一个sleep()方法,它将使当前线程进入等待状态,直到过了一段指定时间,或者直到另一个线程对当前线程的Thread对象调用了Thread.interrupt(),从而中断了线程。当过了指定时间后,线程又将变成可运行的,并且回到调度程序的可运行线程队列中。
如果线程是由对Thread.interrupt()的调用而中断的,那么休眠的线程会抛出InterruptedException,这样线程就知道它是由中断唤醒的,就不必查看计时器是否过期。
Thread.yield()方法就象Thread.sleep()一样,但它并不引起休眠,而只是暂停当前线程片刻,这样其它线程就可以运行了。在大多数实现中,当较高优先级的线程调用Thread.yield()时,较低优先级的线程就不会运行。
守护程序线程
任何线程都可以变成守护程序线程。可以通过调用Thread.setDaemon()方法来指明某个线程是守护程序线程。您也许想要使用守护程序线程作为在程序中创建的后台线程,如计时器线程或其它延迟的事件线程,只有当其它非守护程序线程正在运行时,这些线程才有用。
获取所有线程
Thread.enumerate(Thread[] tarray) 会将在当前线程的线程组和子线程组中的活动线程放到指定的数组中。 从而,你可通过遍历数组来查看每个线程的状态。
线程组
线程是被个别创建的,但可以将它们归类到线程组中,以便于调试和监视。只能在创建线程的同时将它与一个线程组相关联。在使用大量线程的程序中,使用线程组组织线程可能很有帮助。可以将它们看作是计算机上的目录和文件结构。
限制线程优先级和调度
Java 线程模型涉及可以动态更改的线程优先级。本质上,线程的优先级是从 1 到 10 之间的一个数字,数字越大表明任务越紧急。JVM 标准首先调用优先级较高的线程,然后才调用优先级较低的线程。但是,该标准对具有相同优先级的线程的处理是随机的。如何处理这些线程取决于基层的操作系统策略。在某些情况下,优先级相同的线程分时运行;在另一些情况下,线程将一直运行到结束。请记住,Java 支持 10 个优先级,底层操作系统支持的优先级可能要少得多,这样会造成一些混乱。因此,只能将优先级作为一种很粗略的工具使用。最后的控制可以通过明智地使用 yield() 函数来完成。通常情况下,请不要依靠线程优先级来控制线程的状态。
主要分三个级别,高中低.分别代表的数字是10.5.1分别有三个常量代表不可以被改变。最小优先级的常量是MIN_PRIORITY,普通的优先级的常量是NORM_PRIORITY,最高的优先级的常量是MAX_PRIORITY一般主线程的优先级是普通,另外可以通过Thread类的setPriority(int a)方法来修改系统自动设置的线程优先级。
线程间发信
Object类提供了三个函数:wait()、notify() 和 notifyAll()。以全球气候预测程序为例。这些程序通过将地球分为许多单元,在每个循环中,每个单元的计算都是隔离进行的,直到这些值趋于稳定,然后相邻单元之间就会交换一些数据。所以,从本质上讲,在每个循环中各个线程都必须等待所有线程完成各自的任务以后才能进入下一个循环。这个模型称为 屏蔽同步,下例说明了这个模型:
屏蔽同步
public class BSync {
int totalThreads;
int currentThreads;
public BSync(int x) {
totalThreads = x;
currentThreads = 0;
}
public synchronized void waitForAll() {
currentThreads++;
if(currentThreads < totalThreads) {
try {
wait();
} catch (Exception e) {}
}
else {
currentThreads = 0;
notifyAll();
}
}
}
当对一个线程调用 wait() 时,该线程就被有效阻塞,只到另一个线程对同一个对象调用 notify() 或 notifyAll() 为止。因此,在前一个示例中,不同的线程在完成它们的工作以后将调用 waitForAll() 函数,最后一个线程将触发 notifyAll() 函数,该函数将释放所有的线程。第三个函数 notify() 只通知一个正在等待的线程,当对每次只能由一个线程使用的资源进行访问限制时,这个函数很有用。但是,不可能预知哪个线程会获得这个通知,因为这取决于 Java 虚拟机 (JVM) 调度算法。
线程也是有状态和生命周期的
每个Java程序都会有一个缺省的主线程,对于应用程序applcation来说main方法就是一个主线程.
创建一个新的线程的生命周期如下状态:
1) 新建: 当一个Thread类或者其子类的对象被声明并创建时,新的线程对象处于新建状态,此时它已经有了相应的内存空间和其他资源.
2) 就绪: 处于新建状态的线程被启动后,将进入线程队列排队等待CUP服务,这个时候具备了运行的条件,一旦轮到CPU的时候,就可以脱离创建它的主线程独立开始自己的生命周期.
3) 运行: 就绪的线程被调度并获得CUP的处理边进入了运行状态,每一个Thread类及其子类的对象都有一个重要的run()方法,当线程对象被调度执行的时候,它将自动调用本对象的run()方法,从第一句代码开始执行。所以说对线程的操作应该写到run()方法中.
4) 阻塞: 一个正在执行的线程如果再某种情况下不能执行了.进入阻塞状态,这个时候它不能进入排队状态,只有引起了阻塞的原因消失的时候,线程才可以继续进入排队状态等待CUP处理。
5) 死亡: 处于死亡状态的线程不具有继续执行的能力,线程死亡主要的原因是正常运行的线程完成了全部工作,即执行完了run()方法,另外就是被提前强制的终止了。
释放锁
1)如果一个线程一直占用一个对象的锁,则其他的线程将永远无法访问该对象,因此,需要在适当的时候,将对象锁归还。
2)当线程执行到synchronized()块结束时,释放对象锁。
3)当在synchronized()块中遇到break, return或抛出exception,则自动释放对象锁。
4)当一个线程调用wait()方法时,它放弃拥有的对象锁并进入等待队列。