java学习之浅谈多线程2线程同步

• 如果一个共享资源被多个线程同时访问，可能会遭到破坏。举个例子说明这个问题，假设创建并启动100个线程，每个线程都往同一个账户中添加一个便士，代码如下：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class AccountWithSync {

    private static Account account = new Account();

    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();

        //用线程池executor创建并启动100个线程
        for(int i=0; i<100; i++) {
            executor.execute(new AddAPennyTask());
        }

        executor.shutdown();

        //线程全部结束前执行此循环
        while(!executor.isTerminated()) {
        }

        System.out.println("What is balance?" + account.getBalance());
    }

    private static class AddAPennyTask implements Runnable {
        @Override
        public void run() {
            account.deposit(1);
        }
    }

    private static class Account {
        private int balance = 0;        //账户余额

        public int getBalance() {
            return balance;
        }

        public void deposit(int amount) {
            int newBalance = balance + amount;

            //设置这种延迟是为了加大数据的破坏程度让结果更加明显
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
            }

            balance = newBalance;
        }
    }
}

该账户中的初始余额为0，当所有线程都结束时，余额应该为100，但是运行上面程序得到的结果却是不可预测的，如下图所示。它演示了当所有线程同时访问同一个数据时，就会出现数据破坏的问题。

那么，究竟是什么导致了程序的错误？下面给出一个可能的情况。

步骤	余额	任务1	任务2
1	0	newBalance = balance + 1;
2	0		newBalance = balance + 1;
3	1	balance = newBalance;
4	1		balance = newBalance;

在步骤1中，任务1从账户中获取余额数目。在步骤2中，任务2从账户中获取同样数目的余额。在步骤3中，任务1向账户写入一个新余额。在步骤4中任务2也向该账户写入一个新余额。这就导致任务1什么也没做，因为任务2覆盖了任务1的结果。

这是多线程程序中一个普遍的问题，称为竞争状态。如果一个类的对象在多线程程序中没有导致竞争状态，则称这样的类为线程安全的。

• 为了解决上面的问题，应该防止多个线程同时进入程序的某一个特定部分（程序中的这部分称为临界区），也就是将这部分同步化。下面介绍三种解决方法：

1.使用关键字synchronized
通过在程序的deposit方法中添加关键字synchronized，使Account类成为线程安全的，如下：

public synchronized void deposit(double amount)

一个同步方法在执行前需要加锁。对于实例方法，要给调用该方法的对象加锁。对于静态方法，要给这个类加锁。如果一个线程调用一个对象上的同步实例方法（静态方法），首先给该对象（类）加锁，然后执行该方法，最后解锁。在解锁之前，另一个调用那个对象（类）中方法的线程将被阻塞，直到解锁。

因为deposit方法被同步化，如果任务1开始进入deposit方法，任务2就会被阻塞，直到任务1完成该方法的运行。

2.利用加锁同步
使用关键字synchronized的代码块在执行前都隐式地需要一个锁。还可以通过显示地加锁解决上面的问题。
一个锁是一个Lock接口的实例，它定义了加锁和释放锁的方法，如下：

+lock():void                加锁
+unlock():void              释放锁
+newCondition():Condition   返回绑定到Lock实例的新的Condition实例

ReentrantLock是为了创建相互排斥的锁的Lock的具体实现。可以创建具有特定的公平策略的锁。真正的公平策略确保等待时间最长的线程首先获得锁。假的公平策略将锁给任意一个在等待的线程。被多个线程访问的使用公正锁的程序，齐整体性能可能比那些使用默认设置的程序差，但是在获取锁且避免资源缺乏时变化很小。

+ReentrantLock()                等价于ReentrantLock(false)
+ReentrantLock(fair:boolean)    创建具有给定公平策略的锁。当公平性为true时，等待时间最长的线程将获得锁；否则没有特定的获得顺序

使用显示锁修改程序中的Account类如下：

private static class Account {
        private int balance = 0;
        private static Lock lock = new ReentrantLock();         //创建一个锁

        public int getBalance() {
            return balance;
        }

        //使用显示加锁避免竞争状态
        public void deposit(int amount) {
            lock.lock();            //获得锁

            try {
                int newBalance = balance + amount;
                Thread.sleep(5);
                balance = newBalance;
            } catch (InterruptedException e) {
            }finally {
                lock.unlock();      //释放锁
            }
        }
    }

在对lock()的调用之后紧随一个try-catch块并且在finally子句中释放这个锁是一个很好的习惯

通常使用synchronized方法或语句比使用排斥的显示锁简单些。然而，使用显示锁对同步具有状态的线程更加直观和灵活。

3.使用信号量
信号量可以用来限制访问共享资源的线程数。在访问资源之前，线程必须从信号量获取许可。在访问完资源之后，这个线程必须将许可返回给信号量。任务一旦获取许可，信号量中可用许可的总数量减1，一旦许可被释放，信号量中许可的总数加1.

+Semaphore(numberOfPermits:int)                 创建一个带指定数目许可的信号量。公平策略为false
+Semaphore(numberOfPermits:int, fair:boolean)   创建一个带指定数目许可和公平策略的信号量
+acquire():void                                 获取这个信号量的许可。如果无许可可用，线程就被锁住直到有可用许可为止
+release():void                                 释放一个许可给该信号量

只有一个许可的信号量可以用来模拟一个相互排斥的锁。修改程序中的Account类，确保同一时间只有一个线程访问deposit方法从而解决了上面的问题，代码如下。

private static class Account {
        private int balance = 0;
        private static Semaphore semaphore = new Semaphore(1);  //创建只有一个许可的信号量

        public int getBalance() {
            return balance;
        }

        //使用只有一个许可的信号量避免竞争状态
        public void deposit(int amount) {
            try {
                semaphore.acquire();        //  获得许可

                int newBalance = balance + amount;
                Thread.sleep(5);
                balance = newBalance;
            } catch (InterruptedException e) {
            } finally {
                semaphore.release();        //释放许可
            }
        }
    }