亚洲真人无码永久在线观看,亚洲国产精品成人精品无码区 ,亚洲乱码国产一区三区

Evan — Sat, 11 Mar 2006 15:11:00 GMT

摘要: 《Java Threads》的�W?章“Minimal Synchronization Techniques”，是这本书中到现在我认为最差的一章了�Q�当然主要是我不喜欢JDK 1.5新推出的Atomic Class�Q�而这一章却�׃��不少��章来介�l�，且牵强地攚w��打字程序，又语焉不详地指出�q�种攚w��的困难之处和可能带来的副作用，但却又不能从代码的实际运行中看到�q�种副作用，很有误导初学者的嫌疑。不�q�，我想�Q�没有哪个初学者会冒风险�ؓ了用Atomic Class而将原本��单明了的��法攚w��得如此晦�ӆ难懂�Q��ƈ且还有潜在的出错风险。所以，对于Atomic Class�Q�我��跌��不读�Q�绝�Ҏ(gu��)��有什么损失。不�q�对于其中�?.1.3 Double-Checked Locking”和�?.3 Thread Local Variables”这两节倒要着重读一读，��其是Thread Local�Q�应该说是Java中一个比较重要的多线�E�工兗��?nbsp; 阅读全文

Evan 2006-03-11 23:11 发表评论

Evan — Thu, 09 Mar 2006 14:11:00 GMT

看到《Java Threads》第5章，介绍了JDK 1.5新加的一些所谓原子类(Atomic Classes)�Q��L��觉有点�ؓ原子而原子，实际操作中，又有多少��Z��Z��许的性能提升而刻意去用这些别扭的操作而放弃直观的synchronize关键字或者Lock�c�d��Q�不�q�，�q�里不是惌��个，而是当其用Atomic Classes来改造它的打字程序后�Q�解释用原子�c�d��是保证类似递增、递减、赋值等操作的原子性，而不能保证其所在的�Ҏ(gu��)��一定是�U�程安全的，然后��_��有可能按键事件的处理可能需要等待resetScore()处理完才能执行，而这会导致错误的评分�Q�被当成多敲了键�Q�。由于前几章的内容相�Ҏ(gu��)��较简单易懂，所以也没有很仔�l�的�q�行那些例子。这里�ؓ了验证一下，��p��行了一下第4章的例子�Q�然后发玎ͼ�基本上第一�ơ的评分��L��错的。这��引起了我的注意�Q�因为，一般情况下�Q�如果是race condition��D��的错误是很难重现的，�q�么明显的错误很可能是程序逻辑上的错误。仔�l�看了一下代码，发现在start按钮的事件处理方法里�Q�有下面�q�样一�D�代码：

startButton.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent evt) {
                displayCanvas.setDone(false);
                producer.setDone(false);
                startButton.setEnabled(false);
                stopButton.setEnabled(true);
                feedbackCanvas.setEnabled(true);
                feedbackCanvas.requestFocus();
                score.resetScore();
            }
        });

注意重置成�W的调用放在了最后，此时�Q�随机生成字�W�的�U�程应该被唤醒�ƈ产生了第一个字�W�，然后�Q�resetScore()��需要输入的字符又设成了-1�Q�所以，当你�W�一�ơ输入字�W�时�Q��L��被认为是多击了一�ơ键而扣1�?(。既然这��P��那停止然后再启动也应该会发生�q�个错误啊。而事实上的确是这栗��我惻I��q�不应该看做是race condition吧，有什么样的同步技术能够避免这个问题呢�Q�除非另外弄个标志，当成�l�没有被重置前，不能产生�W�一个字�W�。当�Ӟ��q�是不需要的�Q�只要将score.resetScore()攑ֈ��W�一句就可以了�?br />
然后又运行了�W?章的例子�Q�发现基本上没有�q�个问题。难道第3章的代码是正��的�Q�打开源代码一看，重置成�W的方法还是放在最后，那这里�ؓ什么又是正��的呢？我想�Q�大�U�是�W?章的例子中，每次点击start按钮�Q�都重新创徏一个线�E�对象的原因吧。由于创建对象和初始化线�E�需要一定的旉��Q�刚好给了主�U�程重置成�W的机会�?br />
不知道作者有意�ؓ之呢�Q�还是疏忽，不过�Q�这��L(f��ng)��错误不能��是race condition的例子�?img src ="http://www.tkk7.com/evanwhj/aggbug/34556.html" width = "1" height = "1" />

Evan 2006-03-09 22:11 发表评论

Evan — Mon, 06 Mar 2006 14:21:00 GMT

�W?�?/a>主要介绍了数据的同步(Data Synchronization)�Q�这一章则主要介绍�U�程之间的同步方�?Thread Notification)�Q�同样包括传�l�的wait-and-notify�Ҏ(gu��)��和JDK 1.5新推出的Condition Variable。在多线�E�编�E�中�Q�数据同步和�U�程同步是两个最基本也是最关键的部分�?br />《Java Threads》一书中通过考察打字�E�序中当按下start和stop按钮后，每次都创��Z��个新的线�E�的效率问题来引入线�E�同步的概念�Q�当然不是线�E�同步的主要用处。不�q�，教科书归教科书，实际�q�用则又是另一回事。所以，通过书本学习语法�Q�通过实践来获得运用经验�?br />

