《java并发编程实战》读书笔记——基础知识

1。Servlet是非线程安全的。

避免在servlet类中定义未受锁保护的属性

public class unsafe implements servlet {//加入这个属性后，servlet不再是无状态了。多线程同时访问count对象会出现线程安全问题private long count = 0;public long getCount(){  return count;} public void service(..){  .... }}

2。当代码逻辑的正确性取决于多个线程的交替执行的时序时，就会出现竞争条件。

最常见的就是：“先检查后操作”，当其中一个线程通过检查，准备进行操作的时候，要操作的变量可能在这期间被别的线程改变了。

解决方法：a)使用原子操作 b)加锁

3。如果只是将每个方法都作为同步方法，例如Vector，那么不足以保证Vector上的复合操作都是原子的。

还是“先检查后操作”的例子。

if(vector.contains(element)){    vector.add(element)}

线程1：获得锁，检查通过vector不包含element，释放锁—————————------------——————————————————>获得锁，vector.add(element)，释放锁

线程2：                                                                                      获得锁，检查通过vector不包含element，vector.add(element)，释放锁

所以虽然synchronized可以确保单个操作的原子性，但如果把多个操作作为一个复合操作需要额外的加锁

线程1：获得锁，检查通过vector不包含element，vector.add(element)，释放锁

线程2：                                                                                                                               获得锁，检查通过vector已经包含element，释放锁

4。内存可见性问题。

在一些场合需要当一个线程修改了一个对象的状态以后，需要其他所有的线程都能立马的看到这个对象的变化。

举一个不安全的例子：

public class UnsafeClass{ private static boolean flag; private static int num; private static class ReaderThread extend Thread{   public void run(){    while(!flag)      Thread.yield();    System.out.println(num);   }  }  public static void main(){   new ReaderThread().start();   number = 42;   flag = true; } }

书本原话：上面这个class可能会永远运行下去。我猜这句话是因为主线程里面修改完flag=true后，并没有立刻写入到主存，即使写入后，ReaderThread也并没有立刻去主存读取并把存储在ReaderThread线程栈中的flag=false更新为true，导致ReaderThread的栈线程里读到的flag一直是false。

还有可能是print出来的num是0：这是因为JVM为了充分地利用现代多核处理器的强大性能。例如，在缺少同步的情况下，Java内存模型允许编译器对操作顺序进行重排序。此外，它还允许CPU对操作顺序进行重排序。

所以有可能被重排序后变成：

new ReaderThread().start();
falg = true;
number = 42;

那么为了解决上面的现象：

一。Synchronize不用说了

二。Volatile，它的作用是：

①加入内存栅栏，强迫改动里面生效，从缓存中立马写入到主存，并使其他线程保存的这个变量的缓存失效，迫使其他线程从内存中取得这个变量的最新值

②使jvm不对改变量上的操作与其他内存操作进行重排序。

5。注意“this引用溢出”

如果，在构造函数A中启动一个线程时，无论这个线程是显示创建（直接在构造函数中创建一个线程），还是隐式创建（线程作为传入构造函数的参数对象的一个内部类），

A类的引用都会被新创建的线程共享。也就是新创建的线程可以调用A类中的方法和属性。使用外部类名称.this就可以在内部类中引用外部类的对象了

例子：

