【转】Java线程详解
Java线程：概念与原理
一、操作系统中线程和进程的概念
现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。
进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。
线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程共享进程的内存。
“同时”执行是人的感觉，在线程之间实际上轮换执行。
二、Java中的线程
在Java中，“线程”指两件不同的事情：
1、java.lang.Thread类的一个实例；
2、线程的执行。
使用java.lang.Thread类或者java.lang.Runnable接口编写代码来定义、实例化和启动新线程。
一个Thread类实例只是一个对象，像Java中的任何其他对象一样，具有变量和方法，生死于堆上。
Java中，每个线程都有一个调用栈，即使不在程序中创建任何新的线程，线程也在后台运行着。
一个Java应用总是从main()方法开始运行，mian()方法运行在一个线程内，它被称为主线程。
一旦创建一个新的线程，就产生一个新的调用栈。
线程总体分两类：用户线程和守候线程。
当所有用户线程执行完毕的时候，JVM自动关闭。但是守候线程却不独立于JVM，守候线程一般是由操作系统或者用户自己创建的
Java多线程编程总结”中的图
二、阻止线程执行
对于线程的阻止，考虑一下三个方面，不考虑IO阻塞的情况：
睡眠；
等待；
因为需要一个对象的锁定而被阻塞。
1、睡眠
Thread.sleep(long millis)和Thread.sleep(long millis, int nanos)静态方法强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。当线程睡眠时，它入睡在某个地方，在苏醒之前不会返回到可运行状态。当睡眠时间到期，则返回到可运行状态。
线程睡眠的原因：线程执行太快，或者需要强制进入下一轮，因为Java规范不保证合理的轮换。
睡眠的实现：调用静态方法。
try {
Thread.sleep(123);
} catch (InterruptedException e) {
e.printStackTrace();
}
睡眠的位置：为了让其他线程有机会执行，可以将Thread.sleep()的调用放线程run()之内。这样才能保证该线程执行过程中会睡眠。
例如，在前面的例子中，将一个耗时的操作改为睡眠，以减慢线程的执行。可以这么写：
public void run() {
for(int i = 0;i<5;i++){
// 很耗时的操作，用来减慢线程的执行
// for(long k= 0; k <100000000;k++);
try {
Thread.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace(); .
}
System.out.println(this.getName()+" :"+i);
}
}
运行结果：
阿三 :0
李四 :0
阿三 :1
阿三 :2
阿三 :3
李四 :1
李四 :2
阿三 :4
李四 :3
李四 :4
Process finished with exit code 0
这样，线程在每次执行过程中，总会睡眠3毫秒，睡眠了，其他的线程就有机会执行了。
注意：
1、线程睡眠是帮助所有线程获得运行机会的最好方法。
2、线程睡眠到期自动苏醒，并返回到可运行状态，不是运行状态。sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始执行。
3、sleep()是静态方法，只能控制当前正在运行的线程。
下面给个例子：
/**
* 一个计数器，计数到100，在每个数字之间暂停1秒，每隔10个数字输出一个字符串
*
* @author leizhimin 2008-9-14 9:53:49
*/
publicclass MyThreadextends Thread {
publicvoid run() {
for (int i = 0; i < 100; i++) {
if ((i) % 10 == 0) {
System.out.println("-------" + i);
}
System.out.print(i);
try {
Thread.sleep(1);
System.out.print(" 线程睡眠1毫秒！\n");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
publicstaticvoid main(String[] args) {
new MyThread().start();
}
}
-------0
0 线程睡眠1毫秒！
1 线程睡眠1毫秒！
2 线程睡眠1毫秒！
3 线程睡眠1毫秒！
4 线程睡眠1毫秒！
5 线程睡眠1毫秒！
6 线程睡眠1毫秒！
7 线程睡眠1毫秒！
8 线程睡眠1毫秒！
9 线程睡眠1毫秒！
-------10
10 线程睡眠1毫秒！
11 线程睡眠1毫秒！
12 线程睡眠1毫秒！
13 线程睡眠1毫秒！
14 线程睡眠1毫秒！
15 线程睡眠1毫秒！
16 线程睡眠1毫秒！
17 线程睡眠1毫秒！
18 线程睡眠1毫秒！
19 线程睡眠1毫秒！
-------20
20 线程睡眠1毫秒！
21 线程睡眠1毫秒！
22 线程睡眠1毫秒！
23 线程睡眠1毫秒！
24 线程睡眠1毫秒！
25 线程睡眠1毫秒！
26 线程睡眠1毫秒！
27 线程睡眠1毫秒！
28 线程睡眠1毫秒！
29 线程睡眠1毫秒！
-------30
30 线程睡眠1毫秒！
31 线程睡眠1毫秒！
32 线程睡眠1毫秒！
33 线程睡眠1毫秒！
34 线程睡眠1毫秒！
35 线程睡眠1毫秒！
36 线程睡眠1毫秒！
37 线程睡眠1毫秒！
38 线程睡眠1毫秒！
39 线程睡眠1毫秒！
-------40
40 线程睡眠1毫秒！
41 线程睡眠1毫秒！
42 线程睡眠1毫秒！
43 线程睡眠1毫秒！
44 线程睡眠1毫秒！
45 线程睡眠1毫秒！
46 线程睡眠1毫秒！
47 线程睡眠1毫秒！
48 线程睡眠1毫秒！
49 线程睡眠1毫秒！
-------50
50 线程睡眠1毫秒！
51 线程睡眠1毫秒！
52 线程睡眠1毫秒！
53 线程睡眠1毫秒！
54 线程睡眠1毫秒！
55 线程睡眠1毫秒！
56 线程睡眠1毫秒！
57 线程睡眠1毫秒！
58 线程睡眠1毫秒！
59 线程睡眠1毫秒！
-------60
60 线程睡眠1毫秒！
61 线程睡眠1毫秒！
62 线程睡眠1毫秒！
63 线程睡眠1毫秒！
64 线程睡眠1毫秒！
65 线程睡眠1毫秒！
66 线程睡眠1毫秒！
67 线程睡眠1毫秒！
68 线程睡眠1毫秒！
69 线程睡眠1毫秒！
-------70
70 线程睡眠1毫秒！
71 线程睡眠1毫秒！
72 线程睡眠1毫秒！
73 线程睡眠1毫秒！
74 线程睡眠1毫秒！
75 线程睡眠1毫秒！
76 线程睡眠1毫秒！
77 线程睡眠1毫秒！
78 线程睡眠1毫秒！
79 线程睡眠1毫秒！
-------80
80 线程睡眠1毫秒！
81 线程睡眠1毫秒！
82 线程睡眠1毫秒！
83 线程睡眠1毫秒！
84 线程睡眠1毫秒！
85 线程睡眠1毫秒！
86 线程睡眠1毫秒！
87 线程睡眠1毫秒！
88 线程睡眠1毫秒！
89 线程睡眠1毫秒！
-------90
90 线程睡眠1毫秒！
91 线程睡眠1毫秒！
92 线程睡眠1毫秒！
93 线程睡眠1毫秒！
94 线程睡眠1毫秒！
95 线程睡眠1毫秒！
96 线程睡眠1毫秒！
97 线程睡眠1毫秒！
98 线程睡眠1毫秒！
99 线程睡眠1毫秒！
Process finished with exit code 0
2、线程的优先级和线程让步yield()
线程的让步是通过Thread.yield()来实现的。yield()方法的作用是：暂停当前正在执行的线程对象，并执行其他线程。
要理解yield()，必须了解线程的优先级的概念。线程总是存在优先级，优先级范围在1~10之间。JVM线程调度程序是基于优先级的抢先调度机制。在大多数情况下，当前运行的线程优先级将大于或等于线程池中任何线程的优先级。但这仅仅是大多数情况。
注意：当设计多线程应用程序的时候，一定不要依赖于线程的优先级。因为线程调度优先级操作是没有保障的，只能把线程优先级作用作为一种提高程序效率的方法，但是要保证程序不依赖这种操作。
当线程池中线程都具有相同的优先级，调度程序的JVM实现自由选择它喜欢的线程。这时候调度程序的操作有两种可能：一是选择一个线程运行，直到它阻塞或者运行完成为止。二是时间分片，为池内的每个线程提供均等的运行机会。
设置线程的优先级：线程默认的优先级是创建它的执行线程的优先级。可以通过setPriority(int newPriority)更改线程的优先级。例如：
Thread t = new MyThread();
t.setPriority(8);
t.start();
线程优先级为1~10之间的正整数，JVM从不会改变一个线程的优先级。然而，1~10之间的值是没有保证的。一些JVM可能不能识别10个不同的值，而将这些优先级进行每两个或多个合并，变成少于10个的优先级，则两个或多个优先级的线程可能被映射为一个优先级。
线程默认优先级是5，Thread类中有三个常量，定义线程优先级范围：
static int MAX_PRIORITY
线程可以具有的最高优先级。
static int MIN_PRIORITY
线程可以具有的最低优先级。
static int NORM_PRIORITY
分配给线程的默认优先级。
3、Thread.yield()方法
Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。
yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。
结论：yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。
4、join()方法
Thread的非静态方法join()让一个线程B“加入”到另外一个线程A的尾部。在A执行完毕之前，B不能工作。例如：
Thread t = new MyThread();
t.start();
t.join();
另外，join()方法还有带超时限制的重载版本。例如t.join(5000);则让线程等待5000毫秒，如果超过这个时间，则停止等待，变为可运行状态。
线程的加入join()对线程栈导致的结果是线程栈发生了变化，当然这些变化都是瞬时的。下面给示意图：
小结
到目前位置，介绍了线程离开运行状态的3种方法：
1、调用Thread.sleep()：使当前线程睡眠至少多少毫秒（尽管它可能在指定的时间之前被中断）。
2、调用Thread.yield()：不能保障太多事情，尽管通常它会让当前运行线程回到可运行性状态，使得有相同优先级的线程有机会执行。
3、调用join()方法：保证当前线程停止执行，直到该线程所加入的线程完成为止。然而，如果它加入的线程没有存活，则当前线程不需要停止。
除了以上三种方式外，还有下面几种特殊情况可能使线程离开运行状态：
1、线程的run()方法完成。
2、在对象上调用wait()方法（不是在线程上调用）。
3、线程不能在对象上获得锁定，它正试图运行该对象的方法代码。
4、线程调度程序可以决定将当前运行状态移动到可运行状态，以便让另一个线程获得运行机会，而不需要任何理由。
Java线程：线程的同步与锁》，本文是在此基础上所写的。
对于同步，在具体的Java代码中需要完成一下两个操作：
把竞争访问的资源标识为private；
同步哪些修改变量的代码，使用synchronized关键字同步方法或代码。
当然这不是唯一控制并发安全的途径。
synchronized关键字使用说明
synchronized只能标记非抽象的方法，不能标识成员变量。
为了演示同步方法的使用，构建了一个信用卡账户，起初信用额为100w，然后模拟透支、存款等多个操作。显然银行账户User对象是个竞争资源，而多个并发操作的是账户方法oper(int x)，当然应该在此方法上加上同步，并将账户的余额设为私有变量，禁止直接访问。
/**
* Java线程：线程的同步
*
* @author leizhimin 2009-11-4 11:23:32
*/
publicclass Test {
publicstaticvoid main(String[] args) {
User u = new User("张三", 100);
MyThread t1 = new MyThread("线程A", u, 20);
MyThread t2 = new MyThread("线程B", u, -60);
MyThread t3 = new MyThread("线程C", u, -80);
MyThread t4 = new MyThread("线程D", u, -30);
MyThread t5 = new MyThread("线程E", u, 32);
MyThread t6 = new MyThread("线程F", u, 21);
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
t6.start();
}
}
class MyThread extends Thread {
private User u;
privateint y = 0;
MyThread(String name, User u, int y) {
super(name);
this.u = u;
this.y = y;
}
publicvoid run() {
u.oper(y);
}
}
class User {
private String code;
privateint cash;
User(String code, int cash) {
this.code = code;
this.cash = cash;
}
public String getCode() {
return code;
}
publicvoid setCode(String code) {
this.code = code;
}
/**
* 业务方法
* @param x 添加x万元
*/
publicsynchronizedvoid oper(int x) {
try {
Thread.sleep(10L);
this.cash += x;
System.out.println(Thread.currentThread().getName() + "运行结束，增加“"+ x +"”，当前用户账户余额为：" +
cash);
Thread.sleep(10L);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
public String toString() {
return"User{" +
"code='" + code + '\'' +
", cash=" + cash +
'}';
}
}
输出结果：
线程A运行结束，增加“20”，当前用户账户余额为：120
线程F运行结束，增加“21”，当前用户账户余额为：141
线程E运行结束，增加“32”，当前用户账户余额为：173
线程C运行结束，增加“-80”，当前用户账户余额为：93
线程B运行结束，增加“-60”，当前用户账户余额为：33
线程D运行结束，增加“-30”，当前用户账户余额为：3
Process finished with exit code 0
反面教材，不同步的情况，也就是去掉oper(int x)方法的synchronized修饰符，然后运行程序，结果如下：
线程A运行结束，增加“20”，当前用户账户余额为：61
线程D运行结束，增加“-30”，当前用户账户余额为：63
线程B运行结束，增加“-60”，当前用户账户余额为：3
线程F运行结束，增加“21”，当前用户账户余额为：61
线程E运行结束，增加“32”，当前用户账户余额为：93
线程C运行结束，增加“-80”，当前用户账户余额为：61
Process finished with exit code 0
很显然，上面的结果是错误的，导致错误的原因是多个线程并发访问了竞争资源u，并对u的属性做了改动。
可见同步的重要性。
注意：
通过前文可知，线程退出同步方法时将释放掉方法所属对象的锁，但还应该注意的是，同步方法中还可以使用特定的方法对线程进行调度。这些方法来自于java.lang.Object类。
void notify()
唤醒在此对象监视器上等待的单个线程。
void notifyAll()
唤醒在此对象监视器上等待的所有线程。
void wait()
导致当前的线程等待，直到其他线程调用此对象的 notify()方法或 notifyAll()方法。
void wait(long timeout)
导致当前的线程等待，直到其他线程调用此对象的 notify()方法或 notifyAll()方法，或者超过指定的时间量。
void wait(long timeout,int nanos)
导致当前的线程等待，直到其他线程调用此对象的 notify()方法或 notifyAll()方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量。
结合以上方法，处理多线程同步与互斥问题非常重要，著名的生产者-消费者例子就是一个经典的例子，任何语言多线程必学的例子。
Java理论与实践:正确使用 Volatile 变量》，这篇文章对volatile关键字的用法做了相当精辟的阐述。
之所以要单独提出volatile这个不常用的关键字原因是这个关键字在高性能的多线程程序中也有很重要的用途，只是这个关键字用不好会出很多问题。
首先考虑一个问题，为什么变量需要volatile来修饰呢？
要搞清楚这个问题，首先应该明白计算机内部都做什么了。比如做了一个i++操作，计算机内部做了三次处理：读取－修改－写入。
同样，对于一个long型数据，做了个赋值操作，在32系统下需要经过两步才能完成，先修改低32位，然后修改高32位。
假想一下，当将以上的操作放到一个多线程环境下操作时候，有可能出现的问题，是这些步骤执行了一部分，而另外一个线程就已经引用了变量值，这样就导致了读取脏数据的问题。
通过这个设想，就不难理解volatile关键字了。
volatile可以用在任何变量前面，但不能用于final变量前面，因为final型的变量是禁止修改的。也不存在线程安全的问题。
更多的内容，请参看：：《Java理论与实践:正确使用 Volatile 变量》一文，写得很好。
TimeUnit unit,
BlockingQueue<Runnable> workQueue)
用给定的初始参数和默认的线程工厂及处理程序创建新的ThreadPoolExecutor。使用Executors工厂方法之一比使用此通用构造方法方便得多。
参数：
corePoolSize -池中所保存的线程数，包括空闲线程。
maximumPoolSize -池中允许的最大线程数。
keepAliveTime -当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。
unit - keepAliveTime参数的时间单位。
workQueue -执行前用于保持任务的队列。此队列仅保持由execute方法提交的Runnable任务。
抛出：
IllegalArgumentException -如果 corePoolSize或 keepAliveTime小于零，或者 maximumPoolSize小于或等于零，或者 corePoolSize大于 maximumPoolSize。
NullPointerException -如果workQueue为 null
自定义连接池稍微麻烦些，不过通过创建的ThreadPoolExecutor线程池对象，可以获取到当前线程池的尺寸、正在执行任务的线程数、工作队列等等。
有关Java5线程池的内容到此就没有了，更多的内容还需要研读API来获取。
Condition
Condition将Object监视器方法（wait、notify和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意Lock实现组合使用，为每个对象提供多个等待 set（wait-set）。
Lock
Lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。
ReadWriteLock
ReadWriteLock维护了一对相关的锁定，一个用于只读操作，另一个用于写入操作。
Condition将Object监视器方法（wait、notify和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意Lock实现组合使用，为每个对象提供多个等待 set（wait-set）。
Lock
Lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。
ReadWriteLock
ReadWriteLock维护了一对相关的锁定，一个用于只读操作，另一个用于写入操作。
有关锁的介绍,API文档解说很多，看得很烦，还是看个例子再看文档比较容易理解。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* Java线程：锁
*
* @author leizhimin 2009-11-5 10:57:29
*/
publicclass Test {
publicstaticvoid main(String[] args) {
//创建并发访问的账户
MyCount myCount = new MyCount("95599200901215522", 10000);
//创建一个锁对象
Lock lock = new ReentrantLock();
//创建一个线程池
ExecutorService pool = Executors.newCachedThreadPool();
//创建一些并发访问用户，一个信用卡，存的存，取的取，好热闹啊
User u1 = new User("张三", myCount, -4000,
lock);
User u2 = new User("张三他爹", myCount, 6000,
lock);
User u3 = new User("张三他弟", myCount, -8000,
lock);
User u4 = new User("张三", myCount, 800, lock);
//在线程池中执行各个用户的操作
pool.execute(u1);
pool.execute(u2);
pool.execute(u3);
pool.execute(u4);
//关闭线程池
pool.shutdown();
}
}
/**
* 信用卡的用户
*/
class User implements Runnable {
private String name; //用户名
private MyCount myCount; //所要操作的账户
privateint iocash; //操作的金额，当然有正负之分了
private Lock myLock; //执行操作所需的锁对象
User(String name, MyCount myCount, int iocash, Lock myLock) {
this.name = name;
this.myCount = myCount;
this.iocash = iocash;
this.myLock = myLock;
}
publicvoid run() {
//获取锁
myLock.lock();
//执行现金业务
System.out.println(name + "正在操作" + myCount +"账户，金额为" +
iocash +"，当前金额为" + myCount.getCash());
myCount.setCash(myCount.getCash() + iocash);
System.out.println(name + "操作" + myCount +"账户成功，金额为" +
iocash +"，当前金额为" + myCount.getCash());
//释放锁，否则别的线程没有机会执行了
myLock.unlock();
}
}
/**
* 信用卡账户，可随意透支
*/
class MyCount {
private String oid; //账号
privateint cash; //账户余额
MyCount(String oid, int cash) {
this.oid = oid;
this.cash = cash;
}
public String getOid() {
return oid;
}
publicvoid setOid(String oid) {
this.oid = oid;
}
publicint getCash() {
return cash;
}
publicvoid setCash(int cash) {
this.cash = cash;
}
@Override
public String toString() {
return"MyCount{" +
"oid='" + oid + '\'' +
", cash=" + cash +
'}';
}
}
张三正在操作MyCount{oid='95599200901215522', cash=10000}账户，金额为-4000，当前金额为10000
张三操作MyCount{oid='95599200901215522', cash=6000}账户成功，金额为-4000，当前金额为6000
张三他爹正在操作MyCount{oid='95599200901215522', cash=6000}账户，金额为6000，当前金额为6000
张三他爹操作MyCount{oid='95599200901215522', cash=12000}账户成功，金额为6000，当前金额为12000
张三他弟正在操作MyCount{oid='95599200901215522', cash=12000}账户，金额为-8000，当前金额为12000
张三他弟操作MyCount{oid='95599200901215522', cash=4000}账户成功，金额为-8000，当前金额为4000
张三正在操作MyCount{oid='95599200901215522', cash=4000}账户，金额为800，当前金额为4000
张三操作MyCount{oid='95599200901215522', cash=4800}账户成功，金额为800，当前金额为4800
Process finished with exit code 0
从上面的输出可以看到，利用锁对象太方便了，比直接在某个不知情的对象上用锁清晰多了。
但一定要注意的是，在获取了锁对象后，用完后应该尽快释放锁，以便别的等待该锁的线程有机会去执行。
Java线程：新特征-锁（下）
在上文中提到了Lock接口以及对象，使用它，很优雅的控制了竞争资源的安全访问，但是这种锁不区分读写，称这种锁为普通锁。为了提高性能，Java提供了读写锁，在读的地方使用读锁，在写的地方使用写锁，灵活控制，在一定程度上提高了程序的执行效率。
Java中读写锁有个接口java.util.concurrent.locks.ReadWriteLock，也有具体的实现ReentrantReadWriteLock，详细的API可以查看JavaAPI文档。
下面这个例子是在文例子的基础上，将普通锁改为读写锁，并添加账户余额查询的功能，代码如下：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* Java线程：锁
*
* @author leizhimin 2009-11-5 10:57:29
*/
publicclass Test {
publicstaticvoid main(String[] args) {
//创建并发访问的账户
MyCount myCount = new MyCount("95599200901215522", 10000);
//创建一个锁对象
ReadWriteLock lock = new ReentrantReadWriteLock(false);
//创建一个线程池
ExecutorService pool = Executors.newFixedThreadPool(2);
//创建一些并发访问用户，一个信用卡，存的存，取的取，好热闹啊
User u1 = new User("张三", myCount, -4000,
lock, false);
User u2 = new User("张三他爹", myCount, 6000,
lock, false);
User u3 = new User("张三他弟", myCount, -8000,
lock, false);
User u4 = new User("张三", myCount, 800, lock,false);
User u5 = new User("张三他爹", myCount, 0, lock,true);
//在线程池中执行各个用户的操作
pool.execute(u1);
pool.execute(u2);
pool.execute(u3);
pool.execute(u4);
pool.execute(u5);
//关闭线程池
pool.shutdown();
}
}
/**
* 信用卡的用户
*/
class User implements Runnable {
private String name; //用户名
private MyCount myCount; //所要操作的账户
privateint iocash; //操作的金额，当然有正负之分了
private ReadWriteLock myLock; //执行操作所需的锁对象
privateboolean ischeck; //是否查询
User(String name, MyCount myCount, int iocash, ReadWriteLock myLock,boolean ischeck) {
this.name = name;
this.myCount = myCount;
this.iocash = iocash;
this.myLock = myLock;
this.ischeck = ischeck;
}
publicvoid run() {
if (ischeck) {
//获取读锁
myLock.readLock().lock();
System.out.println("读：" + name +"正在查询" +
myCount +"账户，当前金额为" + myCount.getCash());
//释放读锁
myLock.readLock().unlock();
} else {
//获取写锁
myLock.writeLock().lock();
//执行现金业务
System.out.println("写：" + name +"正在操作" +
myCount +"账户，金额为" + iocash +"，当前金额为" +
myCount.getCash());
myCount.setCash(myCount.getCash() + iocash);
System.out.println("写：" + name +"操作" +
myCount +"账户成功，金额为" + iocash +"，当前金额为" +
myCount.getCash());
//释放写锁
myLock.writeLock().unlock();
}
}
}
/**
* 信用卡账户，可随意透支
*/
class MyCount {
private String oid; //账号
privateint cash; //账户余额
MyCount(String oid, int cash) {
this.oid = oid;
this.cash = cash;
}
public String getOid() {
return oid;
}
publicvoid setOid(String oid) {
this.oid = oid;
}
publicint getCash() {
return cash;
}
publicvoid setCash(int cash) {
this.cash = cash;
}
@Override
public String toString() {
return"MyCount{" +
"oid='" + oid + '\'' +
", cash=" + cash +
'}';
}
}
写：张三正在操作MyCount{oid='95599200901215522', cash=10000}账户，金额为-4000，当前金额为10000
写：张三操作MyCount{oid='95599200901215522', cash=6000}账户成功，金额为-4000，当前金额为6000
写：张三他弟正在操作MyCount{oid='95599200901215522', cash=6000}账户，金额为-8000，当前金额为6000
写：张三他弟操作MyCount{oid='95599200901215522', cash=-2000}账户成功，金额为-8000，当前金额为-2000
写：张三正在操作MyCount{oid='95599200901215522', cash=-2000}账户，金额为800，当前金额为-2000
写：张三操作MyCount{oid='95599200901215522', cash=-1200}账户成功，金额为800，当前金额为-1200
读：张三他爹正在查询MyCount{oid='95599200901215522', cash=-1200}账户，当前金额为-1200
写：张三他爹正在操作MyCount{oid='95599200901215522', cash=-1200}账户，金额为6000，当前金额为-1200
写：张三他爹操作MyCount{oid='95599200901215522', cash=4800}账户成功，金额为6000，当前金额为4800
Process finished with exit code 0
在实际开发中，最好在能用读写锁的情况下使用读写锁，而不要用普通锁，以求更好的性能。
Java线程：新特征-信号量
Java的信号量实际上是一个功能完毕的计数器，对控制一定资源的消费与回收有着很重要的意义，信号量常常用于多线程的代码中，并能监控有多少数目的线程等待获取资源，并且通过信号量可以得知可用资源的数目等等，这里总是在强调“数目”二字，但不能指出来有哪些在等待，哪些资源可用。
因此，本人认为，这个信号量类如果能返回数目，还能知道哪些对象在等待，哪些资源可使用，就非常完美了，仅仅拿到这些概括性的数字，对精确控制意义不是很大。目前还没想到更好的用法。
下面是一个简单例子：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
* Java线程：新特征-信号量
*
* @author leizhimin 2009-11-5 13:44:45
*/
publicclass Test {
publicstaticvoid main(String[] args) {
MyPool myPool = new MyPool(20);
//创建线程池
ExecutorService threadPool = Executors.newFixedThreadPool(2);
MyThread t1 = new MyThread("任务A", myPool,
3);
MyThread t2 = new MyThread("任务B", myPool,
12);
MyThread t3 = new MyThread("任务C", myPool,
7);
//在线程池中执行任务
threadPool.execute(t1);
threadPool.execute(t2);
threadPool.execute(t3);
//关闭池
threadPool.shutdown();
}
}
/**
* 一个池
*/
class MyPool {
private Semaphore sp; //池相关的信号量
/**
* 池的大小，这个大小会传递给信号量
*
* @param size 池的大小
*/
MyPool(int size) {
this.sp =new Semaphore(size);
}
public Semaphore getSp() {
return sp;
}
publicvoid setSp(Semaphore sp) {
this.sp = sp;
}
}
class MyThread extends Thread {
private String threadname; //线程的名称
private MyPool pool; //自定义池
privateint x; //申请信号量的大小
MyThread(String threadname, MyPool pool, int x) {
this.threadname = threadname;
this.pool = pool;
this.x = x;
}
publicvoid run() {
try {
//从此信号量获取给定数目的许可
pool.getSp().acquire(x);
//todo：也许这里可以做更复杂的业务
System.out.println(threadname + "成功获取了" + x +"个许可！");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
//释放给定数目的许可，将其返回到信号量。
pool.getSp().release(x);
System.out.println(threadname + "释放了" + x +"个许可！");
}
}
}
任务B成功获取了12个许可！
任务B释放了12个许可！
任务A成功获取了3个许可！
任务C成功获取了7个许可！
任务C释放了7个许可！
任务A释放了3个许可！
Process finished with exit code 0
从结果可以看出，信号量仅仅是对池资源进行监控，但不保证线程的安全，因此，在使用时候，应该自己控制线程的安全访问池资源。
Java线程：新特征-阻塞队列
阻塞队列是Java5线程新特征中的内容，Java定义了阻塞队列的接口java.util.concurrent.BlockingQueue，阻塞队列的概念是，一个指定长度的队列，如果队列满了，添加新元素的操作会被阻塞等待，直到有空位为止。同样，当队列为空时候，请求队列元素的操作同样会阻塞等待，直到有可用元素为止。
有了这样的功能，就为多线程的排队等候的模型实现开辟了便捷通道，非常有用。
java.util.concurrent.BlockingQueue继承了java.util.Queue接口，可以参看API文档。
下面给出一个简单应用的例子：
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ArrayBlockingQueue;
/**
* Java线程：新特征-阻塞队列
*
* @author leizhimin 2009-11-5 14:59:15
*/
publicclass Test {
publicstaticvoid main(String[] args)throws InterruptedException
{
BlockingQueue bqueue = new ArrayBlockingQueue(20);
for (int i = 0; i < 30; i++) {
//将指定元素添加到此队列中，如果没有可用空间，将一直等待（如果有必要）。
bqueue.put(i);
System.out.println("向阻塞队列中添加了元素:" + i);
}
System.out.println("程序到此运行结束，即将退出----");
}
}
输出结果：
向阻塞队列中添加了元素:0
向阻塞队列中添加了元素:1
向阻塞队列中添加了元素:2
向阻塞队列中添加了元素:3
向阻塞队列中添加了元素:4
向阻塞队列中添加了元素:5
向阻塞队列中添加了元素:6
向阻塞队列中添加了元素:7
向阻塞队列中添加了元素:8
向阻塞队列中添加了元素:9
向阻塞队列中添加了元素:10
向阻塞队列中添加了元素:11
向阻塞队列中添加了元素:12
向阻塞队列中添加了元素:13
向阻塞队列中添加了元素:14
向阻塞队列中添加了元素:15
向阻塞队列中添加了元素:16
向阻塞队列中添加了元素:17
向阻塞队列中添加了元素:18
向阻塞队列中添加了元素:19
可以看出，输出到元素19时候，就一直处于等待状态，因为队列满了，程序阻塞了。
这里没有用多线程来演示，没有这个必要。
另外，阻塞队列还有更多实现类，用来满足各种复杂的需求：ArrayBlockingQueue, DelayQueue, LinkedBlockingQueue, PriorityBlockingQueue, SynchronousQueue，具体的API差别也很小。
Java线程：新特征-阻塞栈
对于阻塞栈，与阻塞队列相似。不同点在于栈是“后入先出”的结构，每次操作的是栈顶，而队列是“先进先出”的结构，每次操作的是队列头。
这里要特别说明一点的是，阻塞栈是Java6的新特征。、
Java为阻塞栈定义了接口：java.util.concurrent.BlockingDeque，其实现类也比较多，具体可以查看JavaAPI文档。
下面看一个简单例子：
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;
/**
* Java线程：新特征-阻塞栈
*
* @author leizhimin 2009-11-5 15:34:29
*/
publicclass Test {
publicstaticvoid main(String[] args)throws InterruptedException
{
BlockingDeque bDeque = new LinkedBlockingDeque(20);
for (int i = 0; i < 30; i++) {
//将指定元素添加到此阻塞栈中，如果没有可用空间，将一直等待（如果有必要）。
bDeque.putFirst(i);
System.out.println("向阻塞栈中添加了元素:" + i);
}
System.out.println("程序到此运行结束，即将退出----");
}
}
输出结果：
向阻塞栈中添加了元素:0
向阻塞栈中添加了元素:1
向阻塞栈中添加了元素:2
向阻塞栈中添加了元素:3
向阻塞栈中添加了元素:4
向阻塞栈中添加了元素:5
向阻塞栈中添加了元素:6
向阻塞栈中添加了元素:7
向阻塞栈中添加了元素:8
向阻塞栈中添加了元素:9
向阻塞栈中添加了元素:10
向阻塞栈中添加了元素:11
向阻塞栈中添加了元素:12
向阻塞栈中添加了元素:13
向阻塞栈中添加了元素:14
向阻塞栈中添加了元素:15
向阻塞栈中添加了元素:16
向阻塞栈中添加了元素:17
向阻塞栈中添加了元素:18
向阻塞栈中添加了元素:19
从上面结果可以看到，程序并没结束，二是阻塞住了，原因是栈已经满了，后面追加元素的操作都被阻塞了。
Java线程：新特征-条件变量
条件变量是Java5线程中很重要的一个概念，顾名思义，条件变量就是表示条件的一种变量。但是必须说明，这里的条件是没有实际含义的，仅仅是个标记而已，并且条件的含义往往通过代码来赋予其含义。
这里的条件和普通意义上的条件表达式有着天壤之别。
条件变量都实现了java.util.concurrent.locks.Condition接口，条件变量的实例化是通过一个Lock对象上调用newCondition()方法来获取的，这样，条件就和一个锁对象绑定起来了。因此，Java中的条件变量只能和锁配合使用，来控制并发程序访问竞争资源的安全。
条件变量的出现是为了更精细控制线程等待与唤醒，在Java5之前，线程的等待与唤醒依靠的是Object对象的wait()和notify()/notifyAll()方法，这样的处理不够精细。
而在Java5中，一个锁可以有多个条件，每个条件上可以有多个线程等待，通过调用await()方法，可以让线程在该条件下等待。当调用signalAll()方法，又可以唤醒该条件下的等待的线程。有关Condition接口的API可以具体参考JavaAPI文档。
条件变量比较抽象，原因是他不是自然语言中的条件概念，而是程序控制的一种手段。
下面以一个银行存取款的模拟程序为例来揭盖Java多线程条件变量的神秘面纱：
有一个账户，多个用户（线程）在同时操作这个账户，有的存款有的取款，存款随便存，取款有限制，不能透支，任何试图透支的操作都将等待里面有足够存款才执行操作。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* Java线程：条件变量
*
* @author leizhimin 2009-11-5 10:57:29
*/
publicclass Test {
publicstaticvoid main(String[] args) {
//创建并发访问的账户
MyCount myCount = new MyCount("95599200901215522", 10000);
//创建一个线程池
ExecutorService pool = Executors.newFixedThreadPool(2);
Thread t1 = new SaveThread("张三", myCount,
2000);
Thread t2 = new SaveThread("李四", myCount,
3600);
Thread t3 = new DrawThread("王五", myCount,
2700);
Thread t4 = new SaveThread("老张", myCount,
600);
Thread t5 = new DrawThread("老牛", myCount,
1300);
Thread t6 = new DrawThread("胖子", myCount,
800);
//执行各个线程
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
pool.execute(t6);
//关闭线程池
pool.shutdown();
}
}
/**
* 存款线程类
*/
class SaveThreadextends Thread {
private String name; //操作人
private MyCount myCount; //账户
privateint x; //存款金额
SaveThread(String name, MyCount myCount, int x) {
this.name = name;
this.myCount = myCount;
this.x = x;
}
publicvoid run() {
myCount.saving(x, name);
}
}
/**
* 取款线程类
*/
class DrawThreadextends Thread {
private String name; //操作人
private MyCount myCount; //账户
privateint x; //存款金额
DrawThread(String name, MyCount myCount, int x) {
this.name = name;
this.myCount = myCount;
this.x = x;
}
publicvoid run() {
myCount.drawing(x, name);
}
}
/**
* 普通银行账户，不可透支
*/
class MyCount {
private String oid; //账号
privateint cash; //账户余额
private Lock lock =new ReentrantLock(); //账户锁
private Condition _save = lock.newCondition(); //存款条件
private Condition _draw = lock.newCondition(); //取款条件
MyCount(String oid, int cash) {
this.oid = oid;
this.cash = cash;
}
/**
* 存款
*
* @param x 操作金额
* @param name 操作人
*/
publicvoid saving(int x, String name) {
lock.lock(); //获取锁
if (x > 0) {
cash += x; //存款
System.out.println(name + "存款" + x +"，当前余额为" +
cash);
}
_draw.signalAll(); //唤醒所有等待线程。
lock.unlock(); //释放锁
}
/**
* 取款
*
* @param x 操作金额
* @param name 操作人
*/
publicvoid drawing(int x, String name) {
lock.lock(); //获取锁
try {
if (cash - x < 0) {
_draw.await(); //阻塞取款操作
} else {
cash -= x; //取款
System.out.println(name + "取款" + x +"，当前余额为" +
cash);
}
_save.signalAll(); //唤醒所有存款操作
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock(); //释放锁
}
}
}
李四存款3600，当前余额为13600
张三存款2000，当前余额为15600
老张存款600，当前余额为16200
老牛取款1300，当前余额为14900
胖子取款800，当前余额为14100
王五取款2700，当前余额为11400
Process finished with exit code 0
假如我们不用锁和条件变量，如何实现此功能呢？下面是实现代码：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* Java线程：不用条件变量
*
* @author leizhimin 2009-11-5 10:57:29
*/
publicclass Test {
publicstaticvoid main(String[] args) {
//创建并发访问的账户
MyCount myCount = new MyCount("95599200901215522", 10000);
//创建一个线程池
ExecutorService pool = Executors.newFixedThreadPool(2);
Thread t1 = new SaveThread("张三", myCount,
2000);
Thread t2 = new SaveThread("李四", myCount,
3600);
Thread t3 = new DrawThread("王五", myCount,
2700);
Thread t4 = new SaveThread("老张", myCount,
600);
Thread t5 = new DrawThread("老牛", myCount,
1300);
Thread t6 = new DrawThread("胖子", myCount,
800);
//执行各个线程
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
pool.execute(t6);
//关闭线程池
pool.shutdown();
}
}
/**
* 存款线程类
*/
class SaveThreadextends Thread {
private String name; //操作人
private MyCount myCount; //账户
privateint x; //存款金额
SaveThread(String name, MyCount myCount, int x) {
this.name = name;
this.myCount = myCount;
this.x = x;
}
publicvoid run() {
myCount.saving(x, name);
}
}
/**
* 取款线程类
*/
class DrawThreadextends Thread {
private String name; //操作人
private MyCount myCount; //账户
privateint x; //存款金额
DrawThread(String name, MyCount myCount, int x) {
this.name = name;
this.myCount = myCount;
this.x = x;
}
publicvoid run() {
myCount.drawing(x, name);
}
}
/**
* 普通银行账户，不可透支
*/
class MyCount {
private String oid; //账号
privateint cash; //账户余额
MyCount(String oid, int cash) {
this.oid = oid;
this.cash = cash;
}
/**
* 存款
*
* @param x 操作金额
* @param name 操作人
*/
publicsynchronizedvoid saving(int x, String name) {
if (x > 0) {
cash += x; //存款
System.out.println(name + "存款" + x +"，当前余额为" +
cash);
}
notifyAll(); //唤醒所有等待线程。
}
/**
* 取款
*
* @param x 操作金额
* @param name 操作人
*/
publicsynchronizedvoid drawing(int x, String name) {
if (cash - x < 0) {
try {
wait();
} catch (InterruptedException e1) {
e1.printStackTrace();
}
} else {
cash -= x; //取款
System.out.println(name + "取款" + x +"，当前余额为" +
cash);
}
notifyAll(); //唤醒所有存款操作
}
}
输出结果为：
李四存款3600，当前余额为13600
王五取款2700，当前余额为10900
老张存款600，当前余额为11500
老牛取款1300，当前余额为10200
胖子取款800，当前余额为9400
张三存款2000，当前余额为11400
Process finished with exit code 0
结合先前同步代码知识，举一反三，将此例改为同步代码块来实现，代码如下：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* Java线程：改为同步代码块
*
* @author leizhimin 2009-11-5 10:57:29
*/
publicclass Test {
publicstaticvoid main(String[] args) {
//创建并发访问的账户
MyCount myCount = new MyCount("95599200901215522", 10000);
//创建一个线程池
ExecutorService pool = Executors.newFixedThreadPool(2);
Thread t1 = new SaveThread("张三", myCount,
2000);
Thread t2 = new SaveThread("李四", myCount,
3600);
Thread t3 = new DrawThread("王五", myCount,
2700);
Thread t4 = new SaveThread("老张", myCount,
600);
Thread t5 = new DrawThread("老牛", myCount,
1300);
Thread t6 = new DrawThread("胖子", myCount,
800);
//执行各个线程
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
pool.execute(t6);
//关闭线程池
pool.shutdown();
}
}
/**
* 存款线程类
*/
class SaveThreadextends Thread {
private String name; //操作人
private MyCount myCount; //账户
privateint x; //存款金额
SaveThread(String name, MyCount myCount, int x) {
this.name = name;
this.myCount = myCount;
this.x = x;
}
publicvoid run() {
myCount.saving(x, name);
}
}
/**
* 取款线程类
*/
class DrawThreadextends Thread {
private String name; //操作人
private MyCount myCount; //账户
privateint x; //存款金额
DrawThread(String name, MyCount myCount, int x) {
this.name = name;
this.myCount = myCount;
this.x = x;
}
publicvoid run() {
myCount.drawing(x, name);
}
}
/**
* 普通银行账户，不可透支
*/
class MyCount {
private String oid; //账号
privateint cash; //账户余额
MyCount(String oid, int cash) {
this.oid = oid;
this.cash = cash;
}
/**
* 存款
*
* @param x 操作金额
* @param name 操作人
*/
publicvoid saving(int x, String name) {
if (x > 0) {
synchronized (this) {
cash += x; //存款
System.out.println(name + "存款" + x +"，当前余额为" +
cash);
notifyAll(); //唤醒所有等待线程。
}
}
}
/**
* 取款
*
* @param x 操作金额
* @param name 操作人
*/
publicsynchronizedvoid drawing(int x, String name) {
synchronized (this) {
if (cash - x < 0) {
try {
wait();
} catch (InterruptedException e1) {
e1.printStackTrace();
}
} else {
cash -= x; //取款
System.out.println(name + "取款" + x +"，当前余额为" +
cash);
}
}
notifyAll(); //唤醒所有存款操作
}
}
李四存款3600，当前余额为13600
王五取款2700，当前余额为10900
老张存款600，当前余额为11500
老牛取款1300，当前余额为10200
胖子取款800，当前余额为9400
张三存款2000，当前余额为11400
Process finished with exit code 0
对比以上三种方式，从控制角度上讲，第一种最灵活，第二种代码最简单，第三种容易犯错。
Java线程：新特征-原子量
所谓的原子量即操作变量的操作是“原子的”，该操作不可再分，因此是线程安全的。
为何要使用原子变量呢，原因是多个线程对单个变量操作也会引起一些问题。在Java5之前，可以通过volatile、synchronized关键字来解决并发访问的安全问题，但这样太麻烦。
Java5之后，专门提供了用来进行单变量多线程并发安全访问的工具包java.util.concurrent.atomic，其中的类也很简单。
下面给出一个反面例子（切勿模仿）：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong;
/**
* Java线程：新特征-原子量
*
* @author leizhimin 2009-11-6 9:53:11
*/
publicclass Test {
publicstaticvoid main(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(2);
Runnable t1 = new MyRunnable("张三", 2000);
Runnable t2 = new MyRunnable("李四", 3600);
Runnable t3 = new MyRunnable("王五", 2700);
Runnable t4 = new MyRunnable("老张", 600);
Runnable t5 = new MyRunnable("老牛", 1300);
Runnable t6 = new MyRunnable("胖子", 800);
//执行各个线程
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
pool.execute(t6);
//关闭线程池
pool.shutdown();
}
}
class MyRunnableimplements Runnable {
privatestatic AtomicLong aLong =new AtomicLong(10000); //原子量，每个线程都可以自由操作
private String name; //操作人
privateint x; //操作数额
MyRunnable(String name, int x) {
this.name = name;
this.x = x;
}
publicvoid run() {
System.out.println(name + "执行了" + x +"，当前余额：" +
aLong.addAndGet(x));
}
}
运行结果：
李四执行了3600，当前余额：13600
王五执行了2700，当前余额：16300
老张执行了600，当前余额：16900
老牛执行了1300，当前余额：18200
胖子执行了800，当前余额：19000
张三执行了2000，当前余额：21000
Process finished with exit code 0
张三执行了2000，当前余额：12000
王五执行了2700，当前余额：18300
老张执行了600，当前余额：18900
老牛执行了1300，当前余额：20200
胖子执行了800，当前余额：21000
李四执行了3600，当前余额：15600
Process finished with exit code 0
张三执行了2000，当前余额：12000
李四执行了3600，当前余额：15600
老张执行了600，当前余额：18900
老牛执行了1300，当前余额：20200
胖子执行了800，当前余额：21000
王五执行了2700，当前余额：18300
Process finished with exit code 0
从运行结果可以看出，虽然使用了原子量，但是程序并发访问还是有问题，那究竟问题出在哪里了？
这里要注意的一点是，原子量虽然可以保证单个变量在某一个操作过程的安全，但无法保证你整个代码块，或者整个程序的安全性。因此，通常还应该使用锁等同步机制来控制整个程序的安全性。
下面是对这个错误修正：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.atomic.AtomicLong;
/**
* Java线程：新特征-原子量
*
* @author leizhimin 2009-11-6 9:53:11
*/
publicclass Test {
publicstaticvoid main(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(2);
Lock lock = new ReentrantLock(false);
Runnable t1 = new MyRunnable("张三", 2000,lock);
Runnable t2 = new MyRunnable("李四", 3600,lock);
Runnable t3 = new MyRunnable("王五", 2700,lock);
Runnable t4 = new MyRunnable("老张", 600,lock);
Runnable t5 = new MyRunnable("老牛", 1300,lock);
Runnable t6 = new MyRunnable("胖子", 800,lock);
//执行各个线程
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
pool.execute(t6);
//关闭线程池
pool.shutdown();
}
}
class MyRunnableimplements Runnable {
privatestatic AtomicLong aLong =new AtomicLong(10000); //原子量，每个线程都可以自由操作
private String name; //操作人
privateint x; //操作数额
private Lock lock;
MyRunnable(String name, int x,Lock lock) {
this.name = name;
this.x = x;
this.lock = lock;
}
publicvoid run() {
lock.lock();
System.out.println(name + "执行了" + x +"，当前余额：" +
aLong.addAndGet(x));
lock.unlock();
}
}
执行结果：
张三执行了2000，当前余额：12000
王五执行了2700，当前余额：14700
老张执行了600，当前余额：15300
老牛执行了1300，当前余额：16600
胖子执行了800，当前余额：17400
李四执行了3600，当前余额：21000
Process finished with exit code 0
这里使用了一个对象锁，来控制对并发代码的访问。不管运行多少次，执行次序如何，最终余额均为21000，这个结果是正确的。
有关原子量的用法很简单，关键是对原子量的认识，原子仅仅是保证变量操作的原子性，但整个程序还需要考虑线程安全的。
Java线程：新特征-障碍器
Java5中，添加了障碍器类，为了适应一种新的设计需求，比如一个大型的任务，常常需要分配好多子任务去执行，只有当所有子任务都执行完成时候，才能执行主任务，这时候，就可以选择障碍器了。
障碍器是多线程并发控制的一种手段，用法很简单。下面给个例子：
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
/**
* Java线程：新特征-障碍器
*
* @author leizhimin 2009-11-6 10:50:10
*/
publicclass Test {
publicstaticvoid main(String[] args) {
//创建障碍器，并设置MainTask为所有定数量的线程都达到障碍点时候所要执行的任务(Runnable)
CyclicBarrier cb = new CyclicBarrier(7,new MainTask());
new SubTask("A", cb).start();
new SubTask("B", cb).start();
new SubTask("C", cb).start();
new SubTask("D", cb).start();
new SubTask("E", cb).start();
new SubTask("F", cb).start();
new SubTask("G", cb).start();
}
}
/**
* 主任务
*/
class MainTask implements Runnable {
publicvoid run() {
System.out.println(">>>>主任务执行了！<<<<");
}
}
/**
* 子任务
*/
class SubTask extends Thread {
private String name;
private CyclicBarrier cb;
SubTask(String name, CyclicBarrier cb) {
this.name = name;
this.cb = cb;
}
publicvoid run() {
System.out.println("[子任务" + name +"]开始执行了！");
for (int i = 0; i < 999999; i++) ; //模拟耗时的任务
System.out.println("[子任务" + name +"]开始执行完成了，并通知障碍器已经完成！");
try {
//通知障碍器已经完成
cb.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}
}
运行结果：
[子任务E]开始执行了！
[子任务E]开始执行完成了，并通知障碍器已经完成！
[子任务F]开始执行了！
[子任务G]开始执行了！
[子任务F]开始执行完成了，并通知障碍器已经完成！
[子任务G]开始执行完成了，并通知障碍器已经完成！
[子任务C]开始执行了！
[子任务B]开始执行了！
[子任务C]开始执行完成了，并通知障碍器已经完成！
[子任务D]开始执行了！
[子任务A]开始执行了！
[子任务D]开始执行完成了，并通知障碍器已经完成！
[子任务B]开始执行完成了，并通知障碍器已经完成！
[子任务A]开始执行完成了，并通知障碍器已经完成！
>>>>主任务执行了！<<<<
Process finished with exit code 0
从执行结果可以看出，所有子任务完成的时候，主任务执行了，达到了控制的目标