4.1 Wait and Notify

1. �{�待/唤醒�c�M��于Solaris或POSIX中的条�g变量(conditon variables)�Q�或者Windows中的事�g变量(evant variable)或者信号量(signal)�Q�用于某�?多个�U�程暂停�{�待某个条�g的满��I��而该条�g��由其它�U�程来设�|�的情况�?br />2. 在Java中，��像每个对象有一个锁之外�Q��Q何对象都可以提供�{�待/唤醒的机制。就像Java中的synchronized��L��表示获得某个具体对象的锁一��P��wait和notify也��L��{�待某个具体的对象，�q�由该对象唤醒；同样�Q�获得某个对象上的锁不一定是该对象需要同步一��P��{�待和唤醒的条�g也不一定是与之�l�定的对象�?br />3. Java中wait-and-notify的几个方法：

void wait(): 使当前线�E�处于等待状态，直到其它�U�程调用了nofity()或者notifyAll()�Ҏ(gu��)��为止�?br />void wait(long timeout): 使当前线�E�处于等待状态，直到其它�U�程调用了nofity()或者notifyAll()�Ҏ(gu��)��Q�或者超�q�了指定的时�?单位为ms)为止
void wait(long timeout, int nanos)�Q�与wait(long)一��P��只是在某些JVM中可以精��到奈秒�?br />void notify(): 唤醒一�?/font>正在�{�待该对象的�U�程�?br />void notifyAll(): 唤醒所�?/font>正在�{�待该对象的�U�程�?

注意�Q?strong>��M��{�待和唤醒方法都必须在与之对应的对象的同步方法或同步块里调用�?/strong>卻I��wait-and-notify必须和与之对应的synchronized关键词一起��用的�?br />4. wait()和sleep()的主要区别：
　　1) sleep()可以在�Q何地方调用，而wait()需要在同步�Ҏ(gu��)��或同步块中调用；
　　2) �q�入wait()函数�Ӟ��JVM会自动释��N��Q�而当从wait()�q�回卌��唤醒�Ӟ��又会自动获得锁；而sleep()没有�q�个功能�Q�因此如果在wait()的地方用sleep()代替�Q�则会导致相应的nofity()�Ҏ(gu��)��在等待时不可能被触发�Q�因为notify()必须在相应的同步�Ҏ(gu��)��或同步块中，而此时这个锁却被sleep()所在的�Ҏ(gu��)��占用。也��是��_��wait-and-notify不可能与sleep()同时使用�?br />
4.1.1 The Wait-and-Notify Mechanism and Synchronization
1. �q�一节详�l�的讲解了wait-and-notify机制和synchronized的关�p�，主要是两点：1)wait-and-notify必须和synchronized同时使用�Q?)wait()会自动释攑֒�获取锁；
2. �q�一节中举了一个例子用来解释可能存在当条�g被不满��时也有可能被唤醒的情况：

　　1) �U�程T1调用一个同步方法；
　　2) T1��状态变量，发现其不满��条�g�Q?br />　　3) T1调用wait()�Q��ƈ释放锁；
　　4) �U�程T2调用另外一个同步方法，获得锁；
　　5) �U�程T3调用另外一个同步方法，�׃��T2获得了锁�Q�所以处于等待状态；
　　6) T2修改状态变量，使其满��条�g�Q��ƈ调用notify()�Ҏ(gu��)��Q?br />　　7) T3获得锁，然后处理数据�Q��ƈ��状态变量又讄��Z��满��条�g的状态；
　　8) T3处理完毕�q�回�Q?br />　　9) T1被唤醒，但实际上此时条�g�q�不满��?

