Java同步学习（持续更新）

在需要考虑线程安全性的场合，可以考虑以下五种方式来实现线程的安全性：

1.同步方法

即有synchronized关键字修饰的方法。

由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，

       内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

        注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类。

 

       对于同步方法而言，无需显示指定同步监视器，同步方法的同步监视器是 this 也就是该对象的本身（这里指的对象本身有点含糊，其实就是调用该同步方法的对象）通过使用同步方法，可非常方便的将某类变成线程安全的类，具有如下特征：
      1，该类的对象可以被多个线程安全的访问。
      2，每个线程调用该对象的任意方法之后，都将得到正确的结果。
      3，每个线程调用该对象的任意方法之后，该对象状态依然保持合理状态。
      注：synchronized关键字可以修饰方法，也可以修饰代码块，但不能修饰构造器，属性等。

 

      2.同步代码块

      被该关键字修饰的语句块会自动被加上内置锁，从而实现同步。

      通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。

 

      3.使用特殊域变量(volatile)实现线程同步

      a.volatile关键字为域变量的访问提供了一种免锁机制。

     b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新。

     c.因此每次使用该域就要重新计算，而不是使用寄存器中的值。

     d.volatile不会提供任何原子操作，它也不能用来修饰final类型的变量。

 

     多线程中的非同步问题主要出现在对域的读写上，如果让域自身避免这个问题，则就不需要修改操作该域的方法。 用final域，有锁保护的域和volatile域可以避免非同步的问题。

 

      4.使用重入锁实现线程同步

     在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。

    ReentrantLock类是可重入、互斥、实现了Lock接口的锁， 

    它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力

    ReenreantLock类的常用方法有：

    ReentrantLock() : 创建一个ReentrantLock实例

        lock() : 获得锁 

        unlock() : 释放锁 

    注：ReentrantLock()还有一个可以创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用。

 

     5.使用局部变量实现线程同步

     通常的说法是：如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本， 副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。但我觉得这种说法是不准确的。后面我会说明。

     ThreadLocal 类的常用方法有：

     ThreadLocal() : 创建一个线程本地变量

    get() : 返回此线程局部变量的当前线程副本中的值 

    initialValue() : 返回此线程局部变量的当前线程的"初始值" 

    set(T value) : 将此线程局部变量的当前线程副本中的值设置为value

 

     首先，ThreadLocal 不是用来解决共享对象的多线程访问问题的，一般情况下，通过ThreadLocal.set() 到线程中的对象是该线程自己使用的对象，其他线程是不需要访问的，也访问不到的。各个线程中访问的是不同的对象。

     另外，说ThreadLocal使得各线程能够保持各自独立的一个对象，并不是通过ThreadLocal.set()来实现的，而是通过每个线程中的new 对象 的操作来创建的对象，每个线程创建一个，不是什么对象的拷贝或副本。通 过ThreadLocal.set()将这个新创建的对象的引用保存到各线程的自己的一个map中，每个线程都有这样一个map，执行 ThreadLocal.get()时，各线程从自己的map中取出放进去的对象，因此取出来的是各自自己线程中的对象，ThreadLocal实例是作 为map的key来使用的。

 

 

     总之，ThreadLocal不是用来解决对象共享访问问题的，而主要是提供了保持对象的方法和避免参数传递的方便的对象访问方式。归纳了两点：
1。每个线程中都有一个自己的ThreadLocalMap类对象，可以将线程自己的对象保持到其中，各管各的，线程可以正确的访问到自己的对象。

