线程与并发 - synchronized

多线程与高并发

• synchronized 当多个线程同时访问同一个资源的时候需要对这个资源上锁。
• synchronized 既保证原子性，也保证线程间的可见性

当我们对一个数字进行递增操作时，如果两个程序同时访问，第一个线程读到count=0，并对其+1，在自己线程内部的内存里还没有写回去的时候；第二个线程读到的count也是0，并+1写回去；但是程序明明对count进行了两次+1操作，但结果还是1。
那么我们对这个递增过程加上一把锁，当第一个程序访问的时候，这个资源是它独占的，不允许别的线程访问计算，当第一个线程计算完成并释放锁之后其它线程才能访问，这样就保证了线程安全。

public class Thread_006 {
    private static int count = 0;

    public static void main(String[] args) {
        new Thread(()->{
            countAdd();
        }).start();

        new Thread(()->{
            countAdd();
        }).start();
    }
	//去掉synchronized 可以看出来不加锁的情况下我们预期的结果与实际结果是不符合的
    static /*synchronized*/ void countAdd(){
        for (int i = 0; i < 100; i++) {
            try {
                //相当于你线程处理的业务
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            count++;
        }
        System.out.println(Thread.currentThread().getName()+"count = "+ count);
    }
}
当不在countAdd方法上加锁时的执行结果：
Thread-1count = 155
Thread-0count = 155

当在countAdd方法上加锁的执行结果：
Thread-0count = 100
Thread-1count = 200

synchronized 加锁的方式

• 我们加锁代码有个原则：尽量少的锁代码，比如我的方法中只需要对count++进行synchronized，我们没必要把整个方法锁住，只锁count++就可以了。但是如果我们一个方法内有N多个地方需要加锁，我们就直接锁方法，就不要每次都让线程竞争了。

public class Thread_007 {

    private int count = 0;
    private Object o = new Object();//不可以使用String常量 Integer Long

    //锁定Object
    public void m1(){
        synchronized (o){
            count++;
        }
    }

    //锁定当前对象
    public void m2(){
        synchronized (this){
            count++;
        }
    }

    //等同与m2锁定当前对象
    public synchronized void m3(){
        count++;
    }
}

静态方法加锁

• 静态方法是没有this对象的，我们也可以不用new出来一个对象进行加锁

public class Thread_008 {
    private static int count = 10;

    //等同于synchronized (Thread_008.class)
    public synchronized static void m1(){
        count--;
    }

    public static void m2(){
        synchronized (Thread_008.class){
            count--;
        }
    }
}

synchronized保证原子性与线程间可见

public class Thread_009 {
    private int count  = 100000;

    public /*synchronized*/ void run(){
        count--;
        System.out.println(Thread.currentThread().getName()+" count = "+count);
    }

    public static void main(String[] args) {
        Thread_009 t = new Thread_009();
        for (int i = 100000; i > 0 ; i--) {
            new Thread(t::run,"Thread "+i+" ").start();
        }
    }
}
不加sychronized执行结果,我们可以看到多个线程输出了同一个值，最终结果不是我们预期的0
......
Thread 38223  count = 38230
Thread 38166  count = 38229
Thread 38226  count = 38229
Thread 38169  count = 38229
Thread 38284  count = 38230
Thread 38168  count = 38228
......
当我们加上sychronized时，会解决这个问题
Thread 4  count = 3
Thread 5  count = 2
Thread 2  count = 1
Thread 1  count = 0

面试题：模拟银行账户，对业务写方法加锁，对业务读方法不加锁，可以吗？
答：不可以，容易产生脏读现象；具体看代码，解决方法就是把读方法也加锁

public class Thread_010 {
    String name;
    double balance;

    public /*synchronized*/ void set(String name,double balance){
        this.name = name;
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.balance = balance;
    }

    public synchronized double getBalance(){
        return this.balance;
    }

    public static void main(String[] args) {
        Thread_010 account = new Thread_010();
        new Thread(()->account.set("柯南",300.0)).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前账户余额："+account.getBalance());

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("当前账户余额："+account.getBalance());
    }
}
不加锁执行结果：
当前账户余额：0.0
当前账户余额：300.0
加锁执行结果：
当前账户余额：300.0
当前账户余额：300.0

synchronized 锁重入|异常锁

• 锁重入：一个同步方法内可以调用另一个同步方法，及一个类中两个方法都加了锁，那么他们锁定的都是同一个对象，当我们在m1中调用m2时，会发现他们呢是同一个线程的申请这把锁，允许执行m2，这就叫锁重入。
• 异常锁：程序执行过程中，如果某个环节出现异常，默认锁会被释放，外部等待的程序就会冲进来，程序乱入，可能会访问到异常时产生的数据；一般用try-catch解决，保证流程是不会被异常中断的。

synchronized 锁升级

• 这里强烈安利 《我是厕所所长一、二》-马士兵 马老师的文章生动的讲解了锁升级的一个过程，通俗易懂！

面试题：CAS（自旋锁）一定比系统锁的效率高吗？
答：不一定，分具体情况：执行时间短（加锁的代码），线程数少，用自旋；执行时间长，线程数多，用系统锁。