�q�个例子刚好印证了《Effective Java》中"Item 50: Never invoke wait outside a loop"和《Practical Java》中"实践54�Q�针对wait()和notifyAll()使用旋锁(spin locks)"。即��L��用下面这�U�方式来调用wait():

    synchronized(obj) {
while()
wait();


... // Perform action appropriate to condition
}

或者象《Practical Java》中一��P��

    synchronized(obj) {
while() {
try {
wait();
} catch (InterruptedException e) {}
}


... // Perform action appropriate to condition
}

3. 调用wait()的线�E�T可能在以下几�U�情况被唤醒�Q?br />　　1) 其它�U�程调用了notify()�Q�而刚好线�E�T得到了通知�Q?br />　　2) 其它�U�程调用了notifyAll()�Q?br />　　3) 其它�U�程中断了线�E�T�Q?br />　　4) �׃��JVM的原因，��D��了spurious wakeup�?br />
4.1.2 wait(), notify(), and notifyAll()
1. 正像多个�U�程�{�待同一对象上的锁，当锁释放�Ӟ��无法��定哪个�U�程会得到那个锁一��P��当有多个�U�程在wait()�Ӟ��当另外一个线�E�调用nofity()的时候，也不能确定哪个线�E�会被唤醒； 2. 因此在《Practical Java》的"实践53�Q�优先��用notifyAll()而非notify()"��的一��P��l�合实践54�Q�可以比较好的解决线�E�唤醒的问题�?br />
4.1.3 Wait-and-Notify Mechanism with Synchronized blocks
再次��必须在同一个对象的synchronized�Ҏ(gu��)��或块内调用该对象上的wait和notify�Ҏ(gu��)��?br />

4.2 Condition Variables

1. ��像上面反复��的一��P��wait-and-notify机制是与特定对象及其上的锁是�l�定在一��L(f��ng)��Q�锁和唤醒对象不能分开�Q�这在某些情况下不是很方便；
2. JDK 1.5提供Condition接口来提供与其它�pȝ��几乎一致的condition variables机制�Q?br />3. Condition对象由Lock对象的newCondition()�Ҏ(gu��)��生成�Q�从而允�怸�个锁产生多个条�g变量�Q�可以根据实际情冉|��{�待不同条�g�Q?br />4. 该书的例子没有什么特别的实际意义�Q�但JDK 1.5文档中提供了一个例子，能充分说明��用Condition Variables使得�E�序更加清晰易读�Q�也更有效率�Q?

class BoundedBuffer {
    final Lock lock = new ReentrantLock();
    final Condition notFull  = lock.newCondition(); 
    final Condition notEmpty = lock.newCondition();
final Object[] items = new Object[100];
int putptr, takeptr, count;


public void put(Object x) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length) 
            notFull.await();
            items[putptr] = x; 
            if (++putptr == items.length) putptr = 0;
            ++count;
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

public Object take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0) 
                notEmpty.await();
            Object x = items[takeptr]; 
            if (++takeptr == items.length) takeptr = 0;
            --count;
            notFull.signal();
            return x;
        } finally {
            lock.unlock();
        }
    } 
}

具体的说明请参考JDK 1.5的文档�?br />5. 除了用lock和await-and-signal来代替synchronized和wait-and-notify外，其语义和机制基本一栗��await()在进入前也会自动释放锁，然后再返回前重新获得锁；
6. 使用Condition Variables的原因：
　　1) 如果使用Lock对象�Q�则必须使用condition variables�Q?br />　　2) 每个Lock对象可以创徏多个condition variable.

Evan 2006-03-06 22:21 发表评论

Evan — Sun, 05 Mar 2006 15:25:00 GMT

Chapter 3. Data synchronization

