十分钟掌握java多线程进阶

一、线程的实现

继承thread类重写run()方法和实现Runnable接口实现run()方法

注意点：1、new一个线程实例时建议都要加个线程名方便监控和排查问题；

如new Thread("thread name")或thread.setName("thread name");

2、要处理线程的中断异常（InterruptedException）；

如if (Thread.interrupted()) {

//do someting

};

或

Try{}

catch (InterruptedException e) {

//do someting

}

二、ThreadLocal

ThreadLocal源码详见文档ThreadLocal.java；

顾名思义它是local variable（线程局部变量）。它的功用非常简单，就是为每一个使用该变量的线程都提供一个变量值的副本，是每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。从线程的角度看，就好像每一个线程都完全拥有该变量。

注意：使用ThreadLocal，一般都是声明在静态变量中，如果不断的创建ThreadLocal而且没有调用其remove方法，将会导致内存泄露。如果是static的ThreadLocal，一般不需要调用remove。

三、线程的同步与锁

1、synchronized

public synchronized void xxx() {

System.out.println(“处理业务”);

}

等同于

public void xxx() {

synchronized (this) {

System.out.println(“处理业务”);

}

}

一般建议使用独立的对象锁，不要直接用当前对象的锁，如

public classSharedData{

private int a = 0;

private int b = 0;

public synchronized void setA(int a) { this.a = a; }

public synchronized void setB(int b) { this.b = b; }

}

若同步整个方法，则setA()的时候无法setB()，setB()时无法setA()。为了提高性能，可以使用不同对象的锁：

public classSharedData{

private int a = 0;

private int b = 0;

private Object syncA= new Object();

private Object syncB= new Object();

public void setA(int a) {

synchronized(syncA) {

this.a = a;

}

}

public void setB(int b) {

synchronized(syncB) {

this.b = b;

}

}

}

如果将synchronized关键字标记在静态方法上，由于静态方法不可能访问this实例，那么，锁住的是哪个对象呢？是当前类的Class对象，原因是每个对象的Class实例是唯一且不可变的。比如：

public synchronized static void sync() { ... }

事实上完全等同于下面的写法：

public static void sync() {

synchronized(SharedData.class) {

...

}

}

Synchronized的同步方法和代码块在多线程中各线程才会相互竞争对象锁，非同步方法不会竞争对象锁。

2、读写锁ReadWriteLock

为了提高性能，Java5提供了读写锁，在读的地方使用读锁，在写的地方使用写锁，灵活控制，在一定程度上提高了程序的执行效率。

Java中读写锁有个接口java.util.concurrent.locks.ReadWriteLock，也有具体的实现ReentrantReadWriteLock，详细的API可以查看JavaAPI文档。

一般建议使用读写锁ReadWriteLock。

四、线程的调度

1、wait/（notify/notifyAll()）机制

通常，多线程之间需要协调工作。例如，浏览器的一个显示图片的线程displayThread想要执行显示图片的任务，必须等待下载线程 downloadThread将该图片下载完毕。如果图片还没有下载完，displayThread可以暂停，当downloadThread完成了任务后，再通知displayThread“图片准备完毕，可以显示了”，这时，displayThread继续执行。

以上逻辑简单的说就是：如果条件不满足，则等待。当条件满足时，等待该条件的线程将被唤醒。在Java中，这个机制的实现依赖于wait/notify。等待机制与锁机制是密切关联的。例如：

synchronized(obj) {

while(!condition) {

obj.wait();

}

obj.doSomething();

}

当线程A获得了obj锁后，发现条件condition不满足，无法继续下一处理，于是线程A就wait()。

在另一线程B中，如果B更改了某些条件，使得线程A的condition条件满足了，就可以唤醒线程A：

synchronized(obj) {

condition = true;

obj.notify();

}

需要注意：

1、调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) {...} 代码段内。

2、调用obj.wait()后，线程A就释放了obj的锁，否则线程B无法获得obj锁，也就无法在synchronized(obj) {...} 代码段内唤醒A。

3、当obj.wait()方法返回后，线程A需要再次获得obj锁，才能继续执行。

4、如果A1,A2,A3都在obj.wait()，则B调用obj.notify()只能唤醒A1,A2,A3中的一个（具体哪一个由JVM决定）。

