java并发1

Java Synchronized Blocks

同一对象上的synchronized代码块，同一时刻只允许一个线程进入，其他想进入的线程只能等待，直到之前的线程退出代码块。

有4中synchronized代码块

1. Instance methods
2. Static methods
3. Code blocks inside instance methods
4. Code blocks inside static methods

具体使用哪个，要看实际情况。

Synchronized Instance Methods

public synchronized void add(int value){      this.count += value;  }

同一实例的synchronized方法，同一时刻只允许一个线程进入。不同实例，同时可以有不同的线程进入。这种情况的锁是this，不同实例有不同的this。

Synchronized Static Methods

 public static synchronized void add(int value){      count += value;  }

静态同步方法属于其所在的类的类对象，因为类对象只有一个，所以一个类对象同一时刻只允许一个thread进入。这种情况的锁是XXClass.class

Synchronized Blocks in Instance Methods

 public void add(int value){    synchronized(this){       this.count += value;       }  }

当只需同步一段代码时，如上那么搞。

Synchronized Blocks in Static Methods

public class MyClass {    public static synchronized void log1(String msg1, String msg2){       log.writeln(msg1);       log.writeln(msg2);    }      public static void log2(String msg1, String msg2){       synchronized(MyClass.class){          log.writeln(msg1);          log.writeln(msg2);         }    }  }

当只需同步一段代码时，如上那么搞，静态方法中的同步代码块的monitor object不能是this，可以用Class.class

synchronized关键字是java同步的一个方式，但不是最好的，在jdk1.5引入了a set of java concurrency utilities.

Java's Volatile Keyword

volatile关键字的作用是直接从main memory读和写入。

volatile关键字不能用于local variable 。

volatile关键字能保证变量在多线程见可见！比如，2个线程在2个cpu上执行，访问了共享资源，cpu将共享资源从main memory拷贝到cpu cache，更新值后并没有马上将更新写到main memory，其他线程从main memory读到的还是之前的值。

如果多线程读写volatile的变量，也不能保证是线程安全的，因为线程A先读，接着线程B读，A，B将变量各增加1后写入main memory，结果还是错的，这时应该用synchronized，使读写保持原子性。

当一个线程对volatile变量写入，其他线程只读，这种情况下volatile可以保证能读到volatile变量最新的值。

volatile对程序性能有影响，除非必需，否则别用。

jvm出于性能考虑，在不影响程序行为前提下，会对指令(instructions)重新排序，但不会对操作volatile变量的instruction重新排序。

http://www.ibm.com/developerworks/cn/java/j-jtp06197.html

锁提供了两种主要特性：互斥（mutual exclusion） 和可见性（visibility）。互斥即一次只允许一个线程持有某个特定的锁，因此可使用该特性实现对共享数据的协调访问协议，这样，一次就只有一个线程能够使用该共享数据。可见性要更加复杂一些，它必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个线程是可见的 —— 如果没有同步机制提供的这种可见性保证，线程看到的共享变量可能是修改前的值或不一致的值，这将引发许多严重问题。

Java 语言中的 volatile 变量可以被看作是一种 “程度较轻的 synchronized”；与 synchronized 块相比，volatile 变量所需的编码较少，并且运行时开销也较少，但是它所能实现的功能也仅是 synchronized 的一部分。

虽然增量操作（x++）看上去类似一个单独操作，实际上它是一个由读取－修改－写入操作序列组成的组合操作。

（volatile如何正确使用，未掌握）

http://www.infoq.com/cn/articles/ftf-java-volatile

Volatile是轻量级的synchronized，它在多处理器开发中保证了共享变量的“可见性”。可见性的意思是当一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。

Java语言规范第三版中对volatile的定义如下： java编程语言允许线程访问共享变量，为了确保共享变量能被准确和一致的更新，线程应该确保通过排他锁单独获得这个变量。Java语言提供了volatile，在某些情况下比锁更加方便。如果一个字段被声明成volatile，java线程内存模型确保所有线程看到这个变量的值是一致的。

Volatile的实现原理

那么Volatile是如何来保证可见性的呢？在x86处理器下通过工具获取JIT编译器生成的汇编指令来看看对Volatile进行写操作CPU会做什么事情。

Java代码：

instance = new Singleton();//instance是volatile变量

汇编代码：

0x01a3de1d: movb $0x0,0x1104800(%esi);

0x01a3de24: lock addl $0x0,(%esp);

有volatile变量修饰的共享变量进行写操作的时候会多第二行汇编代码，通过查IA-32架构软件开发者手册可知，lock前缀的指令在多核处理器下会引发了两件事情。

• 将当前处理器缓存行的数据会写回到系统内存。
• 这个写回内存的操作会引起在其他CPU里缓存了该内存地址的数据无效，而重新从系统内存中重新读取

处理器为了提高处理速度，不直接和内存进行通讯，而是先将系统内存的数据读到内部缓存（L1,L2或其他）后再进行操作，但操作完之后不知道何时会写到内存，如果对声明了Volatile变量进行写操作，JVM就会向处理器发送一条Lock前缀的指令，将这个变量所在缓存行的数据写回到系统内存。但是就算写回到内存，如果其他处理器缓存的值还是旧的，再执行计算操作就会有问题，所以在多处理器下，为了保证各个处理器的缓存是一致的，就会实现缓存一致性协议，每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了，当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置成无效状态，当处理器要对这个数据进行修改操作的时候，会强制重新从系统内存里把数据读到处理器缓存里。

这两件事情在IA-32软件开发者架构手册的第三册的多处理器管理章节（第八章）中有详细阐述。

Java ThreadLocal

threadLocal 允许创建只能被同一个线程读写的变量。