�?a >�W�二�?/a>中介�l�了如何创徏�U�程对象、启动和�l�止�U�程。但多线�E�编�E�的关键在于多个�U�程之间数据的共享和同步�Q�从�q�一章开始，��详�l�介�l�线�E�之间数据的�׃�n和同步的各种�Ҏ(gu��)��?br />
3.1 The Synchronized Keywor
1. synchronized是Java中最基本也最常用的用来编写多�U�程安全代码的关键字�Q�用以保护对多线�E�共享的数据的操作��L��完整的；
2. Atomic: 当一个操作被定义成原子操作时�Q�意味着该操作在执行�q�程中不会被打断�Q�原子操作可以由��g保证或者通过软�g来模拟；
3. Mutex Lock: 在很多多�U�程�pȝ��Q�通过互斥锁来保护的共享数据。Java中的��M��一个对象都有一个与之相关的锁，当一个方法被声明成synchronized�Ӟ��p��C�当�U�程�q�入该方法前�Q�必��获得相应对象的锁，在执行完毕再释放�q�个锁。从而保证同一时刻只有一个线�E�调用该对象上的被声明�ؓsynchronized的方法。注意：Java的互斥锁只能加在对象�U�上�Q�获得某个对象的锁，�q�不能保证该对象的属性和其它非synchronized的方法是�U�程安全的；也不能保证受保护的方法里调用的其它对象是多线�E�安全的�Q�除非�Q何调用这些没有被保护的方法或者对象只通过受保护的�Ҏ(gu��)��q�行调用。所以，�~�写�U�程安全的代码关键就在于规划�Ҏ(gu��)��和对象之间的调用关系�Q��ƈ��量采用相同对象的锁来进行同步控制�?br />
3.2 The Volatile Keyword
1. Scope of a Lock: 锁的作用范围卌��得和释放锁之间的那段旉��?br /> 2. Java标准虽然声明存取一个非long和double变量的操作是原子操作�Q�但�׃��不同虚拟机实现的差异�Q�在多线�E�环境下每个�U�程可能会保留自��q��工作拯��Q�而导致变量的��g�生冲�H�。�ؓ了避免这�U�情�늚�发生�Q�可以有两种�Ҏ(gu��)��Q?br /> 　　1) 为变量创建声明�ؓsynchronized的setter和getter�Ҏ(gu��)��Q�然后�Q何调用（包括在类�c�部�Q�该变量的地斚w��通过setter和getter�Ҏ(gu��)��Q?br /> 　　2) 采用volatile声明�Q�确保每�ơ存取这些属性时都从��d��存中��d��或者写入主内存中；
　　3) volatile仅仅用于解决Java内存模式��D��的问题，只能�q�用在对该变量只做一个单一装蝲或写入操作且该方法的其它操作�q�不依赖该变量的变化。如�Q�在一个��@环体中作为递增或递减变量时就不能使用volatile来解决线�E�同步的问题�?br /> 3. volatile的��用是有限的，一般而言�Q�仅仅将其作为强制虚拟机��L��从主内存��d��变量的一个手�D�，或者某些需要其参数声明为volatile的函数�?

3.3 More on Race Conditions
本节以打字游戏中昄��成�W的例子来解释了可能存在的race condition。关键要注意以下几点�Q?br /> 1. 操作�pȝ��会随机的切换多个�U�程的运行，因此当多个线�E�调用同一个方法时�Q�可能在��M��地方被暂停而将控制权交�l�另外的�U�程�Q?br /> 2. ��Z��减少被误用的可能�Q��L��假设�Ҏ(gu��)��有可能被多个�U�程调用�Q?br /> 3. 锁仅仅与某个特定实例相关�Q�而与��M��Ҏ(gu��)��和类都无养I��q�一点当需要存取类属性或�Ҏ(gu��)��时要特别注意�Q?br /> 4. ��M��时候只有一个线�E�能够运行某个类中一个被声明为synchronized的静态方法；一个线�E�只能运行某个特定实例中一个被声明为synchronized的非静态方法�?br />
3.4 Explicit Locking
1. 学过Win32下编写多�U�程的朋友刚开始可能会被Java的Synchronized关键词搞�p�涂。因为Java中的��M��一个对象都有一个与之相关的锁，而不象在Win32下要先定义一个互斥量�Q�然后再调用一个函数进入或者离开互斥区域。在JDK 1.5以后也开始提供这�U�显�C�声明的锁。JDK 1.5中定义了一个Lock接口和一些类�Q�允许程序员昄��的��用锁对象�?br />2. 在Lock接口里有两个�Ҏ(gu��)��Q�lock()和unlock()用来获取和释��N��对象�Q�从而保证受保护的代码区域是�U�程安全的�?br />3. 使用锁对象的一个好处在于可以被保存、传递和抛弃�Q�以在比较复杂的多线�E�应用中使用�l�一的锁�?br /> 在��用锁对象�Ӟ��L��lock()和unlock()调用包含在try/finally块中�Q�以防止�q�行时异常的抛出而导致死锁的情况�?br />
3.5 Lock Scope
利用lock()和unlock()�Ҏ(gu��)��Q�我们可以在��M��地方使用它们�Q�从一行代码到跨越多个�Ҏ(gu��)��和对象，�q�样��p��Ҏ(gu��)��E�序设计需要来定义锁的作用(scope of lock)范围�Q�而不是象以前局限在对象的层�ơ上�?

