锁的优化及注意事项

多线程存在的效率问题：各线程的元数据，上下文切换，线程调度等

1.有助于提高锁性能的几点建议

1.1 减少锁持有的时间

只在需要的代码段加锁，不要将不必要的内容加到同步代码方法或同步代码块中。

1.2 减小锁粒度

和1.1的方法的差不多，缩小锁定对象的范围，从而降低锁冲突的可能性。

1.3 用读写分离锁来替换独占锁

1.4 锁分离

与读写锁的思路类似，对于一个对象，不使用独占锁，而是依据操作功能的不同，对锁进行分离。如LinkedBlockingQueue中的take和put方法实现了取数据和读数据的分离。

1.5 锁粗化

虚拟机再遇到一连串连续地对同一个锁不断进行请求和释放的操作时，便会把所有的锁操作整合成对锁的一次请求，从而减少对锁的请求同步的次数。我们自己写程序时也应该注意这点。但要注意和1.2的区别。

2. Java虚拟机对锁优化所做的努力

下面都是jdk对锁所做的优化，当对象偏向锁的标志位（可偏向）为1时，可以将锁设置为偏向锁，偏向锁适合只有一个线程访问的情景，轻量级锁的使用代价低于轻量级锁。如果对象的偏向锁的标志位为0时，不可以将锁设置为偏向锁，那么这时可以尝试将其设置为轻量级锁，轻量级锁适合多个线程交替竞争锁，如果多个线程争夺锁，锁会膨胀为重量级锁。

2.1 锁偏向

如果一个线程获得了锁，那么锁就进入偏向模式。当这个线程再次请求时，无需再做任何同步操作，可以节省大量有关锁申请的操作，从而提高程序性能。适合于几乎没有锁竞争的场合。

2.2 轻量级锁

https://www.cnblogs.com/paddix/p/5405678.html

https://blog.csdn.net/lengxiao1993/article/details/81568130

2.3 自旋锁

虚拟机让当前线程做几个空循环，再经过若干次循环后，如果可以得到锁，那么就顺利进入临界区，否则就挂起线程。

2.4 锁消除

锁消除时一种更彻底的优化。Java虚拟机再JIT编译时，通过对运行上下文的扫描，去除不可能存在共享资源的竞争的锁。如StringBuffer,Vector等的使用过程中可能会出现。锁消除要保证不会出现逃逸分析才可以进行。

3 ThreadLocal

除了控制资源的访问外，还可以通过增加资源来保证对象的线程安全。锁是前者的思路，ThreadLcal是后者的思路。ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。在ThreadLocal类中有一个Map，用于存储每一个线程的变量副本，Map中元素的键为线程对象，而值对应线程的变量副本。

3.1 ThreadLocal是什么

ThreadLocal源码中该类的介绍：该类提供线程局部变量。这些变量与它们的正常变量不同，因为每个访问一个线程的变量都有它自己的、独立的初始化拷贝。实例通常是希望将状态与线程关联的类中的私有字段（例如，*用户ID或事务ID）。

3.2 ThreadLocal原理

https://www.cnblogs.com/ldq2016/p/9041856.html 这个博客讲得不错，结合《实战java高并发程序设计》的这一小节的内容，以及自己的一些实践，应该可以理解ThreadLocal。

（1）每个线程为自己的ThreadLocal变量赋值

定义一个ThreadLocal对象，当一个线程要使用这个对象时，可以使用set方法给这个对象赋值，如果不赋值的话，而定义这个对象的时候有没有定义initialValue()方法赋予初值，这个对象的值可能为null，使用时就会出现空指针异常。所以在使用ThreadLoacl对象时，如果所有线程都是相同的值，那要在定义这个ThreadLocal变量时，给这个对象利用initialValue()方法赋予初值。如果每个线程这个变量的值不同，那要利用set()方法赋值，最好也利用initValue()方法赋值，防止空指针异常错误的出现。

《 实战java高并发程序设计》中的例子，

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadLocalDemo {
    private static ThreadLocal<SimpleDateFormat> t1 = new ThreadLocal<SimpleDateFormat>();

    public static class ParseDate implements Runnable{
        int i=0;
        public ParseDate(int i){this.i=i;}

        public void run() {
            try{
                if(t1.get()==null){
                    t1.set(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
                }
                Date t =t1.get().parse("2015-03-29 19:29:"+i%60);
                System.out.println(i+":"+t);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String []args) throws InterruptedException {
        ExecutorService es = Executors.newFixedThreadPool(10);
        for(int i=0;i<1000;i++){
            es.execute(new ParseDate(i));
        }
        Thread.sleep(2000);
    }
}

每个线程在使用ThreadLocal对象t1时，要利用 t1.get() == null 来判断t1是否为空，如果为空，给它赋值。如果尝试将

                if(t1.get()==null){
                    t1.set(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
                }

这段代码删掉，会报空指针异常的错误。

而如果在定义t1时，设置初值，就不会报错了

private static ThreadLocal<SimpleDateFormat> t1 = new ThreadLocal<SimpleDateFormat>(){
    protected SimpleDateFormat initialValue(){
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    }
};

这里我有一个疑问，同样是使用t1,为什么有的线程为空，有的不为空,不太懂，但是自己在使用时注意初始化和set就好了。 

（2）线程取得ThreadLocal变量中的值

利用get()方法

 public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

从代码中可以看出，get方法首先尝试从ThreadLocalMap中获取这个线程对应的值，当为空时，尝试获取定义这个对象时的初始值，如果还为空，就返回null了。

（3）关于ThreadLocal变量GC

ThreadLocal变量中可能维护了很多线程的value，在一个线程中所以确定不用这个变量的时候，可以使用remove()方法将这个变量移除中的value移除，加快GC，防止内存泄漏。也可以使用 “ThreadLcal对象名” = null 加快将这个变量设为null,加快GC。remove源码如下：

     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

 

4. 无锁

锁是一种悲观的策略，认为有多个线程会同时访问同一资源，所以有多个线程访问临界区时，只能有一个线程访问临界去资源，其他线程只能阻塞。而无锁是一种乐观的策略，假设有冲突，也不需要阻塞，而是通过CAS技术不断自旋尝试，直到成功或者放弃。典型的应用是原子类和一些并发容器。 

5. 锁的优化及注意事项

5.1 死锁是什么

5.2 哲学家问题的实例代码

public class DeadLock extends Thread {
    protected Object tool;
    static Object fork1 = new Object();
    static Object fork2 = new Object();

    public DeadLock(Object obj){
        this.tool = obj;
        if(tool == fork1){
            this.setName("哲学家A");
        }
        if(tool == fork2){
            this.setName("哲学家B");
        }
    }


    public void run() {
        if(tool == fork1){
            synchronized (fork1){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (fork2){
                    System.out.println("哲学家A开始吃饭了");
                }
            }
        }
        if(tool == fork2){
            synchronized (fork2){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (fork1){
                    System.out.println("哲学家B开始吃饭了");
                }
            }
        }
    }

    public static void main(String []args) throws InterruptedException {
        DeadLock 哲学家A = new DeadLock(fork1);
        DeadLock 哲学家B = new DeadLock(fork2);
        哲学家A.start();
        哲学家B.start();
        Thread.sleep(1000);
     }
}

5.3 死锁检测方法

 

结果：

5.3 死锁避免的方法：

1.使用无锁的方法

2.限制线程获得锁的顺序 

3.超时检测

4.死锁检测

https://blog.csdn.net/ls5718/article/details/51896159

5.4 死锁解除

释放资源或者撤销线程