上一篇看这里：JAVA并发编程-8-线程池

一、类的线程安全的定义

如果多线程下使用这个类，不论多线程如何使用和调度这个类，这个类总是表示出正确的行为，这个类就是线程安全的。

类的线程安全表现为：

• 操作的原子性，使用这个类中的方法进行操作的时候，对外界调用者来说，操作不可被切割中断，要么全部成功，要么全部失败
• 内存的可见性，当线程对类的数据进行修改了以后，其他线程可以马上看到修改后的值

不做正确的同步，在多个线程之间共享状态（即类的属性）的时候，就会出现线程不安全。

二、怎么才能做到类的线程安全

1、栈封闭

所有的变量都是在方法内部声明的，这些变量都处于栈封闭状态。

线程在执行方法时，会将方法打包成一个栈桢，放到自己的方法栈中去执行，由于栈是线程私有的，不同线程执行方法不会相互影响。

2、无状态

没有任何成员变量的类，就叫无状态的类

线程安全问题是由类在多个线程之间共享状态（即类的属性）产生的，如果类没有属性，即没有状态，则不会产生线程安全问题。

3、让类不可变

让状态不可变，两种方式：
1，加final关键字，对于一个类，所有的成员变量应该是私有的，同样的只要有可能，所有的成员变量应该加上final关键字，但是加上final，要注意如果成员变量又是一个对象时，这个对象所对应的类也要是不可变，才能保证整个类是不可变的。
2、根本就不提供任何可供修改成员变量的地方，同时成员变量也不作为方法的返回值

4、volatile

保证类的可见性，最适合一个线程写，多个线程读的情景，

5、加锁和CAS

加锁和CAS前面章节反复提到，是一种线程安全的操作

6、安全的发布

类中持有的成员变量，特别是对象的引用，如果这个成员对象不是线程安全的，通过get等方法发布出去，会造成这个成员对象本身持有的数据在多线程下不正确的修改，从而造成整个类线程不安全的问题。

7、TheadLocal

TheadLocal线程副本，是保存在每个线程中的key，value结构，线程之间不可见，可以保证线程安全。

三、线程不安全会产生的问题

1、死锁

是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁

资源一定是多于1个，同时小于等于竞争的线程数，资源只有一个，只会产生激烈的竞争。

public class NormalDeadLock { private static Object valueFirst = new Object();//第一个锁 private static Object valueSecond = new Object();//第二个锁 //先拿第一个锁，再拿第二个锁 private static void fisrtToSecond() throws InterruptedException {         String threadName = Thread.currentThread().getName(); synchronized (valueFirst) {          System.out.println(threadName+" get first");          SleepTools.ms(100); synchronized (valueSecond) {           System.out.println(threadName+" get second"); } } } //先拿第二个锁，再拿第一个锁 private static void SecondToFisrt() throws InterruptedException {         String threadName = Thread.currentThread().getName(); synchronized (valueSecond) {          System.out.println(threadName+" get first");          SleepTools.ms(100); synchronized (valueFirst) {           System.out.println(threadName+" get second"); } } } } 

如上代码，定义了两把锁（多个资源），fisrtToSecond先拿第一个锁再拿第二个锁，SecondToFisrt先拿第二个锁再拿第一个锁。启动两个线程，线程A拿到了第一把锁，线程B拿到了第二把锁，这时线程A去拿第二把锁，但是被线程B占有无法拿到，而线程B也在尝试拿第一把锁，被线程A占有。产生了死锁。

死锁的根本成因：获取锁的顺序不一致导致。

解决方式：要保证加锁的顺序