3.5.1 Synchronized Blocks
1. 利用synchronized关键字也能徏立同步块�Q�而不一定非得同步整个方法�?br /> 2. 同步一�D�代码时�Q�需要明��的指定获取哪个对象的锁(�q�就�c�M��于锁对象�?�Q�这��P��可以在多个�Ҏ(gu��)��或对象中�׃�n�q�个锁对象�?br />
3.6 Choosing a Locking Mechanism
使用锁对象还是同步关键字(synchronized)�Q�这个取决于开发员自己。��用synchronized比较��单，但相对而言�Q�比较隐晦，在比较复杂的情况�?如要同时同步静态和非静态方法时)�Q�没有锁对象来得直观和统一。一般而言�Q�synchronized��单，易于使用�Q�但同时相对而言效率较低�Q�且不能跨越多个�Ҏ(gu��)��?br />
3.6.1 The Lock Interface

public interface Lock {
     void lock();
     void lockInterruptibly() throws InterruptedException;
     boolean tryLock();
     boolean tryLock(long time, TimeUnit unit)
         throws InterruptedException;
     void unlock();
     Condition newCondition();  
}

其中的tryLock()和tryLock(long, TimeUnit)��尝试获取锁对象�Q�如果不能获取或在指定时间内不能获取�Q�将立即�q�回。调用者可以根据返回值来判断是否获得了锁对象以做�q�一步的操作�?br />
3.7 Nested Locks
1. 在一个同步方法内调用同一个对象上的另外的同步�Ҏ(gu��)��的情况，�U�C��为嵌套锁(nested locking)。系�l�将自动执行嵌套的同步方法，而无��ȝ��待锁的释放。因此，有的时候，即��一些私有方法仅仅被已同步的�Ҏ(gu��)��调用�Q�我们也�l�其加上synchronized关键字，以减��后�l�维护时可能产生的误对{�?br /> 2. ReenterantLock�c�M��支持嵌套锁。在ReenterantLock�cȝ��持一个计数器�Q�只有当�q�个计数器�ؓ0�Ӟ��才会释放锁。注意：�q�个�Ҏ(gu��)��是ReenterantLock�cȝ��Ҏ(gu��)��，而不是所有实现Lock接口的类的特性�?/strong>
3. 需要支持嵌套锁的一个原因是�Ҏ(gu��)��之间交叉调用(cross-calling)。设惛_��象a的方法M1调用对象b的方法N1�Q�然后N1再调用对象a的方法M2�Q�而M1和M2都是同步�Ҏ(gu��)��Q�如果不支持嵌套锁，则N1��在调用M2时等待M1释放锁，而M1则由于N1没有�q�回永远也不会释��N��Q�这样就产生了死锁�?br /> 4. synchronized和Lock接口�q�没有提供锁对象被嵌套获取的�ơ数�Q�但ReentrantLock则提供了�q�样一�U�机�Ӟ��

public class ReentrantLock implements Lock {
public int getHoldCount();
public boolean isLocked();
public boolean isHeldByCurrentThread();
public int getQueueLength();
...
}

其中�Q?br />     1) getHoldCount()�q�回当前�U�程的获取次敎ͼ��q�回0�q�不表示该锁是可获取的，有可能没有被当前�U�程获得�Q?br />     2) isLocked()判断该锁对象是否被�Q何线�E�获得；
    3) isHeldByCurrentThread()判断是否由当前线�E�获得；
    4) getQueueLength()用来估计当前有多��线�E�在�{�待获取�q�个锁对象�?br />
3.8 Deadlock
介绍了死锁的概念�Q��ƈ修改例子代码来演�C�deadlock的��生。死锁一般��生在多个�U�程在多个锁上同步时产生的；当然�Q�多个线�E�在判断多个条�g的时候，也有可能产生死锁�?br />
3.9 Lock Fairness
1. Java里锁的获取机制依赖于底层多线�E�系�l�的实现�Q��ƈ不保证一个特定的��序�Q?br /> 2. ReentrantLock�c�L��供一个先�q�先�?first-in-first-out)的获取锁的选项(在创建锁对象时传入true�?�?img width="1" height="1" src="http://blog.csdn.net/evanwhj/aggbug/616068.aspx" alt="" />
文章来源:http://blog.csdn.net/evanwhj/archive/2006/03/05/616068.aspx

Evan 2006-03-05 23:25 发表评论

Evan — Sun, 05 Mar 2006 15:25:00 GMT

Chapter2: Thread Creation and Management

2.1 What Is a Thread?

介绍了什么是�U�程�Q�以及线�E?thread, multithread)与进�E?process, mutltitask)的区别。其中的一个重要区别是对共享数据的讉K��。进�E�可以共享操作系�l��别的某些数据区域�Q�如剪脓(chu��ng)板；而线�E�是对程序自有的数据�q�行�׃�n。进�E�之间对�׃�n数据的存取方法是�Ҏ(gu��)��的，因此自然能够得到�E�序员的注意�Q�而线�E�之间对�׃�n数据的存取与对线�E�自��q��数据的存取方法是一��L(f��ng)��Q�所以常常比较隐蔽，而被�E�序员忽略。其实，�q�也是多�U�程开发比较难的地斏V��所以，�q�一节最后说�Q?quot;A thread, then, is a discrete task that operates on data shared with other threads.�Q�线�E�就是一个在与其它线�E�共享的数据上进行操作的单独��d��。）"

