Java编程思想,并发编程学习笔记.
一.基本的线程机制
1.定义任务:Runnable接口
线程可以驱动任务,因此需要一种描述任务的方式,这可以由Runnable接口来提供.要想定义任务,只需实现Runnable接口并编写run方法,使得该任务可以执行你的命令.
class MyTask implements Runnable {
private String mName;
public MyTask(String name) {
mName = name;
}
@Override
public void run() {
System.out.println(mName + " run in thread pid is " + Thread.currentThread().getId());
}
}
2.使用Thread
将Runnable对象转变为工作任务的传统方式是把它提交给一个Thread构造器.
Thread thread = new Thread(new MyTask("Thread"));
thread.start();
// Thread run in thread pid is 9
3.使用Executor
java.util.concurrent包中的执行器将为你管理Thread对象,从而简化并发编程.Executor允许管理异步任务的执行,而无须管理线程的生命周期.是启动任务的优选方法.
ExecutorService cachedExecutor = Executors.newCachedThreadPool();
for (int i = 0; i < 3; i++)
cachedExecutor.execute(new MyTask("Cached executor " + i));
cachedExecutor.shutdown();
ExecutorService exec = Executors.newFixedThreadPool(2);
for (int i = 0; i < 3; i++)
exec.execute(new MyTask());
ExecutorService singleExcutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 3; i++)
singleExcutor.execute(new MyTask("Single executor " + i));
singleExcutor.shutdown();
输出结果:
Cached executor 0 run in thread pid is 10
Cached executor 1 run in thread pid is 11
Cached executor 2 run in thread pid is 12
Fixed executor 0 run in thread pid is 13
Fixed executor 1 run in thread pid is 14
Fixed executor 2 run in thread pid is 13
Single executor 0 run in thread pid is 15
Single executor 1 run in thread pid is 15
Single executor 2 run in thread pid is 15
newCachedThreadPool:将为每一个任务分配一个线程.通常在程序执行过程中会创建与所需任务相同的线程,然后在它回收旧线程时停止创建新线程,因此它是Executor的首选.
newFixedThreadPool:将一次性预先执行线程分配,预先分配需要高昂的代价,但可以限制线程的数量,不用为每个任务都付出创建线程的开销.
newSingleThreadExecutor:如同数量为1的newFixedThreadPool.每一个任务都按照提交给它的顺序执行,因此它会序列化提交给他的任务,并维护自己的悬挂任务队列.
shutdown方法将防止新任务被提交给这个Executor,当前任务将继续运行shutdown被调用之前提交的所有任务.程序将在Executor中所有的任务完成之后退出.
4.从任务中产生返回值
使用Callable接口代替Runable接口,可取得返回值.Callable是一种具有参数类型的泛型,它的参数类型表示的是从call方法中返回的值,并且需要使用ExecutorService的submit方法调用它.
class TaskWithResult implements Callable<String> {
private String mName;
public TaskWithResult(String name) {
mName = name;
}
@Override
public String call() throws Exception {
return "Result -> " + mName + " " + Thread.currentThread().getId();
}
}
ExecutorService exec = Executors.newCachedThreadPool();
Future<String> future = exec.submit(new TaskWithResult("t"));
System.out.println(future.get());
exec.shutdown();
5.休眠
Thread类的sleep方法,将暂停给定的时间(ms).
TimeUnit类允许延迟指定时间单位的时间.如
TimeUnit.SECONDS.sleep(1);
TimeUnit.MILLISECONDS.sleep(1);
使用休眠方法,使得线程调度器从一个线程切换到另一个线程,进而驱动另一个任务.
但是这种顺序依赖于底层的线程机制,因此顺序执行的任务不能依赖于此类方法的调用,应该手动编写自己的协作例程,这些例程按照指定的顺序在相互之间传递控制权.
6.优先级
线程的优先级该线程的重要性传递给了调度器,调度器优先让优先级最高的线程优先执行,但这并不是意味着优先级较低的线程得不到执行,即优先级不会导致死锁.优先级低的线程仅仅只是执行的频率较低.
可以使用getPriority和setPriority方法来获取和修改优先级.如,Thread.currentThread().getPriority()
7.让步
调用yield方法让具有相同优先级的线程可以运行.这个操作只是建议上的.
但是对于重要的控制或在调整应用时都不能依赖于yield方法.原理上同使用sleep方法一样.
8.后台线程
后台(Daemon)线程,是指程序运行的时候在后台提供一种通用服务的线程,这种线程并不属于程序中不可或缺的一部分.
当所有非后台线程结束时,程序也就终止了,此时会杀掉所有的后台线程.
必须在线程启动之前(调用start方法前)调用setDaemon方法,才能将一个线程设置为后台线程.
一个后台线程创建的任何线程都将被自动设置为后台线程.可调用isDaemon方法来确定线程是否是一个后台线程.
9.编码的变体
直接使用Thread类创建任务.
Thread类实现了Runable接口,可直接继承自Thread类,重写run方法,实现任务.
class SimpleThread extends Thread {
@Override
public void run() {
super.run();
System.out.println("haha pid:" + getId());
}
}
另一种惯用法是自管理的Runable.
class SelfManage implements Runnable {
private Thread thread = new Thread(this);
public SelfManage() { thread.start(); }
@Override
public void run() {
System.out.println("self manage thread pid is " + Thread.currentThread().getId());
}
}
或者使用内部类或匿名内部类将线程隐藏在代码中.
public void startThread() {
Thread t = new Thread() {
@Override
public void run() {
super.run();
System.out.println("inner thread tid is " + Thread.currentThread().getId());
}
};
t.start();
}
10.加入一个任务
一个线程可以调用其它线程的join方法,其效果是该线程将等待被调用join方法的线程结束,才继续运行.
class Sleeper extends Thread {
@Override
public void run() {
System.out.println("Sleeper run begin");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("Sleeper run out");
}
}
class Joiner extends Thread {
private final Thread joinerThread;
public Joiner(Thread joiner) { joinerThread = joiner; }
@Override
public void run() {
System.out.println("joiner run begin");
try {
joinerThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("joiner run out");
}
}
Thread t = new Sleeper();
t.start();
new Joiner(t).start();
join方法有带参数的版本,参数表示超时的时间,如果被调用的线程超时未返回,将停止等待.
public final synchronized void join(long millis) throws java.lang.InterruptedException;
public final synchronized void join(long millis, int nanoseconds) throws java.lang.InterruptedException;
public final void join() throws java.lang.InterruptedException;
其中millis为毫秒,nanoseconds为纳秒.
11.线程异常捕获
Thread类的setUncaughtExceptionHandler方法,允许设置一个异常处理器,在发生未捕获的异常时,调用异常处理器的uncaughtException方法.
方法声明 public void setUncaughtExceptionHandler(java.lang.Thread$UncaughtExceptionHandler);
class ExceptionThread extends Thread {
@Override
public void run() {
System.out.println("Thread " + getId() + " will throw excetion.");
throw new RuntimeException("This is a exception!");
}
}
ExceptionThread eThread = new ExceptionThread();
eThread.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
@Override
public void uncaughtException(Thread thread, Throwable arg1) {
System.out.println("catch exception! thead id is " + thread.getId());
}
});
eThread.start();
二.共享受限资源(同步)
基本上并发模式在解决线程冲突问题时,都是采用序列化访问共享资源的方案.通常是通过在代码前面加上一条锁语句来实现,这就使得在一段时间内只有一个任务可以运行这段代码.因为锁语句产生了一种互斥效果,所以这种机制常常称作互斥量(Mutex).
共享资源一般是以对象存在的内存片段,或者是文件,输入输出端口,打印机等.要控制对共享资源的访问,首先需要把它包装进一个对象.
1.同步规则
Brian的同规则:如果正在写一个变量,它可能接下来将被另一个线程读取,或者正在读取一个上一次已经被另一个线程写过的变量,那么此时必须使用同步,并且读写的代码都必须使用相同的监视器锁进行同步.
2.synchronized
java以synchronized提供内置支持以防止资源冲突.当任务要执行被synchronized保护的资源时,它将检查锁是否可用,然后获取锁,执行代码,释放锁.
所有对象都含有单一的锁,当在对象上调用sychronized方法时,此对象都会被加锁,该对象上的其它synchronized方法只有等到前一个方法调用完毕并释放了锁以后才能被调用.
一个任务可以多次获得对象的锁.最开始对象的计数为0;每当这个任务在这个对象上获得锁时,计数增加1;离开synchronized方法时减1.计数为0时,锁被释放,其它任务就可以使用此资源.
针对每个类也有一个锁,作为类的Class对象的一部分,所有synchronized static方法也可以在类的范围内防止对static数据的并发访问.
3.使用显示的Lock对象
private java.util.concurrent.locks.Lock lock = new java.util.concurrent.locks.ReentrantLock();
public void lockFunction() {
lock.lock();
try {
System.out.println("locked");
} finally {
lock.unlock();
}
}
如果使用synchronized同步一个方法,那么在方法在某些情况下失败了,可能抛出了一个异常,此时将没有任何机会去做清理工作,以恢复状态.如果使用Lock对象,就可以在finally中将系统的状态正确恢复了.
如果要实现尝试获取锁,或者尝试在一段时间内获取锁,则必须使用Lock对象,synchronized不能实现此类功能.
public void test() {
untimed();
timed();
new Thread() {
@Override
public void run() {
lock.lock();
System.out.println("lock but not unlock it.");
}
}.start();
Thread.yield();
untimed();
timed();
}
private java.util.concurrent.locks.Lock lock = new java.util.concurrent.locks.ReentrantLock();
public void untimed() {
boolean captured = lock.tryLock();
try {
System.out.println("tryLock(): " + captured);
} finally {
if (captured)
lock.unlock();
}
}
public void timed() {
boolean captured = false;
try {
captured = lock.tryLock(1, TimeUnit.SECONDS);
System.out.println("tryLock(): " + captured);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (captured)
lock.unlock();
}
}
4.原子性和易变性
原子操作是不能被线程调度机制中断的操作,一旦操作开始,那么它一定可以在可能发生的上下文切换(切换到其它线程)之前执行完毕.
原子性保证,对于除long和double以外的所有基本类型变量,读取和写入这样的操作,它们会被当作不可分(原子)的操作来操作内存.Java SE5开始,当你定义long或double时,使用关键字volatile,就会获得原子性(简单的赋值和返回操作).
volatile确保了应用中的可视性.一个域如果被声明为volatile,那么只要产生了写操作,那么所有的读操作都可以看到这个修改.
volatile使用规则:如一个域可能被多个任务同时访问,就应当是volatile的;如果一个域由同步块来保护,那么就不需要声明为volatile.如果一个域只需要在某个任务内可见,那么就不需要声明为volatile.
volatile无法工作的情况:一个域的值依赖于它之前的值(如递增计数器);某个域的值受到其它域的值限制(如Range类的).
使用volatile而不是synchronized的唯一安全选择是,类中只有一个可变的域.因此应尽量使用synchronized进行保护.
原子操作:对域中的值作赋值或返回操作.java中自增运算或+=都不是原子操作.
5.临界区
使用多个线程同时访问方法内的一部分代码而不是整个方法,通过这种方法分离出来的代码段就是临界区.它也是使用synchronized建立.也可以显示的使用Lock对象建立.
synchronized(syncObject) {
// ...
}
三.终止任务
1.线程的状态
新建(new):当一个线程被创建时短暂的处于这个状态,此时已经为它分配了必须的系统资源并进行了初始化,有资格获得时间片,此后调度器将把它转为可运行状态或阻塞状态.
就绪(Runable):只要调度器分配时间片就可以运行的状态,即此时可运行或不运行.
阻塞(Blocked):能够运行但有某个条件阻止它运行的状态.调度器不会给他分配时间片直到进入了就绪状态.
死亡(Dead):死亡或终止状态不再可调度,不可能再获得时间片.任务已结束,或不再可运行,通常是由于run返回,或任务的线程被中断.
2.进入阻塞状态
进入阻塞状态通常有以下原因
调用sleep方法,这种情况下任务在指定的时间内不能运行.
调用wait方法,还没有收到notify或notifyAll的通知(或者SE5中的signal或signalAll)而进入就绪状态.
进入同步代码,但未获得锁.
等待输入输出完成.
注意:使用suspend和resume也会阻塞和唤醒线程,但会导致死锁,因此被废弃了.stop方法也被废弃了,因为他不能释放锁.
3.中断
(1)对Thread对象,调用interrupt方法,可以终止被阻塞的任务,并设置中断状态.如果一个线程已经被阻塞,或试图执行一个阻塞操作,那么设置这个中断状态将抛出InterruptException异常.当抛出该异常或调用Thread.interrupted方法时,将清除该状态.
(2)对Executor对象,调用shotdownNow方法,那么将给Executor启动的所有线程调用interrupt方法.如果使用的是submit方法启动的线程,使用submit返回的Future对象来调用cancel方法,传入true,可以中断该任务.cancel是中断Executor启动的单个线程的方式.
四.线程之间的协作
线程之间的协作,指多个任务一起工作去解决某个问题.这样,问题不是相互干涉,而是彼此之间的协调,因为这类问题中,某些部分必须在其它部分解决之后解决.
1.wait()和notifyAll()方法
wait提供了任务之间对活动同步的方式.wait等待某个条件发生变化,这种条件由别的任务来提供.wait只有当收到notify或notifyAll时,才被唤醒.
调用wait时,线程的执行被挂起,对象上的锁被释放.
public final void wait() throws InterruptedException;
public final void wait(long timeout) throws InterruptedException;
在wait期间,对象上的锁被释放; notify或notifyAll时,从wait中恢复执行.执行带参数版本的wait时,超时后从wait中恢复执行.
注意:wait(),notify(),notifyAll()方法只能在同步代码块中调用.否则,运行时将抛出IllegalMonitorStateException异常,这表示,调用这些方法必须拥有对象的锁.
2.await()和signalAll()方法
通过Lock对象的newCondition()方法,可创建一个Condition对象,Condition类使用互斥并允许任务挂起.
Condition对象的awati和signalAll方法,可用来挂起和唤醒这个Condition对象上的任务.与notifyAll相比,signalAll是更安全的方式.
一个线程协作的例子,演示一直开关灯的事件:
interface Light {
void open();
void close();
void waitForOpen() throws InterruptedException;
void waitForClose() throws InterruptedException;
}
class SyncLight implements Light {
private boolean mIsOpen;
public synchronized void open() {
mIsOpen = true;
notifyAll();
}
public synchronized void close() {
mIsOpen = false;
notifyAll();
}
public synchronized void waitForOpen() throws InterruptedException {
while (mIsOpen == false)
wait();
}
public synchronized void waitForClose() throws InterruptedException {
while (mIsOpen == true)
wait();
}
}
class LockLight implements Light {
private boolean mIsOpen;
private Lock mLock = new ReentrantLock();
private Condition mCondition = mLock.newCondition();
public void open() {
mLock.lock();
try {
mIsOpen = true;
mCondition.signalAll();
} finally {
mLock.unlock();
}
}
public void close() {
mLock.lock();
try {
mIsOpen = false;
mCondition.signalAll();
} finally {
mLock.unlock();
}
}
public void waitForOpen() throws InterruptedException {
mLock.lock();
try {
while (mIsOpen == false)
mCondition.await();
} finally {
mLock.unlock();
}
}
public void waitForClose() throws InterruptedException {
mLock.lock();
try {
while (mIsOpen == true)
mCondition.await();
} finally {
mLock.unlock();
}
}
}
class OpenLight implements Runnable {
Light mLight;
public OpenLight(Light light) {
mLight = light;
}
@Override
public void run() {
try {
while (!Thread.interrupted()) {
TimeUnit.MILLISECONDS.sleep(10);
System.out.print("Open light! ");
mLight.open();
mLight.waitForClose();
}
} catch (InterruptedException e) {
System.out.println("exit...open");
}
}
}
class CloseLight implements Runnable {
Light mLight;
public CloseLight(Light light) {
mLight = light;
}
@Override
public void run() {
try {
while (!Thread.interrupted()) {
mLight.waitForOpen();
TimeUnit.MILLISECONDS.sleep(10);
System.out.print("Close light! ");
mLight.close();
}
} catch (InterruptedException e) {
System.out.println("exit...close");
}
}
}
public class ThreadCooperation {
public static void main(String[] args) throws InterruptedException {
// Light light = new LockLight();
Light light = new SyncLight();
ExecutorService service = Executors.newCachedThreadPool();
service.execute(new CloseLight(light));
service.execute(new OpenLight(light));
TimeUnit.SECONDS.sleep(1);
service.shutdownNow();
}
}
3.解决带循环的语句,不同步的问题:将循环写到同步块中.
synchronized(object) {
while(condition) {
// do something;
}
}
五.其它类及其方法
Thread类
Thread类自身不执行任何操作,它只是驱动赋予它的任务.创建线程可能是一个高昂的代价,因此必须保存并管理它们.
1.start方法: 用来启动一个线程，当调用start方法后，系统才会开启一个新的线程来执行用户定义的子任务，在这个过程中，会为相应的线程分配需要的资源.
public synchronized void start();
2.yield方法: 切换线程函数,调用此方法建议线程调度器可以将CPU从一个线程转移给另一个线程.
public static native void yield();
3.interrupt方法: 中断一个线程.调用此方法时,将给线程设置一个标志,表明该线程已被中断.然而异常捕获时将清理这个标志.因此在异常被捕获后,再调用isInterrupted将返回false,而异常代码处理中则为true.
isInterrupted方法: 判断一个线程是否被中断.
interrupted方法: 检查中断状态,并清除中断状态.
public void interrupt();
public boolean isInterrupted();
注:interrupt方法,可以终止被阻塞的任务,并设置中断状态.如果一个线程已经被阻塞,或试图执行一个阻塞操作,那么设置这个中断状态将抛出InterruptException异常.
4.isAlive方法:判断线程是否已运行.调用start方法后,返回true; run结束后返回false.如果被强制中断,仍返回true
public final native boolean isAlive();
ExecutorService类
awaitTermination方法:等待每一个任务结束,如果所有任务在超时时间内结束,则返回true,否则返回false,表示不是所有任务都结束了.
public abstract boolean awaitTermination(long, java.util.concurrent.TimeUnit) throws java.lang.InterruptedException;
shutdownNow方法,那么将给Executor启动的所有线程调用interrupt方法
public abstract java.util.List<java.lang.Runnable> shutdownNow();