2。将一个共用的ThreadLocal静态实例作为key，将不同对象的引用保存到不同线程的ThreadLocalMap中，然后在线程执行
的各处通过这个静态ThreadLocal实例的get()方法取得自己线程保存的那个对象，避免了将这个对象作为参数传递的麻烦。

 

      ThreadLocal的应用场合，我觉得最适合的是按线程多实例（每个线程对应一个实例）的对象的访问，并且这个对象很多地方都要用到。

 

      举个例子，在Spring中的应用，我 们知道在一般情况下，只有无状态的Bean才可以在多线程环境下共享，在Spring中，绝大部分Bean都可以声明为singleton作用域。就是因 为Spring对一些Bean（如RequestContextHolder、TransactionSynchronizationManager、 LocaleContextHolder等）中非线程安全状态采用ThreadLocal进行处理，让它们也成为线程安全的状态，因为有状态的Bean就 可以在多线程中共享了。一般的Web应用划分为展现层、服务层和持久层三个层次，在不同的层中编写对应的逻辑，下层通过接口向上层开放功能调用。在一般情况下，从接收请求到返回响应所经过的所有程序调用都同属于一个线程。同一线程贯通三层这样你就可以根据需要，将一些非线程安全的变量以ThreadLocal存放，在同一次请求响应的调用线程中，所有关联的对象引用到的都是同一个变量。下面的实例能够体现Spring对有状态Bean的改造思路：

 

       TestDao：非线程安全

    package com.test;  

    import java.sql.Connection;
    import java.sql.SQLException;
    import java.sql.Statement;  

    public class TestDao {
        private Connection conn;// ①一个非线程安全的变量  

        public void addTopic() throws SQLException {
            Statement stat = conn.createStatement();// ②引用非线程安全变量
            // …
        }
    }  

conn是成员变量，因为addTopic()方法是非线程安全的，必须在使用时创建一个新TopicDao实例（非singleton）。下面使用ThreadLocal对conn这个非线程安全的“状态”进行改造：

TestDao：线程安全

    package com.test;  

    import java.sql.Connection;
    import java.sql.SQLException;
    import java.sql.Statement;  

    public class TestDaoNew {
        // ①使用ThreadLocal保存Connection变量
        private static ThreadLocal<Connection> connThreadLocal = new ThreadLocal<Connection>();  

        public static Connection getConnection() {
            // ②如果connThreadLocal没有本线程对应的Connection创建一个新的Connection，
            // 并将其保存到线程本地变量中。
            if (connThreadLocal.get() == null) {
                Connection conn = getConnection();
                connThreadLocal.set(conn);
                return conn;
            } else {
                return connThreadLocal.get();// ③直接返回线程本地变量
            }
        }  

        public void addTopic() throws SQLException {
            // ④从ThreadLocal中获取线程对应的Connection
            Statement stat = getConnection().createStatement();
        }
    }  

不 同的线程在使用TopicDao时，先判断connThreadLocal.get()是否是null，如果是null，则说明当前线程还没有对应的 Connection对象，这时创建一个Connection对象并添加到本地线程变量中；如果不为null，则说明当前的线程已经拥有了 Connection对象，直接使用就可以了。这样，就保证了不同的线程使用线程相关的Connection，而不会使用其它线程的 Connection。因此，这个TopicDao就可以做到singleton共享了。

　　当然，这个例子本身很粗糙，将Connection的ThreadLocal直接放在DAO只能做到本DAO的多个方法共享Connection时不 发生线程安全问题，但无法和其它DAO共用同一个Connection，要做到同一事务多DAO共享同一Connection，必须在一个共同的外部类使 用ThreadLocal保存Connection。