2.2 Creating a Thread

1. 有两�U�方法创建线�E�：使用Thread�c�L��者Runnable接口
2. �C�Z��E�序竟然是编一个打字游戏，所以，�q�本书的门槛�q�是有点高的:(。当然可以从该书的站点直接下�?a >代码�?
3. Thread class

package java.lang;
public class Thread implements Runnable {
public Thread( );
public Thread(Runnable target);
public Thread(ThreadGroup group, Runnable target);
public Thread(String name);
public Thread(ThreadGroup group, String name);
public Thread(Runnable target, String name);
public Thread(ThreadGroup group, Runnable target, String name);
public Thread(ThreadGroup group, Runnable target, String name,
long stackSize);
public void start( );
public void run( );
}

Thread name: �U�程名，用以打印�U�程信息时用�Q�缺省�ؓThread-N�?
Runnable target�Q�可�q�行的目标。一个可�q�行的对象就是一串可��q��E�执行的指��o。缺省就是在run()�Ҏ(gu��)��中编写的内容�?
Thread group�Q�线�E�组。对于大多数应用来说没什么意义，�~�省在同一�l��?
Stack size�Q�线�E�堆栈大��，与��^台相兟뀂�ؓ了�ɽE�序更具可移植性，�q�不推荐使用�?br />
2.3 The Lifecycle of a Thread

1. Creating a Thread�Q�创��Z��个线�E�对象，�q�没有开始执行一个线�E?
2. Starting a Thread�Q�在调用�U�程对象的start()�Ҏ(gu��)��前，一直处于等待状态。可以通过调用isAlive()�Ҏ(gu��)��来获取线�E�是否正在运行；
3. Terminating a Thread�Q�线�E�在以下情况下结束　　
　　1)执行完run()中的语句�Q?br />　　2)抛出一个异常，包括其没有捕��L(f��ng)��异常�Q?br />　　3)其所在的�E�序�Q�或者容器）调用System.exit()�?
注意�Q�一个线�E�结束后�Q�就不能再次启动�Q�该�U�程��变成一个普通的对象�Q�如果试囑ֆ��ơ调用start()�Ҏ(gu��)��Q�将抛出java.lang.IllegalThreadStateException异常。如果想多次�q�行�Q�要么创建新的对象；要么��是不要�l�束该线�E��?/span>
4. Java�q�没有提供可靠的�Ҏ(gu��)��来暂停、挂��h��者重启一个线�E�的�Ҏ(gu��)��Q�线�E�本�w�能通过sleep()函数来暂停执行。目前依然只能确保若�q�毫�U��别的�_�ֺ��?
5. Thread Cleanup�Q�线�E�终止后�Q�线�E�对象依然存在。可以通过join()�Ҏ(gu��)��以阻塞方�?blocked)来等待某个线�E�终止�?br />
2.4 Two Approches to Stop a Thread

1. Setting a Flag�Q�在�U�程的执行过�E�中判断其它�U�程是否��标志置位。其�~�点是有旉��延迟�Q�尤其是当进入了某些被阻塞的函数如：sleep(), wait()�{�；
2. 调用�U�程的interrupt()�Ҏ(gu��)���Q�线�E�的执行�q�程中改为判断isInterrupted()的返回倹{��可以解决线�E�进入阻塞导致的延迟�Q�但依然解决不了��长旉��计算而导致的延迟。interrupt()有两个作用：1)�l�止sleep()和wait()�Q�抛出InterruptedException�Q?)使isInterrupted()�q�回true。下面这�D�代码将演示interrupt()的作用：