5、obj.notifyAll()则能全部唤醒A1,A2,A3，但是要继续执行obj.wait()的下一条语句，必须获得obj锁，因此，A1,A2,A3只有一个有机会获得锁继续执行，例如A1，其余的需要等待A1释放obj锁之后才能继续执行。

6、当B调用obj.notify/notifyAll的时候，B正持有obj锁，因此，A1,A2,A3虽被唤醒，但是仍无法获得obj锁。直到B退出synchronized块，释放obj锁后，A1,A2,A3中的一个才有机会获得锁继续执行。

2、wait/sleep的区别

Thread还有一个sleep()静态方法也能使线程暂停一段时间。sleep与wait的不同点是：sleep并不释放锁，并且sleep的暂停和wait暂停是不一样的。obj.wait会使线程进入obj对象的等待集合中并等待唤醒。但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException。

如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在 wait/sleep/join，则线程B会立刻抛出InterruptedException，在catch() {} 中直接return即可安全地结束线程。需要注意的是，InterruptedException是线程自己从内部抛出的，并不是interrupt()方法抛出的。对某一线程调用 interrupt()时，如果该线程正在执行普通的代码，那么该线程根本就不会抛出InterruptedException。但是，一旦该线程进入到 wait()/sleep()/join()后，就会立刻抛出InterruptedException。

3、线程的让步yield()和合并join()

线程的让步含义就是使当前运行着线程让出CPU资源，但是然给谁不知道，仅仅是让出，线程状态回到可运行状态。

线程的让步使用Thread.yield()方法，yield() 为静态方法，功能是暂停当前正在执行的线程对象，并执行其他线程。

线程的合并的含义就是将几个并行线程的线程合并为一个单线程执行，应用场景是当一个线程必须等待另一个线程执行完毕才能执行时可以使用join方法。

五、阻塞队列

阻塞队列是Java5线程新特征中的内容，Java定义了阻塞队列的接口java.util.concurrent.BlockingQueue，阻塞队列的概念是，一个指定长度的队列，如果队列满了，添加新元素的操作会被阻塞等待，直到有空位为止。同样，当队列为空时候，请求队列元素的操作同样会阻塞等待，直到有可用元素为止。

有了这样的功能为多线程的排队等候的业务场景开辟了便捷通道，非常有用。

java.util.concurrent.BlockingQueue继承了java.util.Queue接口，可以参看API文档。

下面给出一个简单应用的例子：

publicclassTest {

publicstaticvoidmain(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("程序到此运行结束，即将退出----");

}

}

可以看出，输出到元素19时候，就一直处于等待状态，因为队列满了，程序阻塞了。

另外，阻塞队列还有更多实现类，用来满足各种复杂的需求：ArrayBlockingQueue, DelayQueue, LinkedBlockingQueue, PriorityBlockingQueue, SynchronousQueue ，具体的API差别也很小。

六、线程池和有返回值的线程

Executors：ExecutorService和Future

1、线程池

//创建一个可重用固定线程数的线程池

ExecutorService pool =Executors.newFixedThreadPool(2);

//创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。

ExecutorService pool =Executors.newSingleThreadExecutor();

//创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。

ExecutorService pool = Executors.newCachedThreadPool();

//创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);

//创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。

ScheduledExecutorService pool = Executors.newSingleThreadScheduledExecutor();

//创建等待队列

BlockingQueue bqueue = new ArrayBlockingQueue(20);

//创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。

ThreadPoolExecutor pool = new ThreadPoolExecutor(2,3,2,TimeUnit.MILLISECONDS,bqueue);

2、有返回值的线程（Future）

Future的主要方法：

boolean cancel (boolean mayInterruptIfRunning) 取消任务的执行。参数指定是否立即中断任务执行，或者等等任务结束

boolean isCancelled () 任务是否已经取消，任务正常完成前将其取消，则返回 true

boolean isDone () 任务是否已经完成。需要注意的是如果任务正常终止、异常或取消，都将返回true

V get () throws InterruptedException, ExecutionException 等待任务执行结束，然后获得V类型的结果。InterruptedException 线程被中断异常， ExecutionException任务执行异常，如果任务被取消，还会抛出CancellationException

V get (long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException 同上面的get功能一样，多了设置超时时间。参数timeout指定超时时间，uint指定时间的单位，在枚举类TimeUnit中有相关的定义。如果计算超时，将抛出TimeoutException

---

文/老猿，写代码写诗写职场的程序猿大叔，转载此文请联系老猿。