ConnectionManager.java

    package com.test;  

    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;  

    public class ConnectionManager {  

        private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() {
            @Override
            protected Connection initialValue() {
                Connection conn = null;
                try {
                    conn = DriverManager.getConnection(
                            "jdbc:mysql://localhost:3306/test", "username",
                            "password");
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                return conn;
            }
        };  

        public static Connection getConnection() {
            return connectionHolder.get();
        }  

        public static void setConnection(Connection conn) {
            connectionHolder.set(conn);
        }
    }  

       Synchronized和lock的那点事：

       所有线程使用的同一个对象实例，才能实现互斥的现象。否则synchronized关键字将失去意义。

      但是如果该方法为类方法，即其修饰符为static，那么synchronized 意味着某个调用此方法的线程当前会拥有该类的锁，只要该线程持续在当前方法内运行，其他线程依然无法获得方法的使用权！

 

      wait() 与notify()/notifyAll()

 

      这三个方法都是Object的方法，并不是线程的方法！

       wait():释放占有的对象锁，线程进入等待池，释放cpu,而其他正在等待的线程即可抢占此锁，获得锁的线程即可运行程序。而 sleep()不同的是，线程调用此方法后，会休眠一段时间，休眠期间，会暂时释放cpu，但并不释放对象锁。也就是说，在休眠期间，其他线程依然无法进 入此代码内部。休眠结束，线程重新获得cpu,执行代码。wait()和sleep()最大的不同在于wait()会释放对象锁，而sleep()不会！

 

       notify(): 该方法会唤醒因为调用对象的wait()而等待的线程，其实就是对对象锁的唤醒，从而使得wait()的线程可以有机会获取对象锁。调用notify()后，并不会立即释放锁，而是继续执行当前代码，直到synchronized中的代码全部执行完毕，才会释放对象锁。JVM则会在等待的线程中调度一个线程去获得对象锁，执行代码。需要注意的是，wait()和notify()必须在synchronized代码块中调用。

 

1、ReentrantLock 拥有Synchronized相同的并发性和内存语义，此外还多了 锁投票，定时锁等候和中断锁等候

线程A和B都要获取对象O的锁定，假设A获取了对象O锁，B将等待A释放对O的锁定，

如果使用 synchronized ，如果A不释放，B将一直等下去，不能被中断

如果 使用ReentrantLock，如果A不释放，可以使B在等待了足够长的时间以后，中断等待，而干别的事情

ReentrantLock获取锁定与三种方式：
    a)  lock(), 如果获取了锁立即返回，如果别的线程持有锁，当前线程则一直处于休眠状态，直到获取锁

b) tryLock(), 如果获取了锁立即返回true，如果别的线程正持有锁，立即返回false；

c)tryLock(long timeout,TimeUnit unit)，   如果获取了锁定立即返回true，如果别的线程正持有锁，会等待参数给定的时间，在等待的过程中，如果获取了锁定，就返回true，如果等待超时，返回false；

d) lockInterruptibly:如果获取了锁定立即返回，如果没有获取锁定，当前线程处于休眠状态，直到或者锁定，或者当前线程被别的线程中断

2、synchronized是在JVM层面上实现的，不但可以通过一些监控工具监控synchronized的锁定，而且在代码执行时出现异
常，JVM会自动释放锁定，但是使用Lock则不行，lock是通过代码实现的，要保证锁定一定会被释放，就必须将unLock()放到
finally{}中

3、在资源竞争不是很激烈的情况下，Synchronized的性能要优于ReetrantLock，但是在资源竞争很激烈的情况下，Synchronized的性能会下降几十倍，但是ReetrantLock的性能能维持常态；

下面内容 是转载 http://zzhonghe.iteye.com/blog/826162

5.0的多线程任务包对于同步的性能方面有了很大的改进，在原有synchronized关键字的基础上，又增加了ReentrantLock，以及各种Atomic类。了解其性能的优劣程度，有助与我们在特定的情形下做出正确的选择。

总体的结论先摆出来：

synchronized：
在资源竞争不是很激烈的情况下，偶尔会有同步的情形下，synchronized是很合适的。原因在于，编译程序通常会尽可能的进行优化synchronize，另外可读性非常好，不管用没用过5.0多线程包的程序员都能理解。

ReentrantLock:
ReentrantLock
提供了多样化的同步，比如有时间限制的同步，可以被Interrupt的同步（synchronized的同步是不能Interrupt的）等。在资源竞
争不激烈的情形下，性能稍微比synchronized差点点。但是当同步非常激烈的时候，synchronized的性能一下子能下降好几十倍。而
ReentrantLock确还能维持常态。

Atomic:
和上面的类似，不激烈情况下，性能比synchronized略
逊，而激烈的时候，也能维持常态。激烈的时候，Atomic的性能会优于ReentrantLock一倍左右。但是其有一个缺点，就是只能同步一个值，一
段代码中只能出现一个Atomic的变量，多于一个同步无效。因为他不能在多个Atomic之间同步。

所以，我们写同步的时候，优先考虑synchronized，如果有特殊需要，再进一步优化。ReentrantLock和Atomic如果用的不好，不仅不能提高性能，还可能带来灾难。

 

      Java线程池实例：http://blog.chinaunix.net/uid-25808509-id-3353441.html

 

       以上内容，皆为个人学习整理，非原创，谢谢各位乐意分享的牛人。