public class TestInterrupted {
public static void main(String args[]) throws InterruptedException{
Foo foo = new Foo();
foo.start();
Thread.currentThread().sleep(100); //注释掉这句有什么媄响呢�Q?br /> System.out.println("before interrupt");
foo.interrupt();
System.out.println("after interrupt");
} }

class Foo extends Thread {
public void run() {
try{
while(!isInterrupted()) {
System.out.println("start calculating...");
double pi = 3.1415926;
for(int i=0; i<5; i++) {
for(long j=0; j<1000000; j++) {
pi *= pi;
}
System.out.println("i="+i);
}
System.out.println("before sleep");
sleep(5000); //注释掉这句及相关的try...catch语句�Q�又怎样呢？
System.out.println("after sleep");
}
} catch(InterruptedException ex) {
ex.printStackTrace(System.out);
}
}
}

2.5 The Runnable Interface

��Z��么有了Thread�c�，�q�要有Runnable接口呢？最主要的原因是��Z��解决Java不能多重�l�承的问题。线�E��承自Thread�Q�还是仅仅实现Runnable接口�Q�取决于�q�个�U�程的作用。不�q�，如果仅仅实现Runnable接口�Q�则在线�E�里不能使用Thread�cȝ��Ҏ(gu��)��Q�比如interrupt()和isInterrupted()。当�Ӟ��q�个�q�是要取决于实际情况�?br />
2.6 Threads and Objects

主要讲解�U�程与对象的关系。线�E�根本上�q�是个对象，其可以存取�Q何对象包括其它线�E�对象，当然也能被其它对象存取，只要没有因�ؓ争夺公共资源而被锁定�Q�线�E�对象中的�Q何属性和�Ҏ(gu��)��都有可能同时执行。�ƈ且Java中的锁只针对对象本��n�Q��ƈ不包括对象下的属性；而对�Ҏ(gu��)��同步�Q�则�{�同于对对象同步。更�q�一步的说明�q�可以参考《Practical Java》中�?quot;实践46�Q�面对instance函数�Q�synchronized锁定的是对象(object)而非函数(methods)或代码（code�Q?quot;。下面用两段代码来说明一下：
代码1:

public class TestLock {
public static void main(String args[])
throws InterruptedException{
Foo foo = new Foo();
foo.start();
Thread t = Thread.currentThread();
for(int i=0; i<10; i++) {
foo.setInt2("Main", i, i+20);
}
}
}

class Foo extends Thread{
protected int arrI[] = new int[10];

public void run() {
try {
for(int i=0; i<10; i++) {
setInt("Foo", i, i);
}
} catch(InterruptedException ex) {}
}

public synchronized void setInt(String from, int pos, int val)
throws InterruptedException{
arrI[pos] = val;
sleep((long)(Math.random()*5000));
System.out.println(from+":arrI["+pos+"]="+arrI[pos]);
}

public void setInt2(String from, int pos, int val)
throws InterruptedException {
synchronized(arrI){
arrI[pos] = val;
sleep((long)(Math.random()*5000));
System.out.println(from+":arrI["+pos+"]="+arrI[pos]);
}
}
}

�l�果�Q�非�U�程安全�Q�setInt()在对象上加锁�Q�而setInt2()在属性arrI上加锁，不同的锁不能保证�U�程安全。可能的�l�果如下�Q?br />

Foo:arrI[0]=0
Main:arrI[0]=0
Main:arrI[1]=21
Main:arrI[2]=22
Foo:arrI[1]=21
Main:arrI[3]=23
Main:arrI[4]=24
Main:arrI[5]=25
Foo:arrI[2]=2
Main:arrI[6]=26
Main:arrI[7]=27
Foo:arrI[3]=3
Foo:arrI[4]=4
Main:arrI[8]=28
Main:arrI[9]=29
Foo:arrI[5]=5
Foo:arrI[6]=6
Foo:arrI[7]=7
Foo:arrI[8]=8
Foo:arrI[9]=9

代码2:

public class TestLock1 {
public static void main(String args[])
throws InterruptedException{
Foo1 foo = new Foo1();
foo.start();
Thread t = Thread.currentThread();
for(int i=0; i<10; i++) {
foo.setInt2("Main", i, i+20);
}
}
}

class Foo1 extends Thread{
protected int arrI[] = new int[10];

public void run() {
try{
for(int i=0; i<10; i++) {
setInt("Foo", i, i);
}
}catch(InterruptedException ex){}
}

public synchronized void setInt(String from, int pos, int val)
throws InterruptedException{
arrI[pos] = val;
sleep((long)(Math.random()*5000));
System.out.println(from+":arrI["+pos+"]="+arrI[pos]);
}

public synchronized void setInt2(String from, int pos, int val)
throws InterruptedException{
arrI[pos] = val;
sleep((long)(Math.random()*5000));
System.out.println(from+":arrI["+pos+"]="+arrI[pos]);
}
}

�l�果�Q�线�E�安�?img width="1" height="1" src="http://blog.csdn.net/evanwhj/aggbug/616046.aspx" alt="" />

Evan 2006-03-05 23:25 发表评论

Evan — Sun, 05 Mar 2006 15:25:00 GMT
J2SE 5.0在多�U�程上做了很大的改进�Q�提供了更多的API�Q�包括：
Atomic variables: A set of classes that provide threadsafe operations without synchronization
Explicit locks: Synchronization locks that can be acquired and released programmatically
Condition variables: Variables that can be the subject of a targeted notification when certain conditions exist
Queues: Collection classes that are thread-aware Synchronization primitives: New classes that perform complex types of synchronization
Thread pools: Classes that can manage a pool of threads to run certain tasks
Thread schedulers: Classes that can execute tasks at a particular point in time

在《Java Threads》一书中��其归纳��Z��c�：
1. 对现有功能的新实玎ͼ�
2. 提供了重要的多线�E�工��P��如线�E�池(pool)和计�?schedule)�Q?br /> 3. 最��化同步工具(Minimal synchronization utilities)�?br />
�q�些功能的妙处我现在自然是无法体会得刎ͼ�但对于JDK 5.0中提供的�q�些多线�E�工��P��会不会也遭遇JDK 1.4提供的Log API的命�q�，因敌不过�W�三方工兯��成为摆讑֑��Q�至��目前我�q�在用Log4J�Q�且其也没有停止开发的�q�象�Q�？