 //先拿第一个锁，再拿第二个锁 private static void fisrtToSecond() throws InterruptedException {         String threadName = Thread.currentThread().getName(); synchronized (valueFirst) {          System.out.println(threadName+" get first");          SleepTools.ms(100); synchronized (valueSecond) {           System.out.println(threadName+" get second"); } } } //先拿第二个锁，再拿第一个锁 private static void SecondToFisrt() throws InterruptedException {         String threadName = Thread.currentThread().getName(); synchronized (valueFirst) {          System.out.println(threadName+" get first");          SleepTools.ms(100); synchronized (valueSecond) {           System.out.println(threadName+" get second"); } } } 

2、活锁

尝试拿锁的机制中，发生多个线程之间互相谦让，不断发生拿锁，释放锁的过程。

定义一个转账操作，按照顺序对from和to加锁，finally里面解锁

/**  *  *类说明：用户账户的实体类  */ public class UserAccount { //private int id; private final String name;//账户名称 private int money;//账户余额 //显示锁 private final Lock lock = new ReentrantLock(); public Lock getLock() { return lock; } public UserAccount(String name, int amount) { this.name = name; this.money = amount; } public String getName() { return name; } public int getAmount() { return money; } @Override public String toString() { return "UserAccount{" + "name='" + name + ''' + ", money=" + money + '}'; } //转入资金 public void addMoney(int amount){         money = money + amount; } //转出资金 public void flyMoney(int amount){         money = money - amount; } } 

public class SafeOperateToo implements ITransfer { @Override public void transfer(UserAccount from, UserAccount to, int amount) throws InterruptedException {      Random r = new Random(); while(true) { if(from.getLock().tryLock()) { try {         System.out.println(Thread.currentThread().getName() +" get "+from.getName()); if(to.getLock().tryLock()) { try {              System.out.println(Thread.currentThread().getName() +" get "+to.getName()); //两把锁都拿到了                          from.flyMoney(amount);                          to.addMoney(amount); break; }finally {           to.getLock().unlock(); } } }finally {         from.getLock().unlock(); } } } } } 

模拟张三to李四，和李四to张三，两个操作，启动两个线程调用转账方法。

/**  * 类说明：模拟支付公司转账的动作  */ public class PayCompany { /*执行转账动作的线程*/ private static class TransferThread extends Thread { private String name;//线程名字 private UserAccount from; private UserAccount to; private int amount; private ITransfer transfer; //实际的转账动作 public TransferThread(String name, UserAccount from, UserAccount to, int amount, ITransfer transfer) { this.name = name; this.from = from; this.to = to; this.amount = amount; this.transfer = transfer; } public void run() {             Thread.currentThread().setName(name); try {                 transfer.transfer(from, to, amount); } catch (InterruptedException e) {                 e.printStackTrace(); } } } public static void main(String[] args) {         PayCompany payCompany = new PayCompany();         UserAccount zhangsan = new UserAccount("zhangsan", 20000);         UserAccount lisi = new UserAccount("lisi", 20000);         ITransfer transfer = new SafeOperateToo();         TransferThread zhangsanToLisi = new TransferThread("zhangsanToLisi" , zhangsan, lisi, 2000, transfer);         TransferThread lisiToZhangsan = new TransferThread("lisiToZhangsan" , lisi, zhangsan, 4000, transfer);         zhangsanToLisi.start();         lisiToZhangsan.start(); } } 

可以看到执行结果，尝试加锁了很多次。

ReentrantLock.trylock在拿不到锁的时候不会进行等待，而是在finally中执行解锁操作。这样线程A拿到1锁拿不到2锁时，解锁进行下一次循环，线程B拿到2锁拿不到1锁时，解锁进行下一次循环，不断尝试，知道某个时间差将其错开。

解决办法：每个线程休眠随机数，错开拿锁的时间。

3、线程饥饿

低优先级的线程总是拿不到cpu的执行时间。这种情况在我们的开发过程中比较少碰到。

四、性能和思考

使用并发的目标是为了提高性能，但是引入多线程后，也会引入额外的开销。但是如果使用的不合理，往往可能使程序运行的效率降低。

衡量应用的程序性能：

• 服务时间，延迟时间（多快）
• 吞吐量（处理能力的指标，完成工作的多少）
• 可伸缩性

多快和多少完全独立，甚至是相互矛盾的。
这是架构设计最重要的需要权衡的部分

对服务器应用来说：多少（可伸缩性，吞吐量）比多快更受重视
做应用的时候：
1、先保证程序正确，确实达不到要求，再提高速度（黄金原则）
2、一定要以测试为基准

一个应用程序中，串行的部分总是有的
Amdahl定律：1/(F+(1-N)/N) F-串行部分，N-并行部分，最好的情况 1/F

影响性能的因素

1、上下文切换

如果当前可运行线程大于cpu的数量，cpu会把它的可执行时间进行分片，分给一个个线程去运行，当一个线程将时间分片用完了以后，操作系统需要将当前运行完了的线程从cpu上拿走，把其他线程load进来，让其他线程来使用cpu，这个过程就是一次上下文切换。上下文切换包括将原线程的各种数据等保存，将新线程所需要的数据读到cpu寄存器，这些都是上下文切换所要耗费的资源，大约需要5000-10000个时钟周期。

2、内存同步

即加锁，需要执行很多内存屏障等额外指令，这会带来性能上的损失

3、阻塞

线程挂起，包括两次额外的上下文切换

减少锁的竞争

• 缩小锁的范围
  对锁的持有快进快出，尽量缩短持有锁的时间
  比如sleep操作不会释放锁，不建议在加锁代码中使用
• 减少锁的粒度
  在使用锁的时候，锁保护的对象是多个，多个对象其实是独立变化的，应该使用多个锁一一保护每个对象
• 锁分段
  比如ConcurrentHashmap
• 替换独占锁
  使用读写锁等