所谓的原子量即操作变量的操作是“原子的”,该操作不可再分,因此是线程安全的。
为何要使用原子变量呢,原因是多个线程对单个变量操作也会引起一些问题。在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,这个结果是正确的。
有关原子量的用法很简单,关键是对原子量的认识,原子仅仅是保证变量操作的原子性,但整个程序还需要考虑线程安全的。
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
从执行结果可以看出,所有子任务完成的时候,主任务执行了,达到了控制的目标。
面试题:
Java中创建线程主要有三种方式:
一、继承Thread类创建线程类
(1)定义Thread类的子类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。
(2)创建Thread子类的实例,即创建了线程对象。
(3)调用线程对象的start()方法来启动该线程。
上述代码中Thread.currentThread()方法返回当前正在执行的线程对象。GetName()方法返回调用该方法的线程的名字。
二、通过Runnable接口创建线程类
(1)定义runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。
(2)创建 Runnable实现类的实例,并依此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。
(3)调用线程对象的start()方法来启动该线程。
示例代码为:
三、通过Callable和Future创建线程
(1)创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,并且有返回值。
(2)创建Callable实现类的实例,使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值。
(3)使用FutureTask对象作为Thread对象的target创建并启动新线程。
(4)调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
实例代码:
二、创建线程的三种方式的对比
采用实现Runnable、Callable接口的方式创见多线程时,优势是:
线程类只是实现了Runnable接口或Callable接口,还可以继承其他类。
在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码和数据分开,形成清晰的模型,较好地体现了面向对象的思想。
劣势是:
编程稍微复杂,如果要访问当前线程,则必须使用Thread.currentThread()方法。
使用继承Thread类的方式创建多线程时优势是:
编写简单,如果需要访问当前线程,则无需使用Thread.currentThread()方法,直接使用this即可获得当前线程。
劣势是:
线程类已经继承了Thread类,所以不能再继承其他父类。