Evan 2006-03-05 23:25 发表评论

多线�E?1): 选书

Evan — Sun, 05 Mar 2006 15:25:00 GMT

��M��一门支持多�U�程的语�a�中，多线�E�是都是一个让人又爱又恨的东西。Java的多�U�程相对而言比其它语�a�要简单一点，如果不是开发框架类或者系�l��的程序，也许很少会碰到要明确��到Java的多�U�程API�Q�但事实上不�{�于你不用注意多�U�程安全的问题，��其当你在开发Web�E�序的时候，在类中��用了静态属性（static fields�Q�而不仅仅是对象属性（instance fields�Q�的时候，如果在压力测试或者提交给用户使用的时候，发生了一些不可重现的错误或者数据�؜��q��时候，那往往要查查这些��用了静态属性的�c�L��否是多线�E�安全的了。当�Ӟ��如果你专注于开发Web应用�Q��ƈ且很��涉及框架或核心模块的开发，那也��基本上知道synchronized的关键字的应用就可以了。这也许��是Java多线�E�相对其它语�a�中多�U�程要简单一点的原因�?/p> 当然�Q�这�ơ我打算比较深入地来了解了解一下Java多线�E�开发的其它一些内容，那么找一本好的书是一个比较好的开始。关于Java多线�E�开发的专著比较有名的大�U�是《Java Threads, 3rd Edition》和《Java Thread Programming》了�Q�前者基于JDK 1.5(�q�个版本对多�U�程�q�行了很大的改进)�q�行介绍�Q��ƈ且指��Z��与以前版本的区别�Q�而后者出版于1999�q�_��是基于JDK 1.2�q�行讲解的。所以呢�Q�基本上采用�W�一本�ؓ丅R��同时也参考一下《Practical Java》和《Effective Java》的相关条目�?br />
�q�几本书的封面如下，相关书的介绍可去Amazon查看一下：

Evan 2006-03-05 23:25 发表评论

Java学习�W�记�Q�序�a�

Evan — Sun, 05 Mar 2006 15:25:00 GMT
除了C是在大学中系�l�学的外�Q�C++、Java、Design Pattern�{�等�{�等都是在工作中赉��子上架的时候学的，虽然有边做边学的乐趣�Q�但也有��Z��赶时间抓�q�度�Q�只要解决了问题��好而浅��辄止的遗憾�Q�也时有遗忘的现象发生。近来得了点�I�闲�Q�准备好好读��d��本或��经典或��时髦的书。所以，��有了这样一个Blog�Q�希望能��学习和工作中的一些小心得�l�记录下来，聊以敝帚自珍之需�?img width="1" height="1" alt="" src="http://blog.csdn.net/evanwhj/aggbug/616036.aspx" />

Evan 2006-03-05 23:25 发表评论