1 /**
2  * synchronized 修饰实例?法
3  */
4  public synchronized void increase() {
5  i++;
6  }

• 修饰静态?法: 也就是给当前类加锁，会作?于类的所有对象实例，因为静态成员不属于任何?个实例对象，是类成员（ static 表明这是该类的?个静态资源，不管new了多少个对象，只有?份）。

 1 public class Demo21 {
 2     public static int i;
 3     private synchronized static void method() {
 4         System.out.println("我是类锁的第?种形式：static形式，我叫" + Thread.currentThread().getName());
 5         try {
 6             Thread.sleep(1000);
 7             for (int j = 0; j < 100000; j++) {
 8                 i++;
 9             }
10         } catch (InterruptedException e) {
11             e.printStackTrace();
12         }
13         System.out.println(Thread.currentThread().getName() + "1=" + i);
14     }
15 }

 1 private void method2() {
 2         synchronized (Demo21.class) {
 3 // synchronized (this) {
 4             System.out.println("我是类锁的第?种形式：static形式，我叫" +
 5                     Thread.currentThread().getName());
 6             try {
 7                 Thread.sleep(1000);
 8                 for (int j = 0; j < 100000; j++) {
 9                     i++;
10                 }
11             } catch (InterruptedException e) {
12                 e.printStackTrace();
13             }
14             System.out.println(Thread.currentThread().getName() + "1=" + i);
15         }
16     }

 　　　　?先切换到类的对应?录执? javac XXX.java 命令?成编译后的.class ?件，然后执? javap -c -s -v -l XXX.class。

　　　　synchronized 同步语句块的实现使?的是 monitorenter 和 monitorexit 指令，其中monitorenter 指令指向同步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置。 当执? monitorenter 指令时，线程试图获取锁也就是获取 monitor(monitor对象存在于　　　　　　　　　　　　　　　　　　　　每个Java对象的对象头中，synchronized 锁便是通过这种?式获取锁的，也是为什么Java中任意对象可以作为锁的原因) 的持有权。 当计数器为0则可以成功获取，获取后将锁计数器设为1也就是加1。相应的在执?monitorexit 指令后，将锁计数器设为0，表明锁被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到锁被另外?个线程释放为?。

• 同步方法的情况

　　　　?先切换到类的对应?录执? javac XXX.java 命令?成编译后的 .class ?件，然后执? javap -c -s -v -l XXX.class。

 　　　　synchronized 修饰的?法并没有 monitorenter 指令和 monitorexit 指令，取得代之的却是ACC_SYNCHRONIZED 标识，该标识指明了该?法是?个同步?法，JVM 通过该ACC_SYNCHRONIZED 访问标志来辨别?个?法是否声明为同步?法，从?执?相应的同

• 偏向锁

　　　　引?偏向锁的?的和引?轻量级锁的?的很像，他们都是为了没有多线程竞争的前提下，减少传统的重量级锁使?操作系统互斥量产?的性能消耗。但是不同是：轻量级锁在?竞争的情况下使?CAS 操作去代替使?互斥量。?偏向锁在?竞争的情况下会把整个同步都消除掉。当一个线程访问同步块并获取锁时，会在对象头和栈帧中的锁记录里存储锁偏向的线程ID，以后该线程在进入和退出同步块时不需要花费CAS操作来加锁和解锁，而只需简单的测试一下对象头的Mark Word里是否存储着指向当前线程的偏向锁，如果测试成功，表示线程已经获得了锁，如果测试失败，则需要再测试下Mark Word中偏向锁的标识是否设置成1（表示当前是偏向锁），如果没有设置，则使用CAS竞争锁，竞争成果后为轻量级锁如果设置了，则尝试使用CAS将对象头的偏向锁指向当前线程。

• 轻量级锁

• 自旋锁和自适应自旋　　　　

　　　　轻量级锁失败后，虚拟机为了避免线程真实地在操作系统层?挂起，还会进??项称为?旋锁的优化?段。

　　　　互斥同步对性能最?的影响就是阻塞的实现，因为挂起线程/恢复线程的操作都需要转?内核态中完成（?户态转换到内核态会耗费时间）。

• 锁消除

　　　　锁消除理解起来很简单，它指的就是虚拟机即使编译器在运?时，如果检测到那些共享数据不可能存在竞争，那么就执?锁消除。锁消除可以节省毫?意义的请求锁的时间。

• 锁粗化

　　　　原则上，我们在编写代码的时候，总是推荐将同步块的作?范围限制得尽量?，——直在共享数据的实际作?域才进?同步，这样是为了使得需要同步的操作数量尽可能变?，如果存在锁竞争，那等待线程也能尽快拿到锁。

不可变对象

Guava

 

 

 

final

• 修饰类（禁?继承）
• 修饰?法(禁??类覆盖，注意现在已经不需要因为效率把?法设置为final了)
• final修饰的变量称为常量
• final修饰的引?类型变量 是引?不可变，?对象不可变

 

线程不安全类、并发容器

线程不安全类	线程安全类
StringBuilder	StringBuffer
SimpleDateFormat	JodaTime
ArrayList	CopyOnWriteArrayList
HashSet，TreeSet	CopyOnWriteArraySet，ConcurrentSkipListSet
HashMap，TreeMap	ConcurrentHashMap，ConcurrentSkipListMap
。。。	。。。

COW写时复制（CopyOnWriteArrayList，CopyOnWriteArraySet）

并发编程基础