class Escape {private String a = null;public Escape(){new Thread(new Runnable(){@Overridepublic void run() {//注意，它能直接调用到Escape类中的doSomething()函数，从而打印出了还没有初始化完的a对象doSomething();//它能直接调用到Escape类中的a属性System.out.println(a);}}).start();try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}//这个时候a才初始化完a = "finish";}private void doSomething(){System.out.println(a);}}public class ThisEscape{public static void main(String args[]){Escape demo = new Escape();}}

最后print出来的结构是

null

null

因为在Escape类的构造函数的创建的线程对象 调用了Escape还没有初始化完成的a对象

6。ThreadLocal类

ThreadLocal提供了get与set等访问接口或方法，这些方法为每个使用该变量的线程都存有一份独立的副本，因此get总是能放回当前线程在调用set时设置的最新值，

从概念上可以将ThreadLocal<T>视为包含了Map<Thread,T>的一个对象，其中保存了特定于该线程的值，但ThreadLocal的实现并非如此。这些特定于线程的值都保存在Thread对象中，当线程终止后，这些值会作为垃圾回收

如下为ThreadLocal.set()方法java源码：

public void set(T value) {        Thread t = Thread.currentThread();        ThreadLocalMap map = getMap(t);        if (map != null)            map.set(this, value);        else            createMap(t, value);}

7。同步容器的替代者

同步容器类包括 Vector和HashTable，以及使用Collections.synchronizedXxx等工厂方法创建的同步类。

这些同步容器类的特点是：每个公有的方法都进行同步，使得每次只有一个线程能够访问容器的状态。

同步容器类的问题：由于只是在类中的每单个函数上进行了同步，那么在进行需要多个函数参与的复合操作的时候，比如“若没有则添加”，就会出现问题。

需要在最外层加锁：

public class Test {Vector vector = new Vector();public void ifNotAddSafe(String value){synchronized(vector){if(!vector.contains(value)){vector.add(value);}}}}

并且在迭代vector容器的时候，如果有其他线程对vector里面的内容做了修改就会出错

所以需要做迭代操作的时候也在最外层加锁

public class Test {Vector vector = new Vector();public void iteratorSafe(){synchronized (vector) {for(int i=0;i<vector.size();i++){....}}}}

还有一个方法就是每次进行迭代操作的时候，对vector复制一个副本，对副本进行迭代（不过在克隆的过程中仍然需要对容器加锁）

针对上面各种问题，java5.0提供了多种并发容器来改进同步容器在多线程并发环境中的使用性能。

增加了ConcurrentHashMap 替代 同步且基于散列的Map（《ConcurrentHashMap分析》）

CopyOnWriteArrayList 用于在遍历操作为主要操作的情况下代替同步的List。

在每次对容器做出修改时，都会创建并重新发布一个新的容器副本，在修改前对容器进行迭代的其他线程就不会出现错误

在新的ConcurrentMap接口中增加了对一些常见的复合操作的支持，比如“若没有则添加”

8。同步工具类

同步工具类的定义：同步工具类可以是任何一个对象，只要它根据自身的状态来协调线程的控制流（比如阻塞队列BlockingQueue有full和empty两个状态，当full时put的操作会被阻塞，等待空位），那么阻塞队列可以作为同步工具类，其他类型的同步工具类还有 信号量（Semaphore）、栅栏（Barrier）以及闭锁（Latch）等等

1.闭锁

闭锁相当于一扇门，在门没有打开之前任何线程都不能开始执行，一旦门打开，所有线程同时开始执行。

应用场景（例子）：

• 确保某个计算在其所需要的所有资源都被初始化完了以后才开始执行
• 确保某个服务在其所依赖的所有其他服务都已经启动之后才启动。
• 等待直到某个操作的所有参与者都就绪再继续执行。

闭锁的java实现类是java.util.concurrent.CountDownLatch

闭锁包括一个计数器 private volatile int state 该计数器被初始化为一个正数，表示需要等待的事件数量。

包括一个countDown方法，表示有一个事件已经发生了

包括一个await方法，这个方法等待计数器达到0，表示所有等待的事情都发生了。如果计数器的值非0，那么await方法会一直阻塞，或者等待中的线程中断，或者超时

例子：

使用CountDownLatch计算所有线程都完成任务，总共消耗的时间：

package bisuo;import java.util.concurrent.CountDownLatch;public class Test {public static void main(String[] args) {//定义有10个事件，需要10个事件都完成才能开门final CountDownLatch gate = new CountDownLatch(10);long startTime = System.currentTimeMillis();//10个线程完成10个事件for(int i=0; i<10;i++){Thread t = new Thread() {public void run() {try {//do somethingThread.sleep(10000);}catch(Exception e){e.printStackTrace();}finally{//完成一个count减1gate.countDown();}}};t.start();}try {//等待直到count为0gate.await();} catch (InterruptedException e) {e.printStackTrace();}long endTime = System.currentTimeMillis();long spendTime = endTime - startTime;System.out.println(spendTime);}}

2.FutureTask类

FutureTask类表示了一种抽象的可生成结果的计算。

通过Callable来实现，相当于一种可生成结果的Runnable。

public class TestFutureTask {public static void main(String[] args) {final FutureTask<Result> future = new FutureTask<Result>(new Callable<Result>(){public Result call(){try {//模拟任务执行Thread.sleep(10000);} catch (InterruptedException e) {e.printStackTrace();}Result result = new Result();return result;}});//定义一个线程去执行这个任务final Thread thread = new Thread(future);thread.start();try {//这一步会一直阻塞直到thread运行结束,result返回Result result = future.get();System.out.println("end");} catch (InterruptedException | ExecutionException e) {e.printStackTrace();}}}

3信号量（Semaphore）

Semaphore中管理着一组虚拟的许可，许可的初始数量可以通过构造函数来指定。

在执行操作中需要先获得许可，操作完以后释放，如果没有可用的许可了，那么acquire（）——获得许可操作将一直阻塞直到有可用的许可了

章节总结：

可变状态越少，就越容易确保线程的安全性，所以尽量将域声明为final类型，除非需要它们是可变的。不可变对象一定是线程安全的

当保护同一个不变性条件中的所有变量时，要使用同一个锁，在执行复合操作期间，要持有锁。