线程同步的方法

线程同步的方法

1 synchronized修饰方法

由于Java的每个对象都有一个内置锁，在调用synchronized修饰的方法前，需要获得内置锁，否则就处于阻塞状态。

public synchronized void save(){

}

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

synchronized static void method(){

}

2 synchronized修饰代码块

使用synchronized同步是一种高开销的操作，因此应该尽量减少同步的内容。
通常没有必要同步整个方法时，我们尽量使用synchronized同步代码块即可。

普通代码块：

 void function(){
	 synchronized(this){
	}
 }

静态代码块：

class A{
	 static void method(){
 		synchronized(A.class){
		}
	 }
 }

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

volatile关键字为域变量的访问提供了一种免锁机制，使用volatile修饰域相当于告诉JVM该域可能会被其他线程更新，因此每次使用该域就要重新计算，而不是使用寄存器中的值。

private volatile int account = 100;

• 被volatile修饰的变量具备可见性结果。
• 被volatile修饰的变量，无论是什么类型,都是原子的。
• 保证 引用 = new 构造方法（）的重排序是正确的。

注意：

• volatile关键字不能用来修饰final类型的变量，因为final修饰的域本身就是线程安全的。
• 多线程中的非同步问题主要出现在对域的读写上，如果让域自身避免这个问题，则就不需要修改操作该域的方法。 用final域，有锁保护的域和volatile域可以避免非同步的问题。

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

        class Bank {
            
            private int account = 100;
            //需要声明这个锁
            private Lock lock = new ReentrantLock();
            
            public int getAccount() {
                return account;
            }
            public void save(int money) {
            
                lock.lock();
                
                try{
                    account += money;
                }finally{
                    lock.unlock();
                }
                
            }
        ｝

• ReentrantLock需要要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。需要lock()和unlock()方法配合try/finally语句块来完成，
• Lock因为是方法调用，可以跨方法，灵活性更大
• 构造器可以传入boolean值，true为公平锁，false为非公平锁，
• 在资源竞争不激烈的情形下，性能稍微比synchronized差点点。但是当同步非常激烈的时候，synchronized的性能一下子能下降好几十倍。而ReentrantLock确还能维持常态。

5 使用原子变量util.concurrent.atomic实现线程同步

拿AtomicInteger 举例，常见方法有：

addAndGet(int delta);   i += delta;
decrementAndGet(); --i;
getAndDecrement(); i--;
incrementAndGet(); ++i;
getAndIncrement(); i++;

非原子的：
int i=0;
i++;

原子的：
AtomicInteger i = new AtomicInteger(0);
int v = i.getAndIncrement();