线程基础（线程安全篇）

线程的上下文切换？

多线程创建并切换到另一个线程的过程，称之为线程的上下文切换。

线程的上下文切换出现的问题

正常情况下一个CPU的内核一个时间只能运行一个线程中的一个指令

通过线程的并发，cpu内核会在多个线程之间相互的切换，切换速度非常快，达到同时运行的效果

随之就会出现几个问题

1.线程切换回来后，如何从上次执行的指令后执行？

每个线程都有自己的  程序计数器（用于记录上次执行的行数）

2.CPU进行上下文切换的过程中，性能会降低。

3.线程执行会随时切换，如何保证重要的指令能完全完成？

单CPU这么频繁，多核CPU一定程度上可以减少上下文切换。

线程安全问题 

线程的安全（同步）问题

cpu内核会在多个线程间切换，可能会导致有些重要的指令不能正常的执行，就会导致线程安全问题。

出现线程安全问题的三个条件：

1.多线程

2.同一时间

3.执行同一段指令或者修改同一变量

public class BankDemo {
  int accounts[]=new int [100] ;
  public void transfer(int from,int to,int money){
        if(accounts[from]<money){
            throw new RuntimeException("余额不足");
        }
         accounts[from]=accounts[from] - money;
         System.out.println("从"+from+"转出"+money);
         accounts[to] =accounts[to] +money;
         System.out.println("到"+to+"转入"+money);
         getTotal();
        
}
    public int getTotal(){
        int sum =0;
        for (int i = 0; i < 100; i++) {
            sum+=accounts[i];
        }
        System.out.println("现在总金额"+sum);
        return sum;
    }
    public static void main(String[] args) {
        Random random = new Random();
        BankDemo bankDemo = new BankDemo();
        for (int i = 0; i < 50; i++) {
        new Thread(() ->{
                bankDemo.transfer(random.nextInt(100),random.nextInt(100),random.nextInt(2000));
        }).start();
        }
    }
}

发现总金额发生了改变,如何解决这一问题，如下：

线程安全问题的解决方法

解决方法：上锁

同步方法

作用：给整个方法上锁

过程：当前线程调用方法后，方法上锁，其它线程无法执行，调用结束后，释放锁。

锁对象：

• 非静态方法 --> this

• 静态方法 ---> 当前类.class

格式：
public synchronized void method(){
        代码
} 

//方法上public后加 synchronized
    public synchronized void transfer(int from,int to,int money) {
        if (accounts[from] < money) {
            throw new RuntimeException("余额不足");
        }

        accounts[from] = accounts[from] - money;
        System.out.println("从" + from + "转出" + money);
        accounts[to] = accounts[to] + money;
        System.out.println("到" + to + "转入" + money);
        getTotal();
    }

同步代码块

同步代码块是给需要上锁的代码，进行上锁，这样更加灵活，性能更高

锁对象：

1.把同步代码块锁住，只让一个线程在同步代码块中执行

2.任何对象都可以作为锁，对象不能是局部变量

格式：
synchronized(锁对象){
    代码
}

public class BankDemo { 
    Object lock=new Object();
    //方法上public后加 synchronized
    public void transfer(int from,int to,int money){
        if(accounts[from]<money){
            throw new RuntimeException("余额不足");
        }
        synchronized (lock){
            accounts[from]=accounts[from] - money;
            System.out.println("从"+from+"转出"+money);
            accounts[to] =accounts[to] +money;
            System.out.println("到"+to+"转入"+money);
            getTotal();
        }
    }
}

synchronized的基本的原理：

从 底层汇编可以发现一旦代码被synchronized包含，JVM会启动监视器（monitor）对这段指令进行监控。线程执行该段代码时，monitor会判断锁对象是否有其它线程持有，如果其它线程持有，当前线程就无法执行，等待锁释放，如果锁没有其它线程持有，当前线程就持有锁，执行代码

同步锁

在java.concurrent并发包中的Lock接口

Lock实现提供了比使用synchronized方法和语句可获得更广泛的锁定操作

基本方法：

• lock() 上锁

• unlock() 释放锁

使用方法：

1. 定义同步锁对象（成员变量）

2. 上锁

3. 释放锁

 格式：

//成员变量
Lock lock = new ReentrantLock();

//方法内部上锁
lock.lock();
try{
    代码...
}finally{
    //释放锁
    lock.unlock();
}

 //同步锁 unlock的必须执行
        lock1.lock();
        try {
            accounts[from]=accounts[from] - money;
            System.out.println("从"+from+"转出"+money);
            accounts[to] =accounts[to] +money;
            System.out.println("到"+to+"转入"+money);
            getTotal();
        }finally {
            lock1.unlock();
        }

三种锁对比：

• 粒度

  同步代码块/同步锁 < 同步方法

• 编程简便

  同步方法 > 同步代码块 > 同步锁

• 性能

  同步锁 > 同步代码块 > 同步方法

• 功能性/灵活性

  同步锁（有更多方法，可以加条件） > 同步代码块 （可以加条件） > 同步方法