JAVA多线程-synchronized关键字

临界区

通常来说，临界区是一个用以访问共享资源的代码块，这个代码块在同一时刻只允许被一个线程执行

同步

1. 当一个线程试图访问一个临界区资源时，它将使用一种同步机制来查看当前不是是已经有其他的线程进入了临界区。
2. 如果临界区没有其他线程进入，则这个线程可以直接进入临界区；如果当前已经有线程进入了临界区，则它就会被同步机制挂起，直到进入的线程离开这个临界区
3. 如果在等待进入临界区的线程不止一个，JVM就会选择其中一个，其他的线程继续等待

java中采用的两种基本的同步机制

1. synchronized关键字同步
2. Lock接口及其接口实现类

通常，synchronized关键字有以下三种使用方式：

1. 同步普通方法，锁的是当前对象。
2. 同步静态方法，锁的是当前 Class 对象。
3. 同步块，锁的是 {} 中的对象。

package com.feizi.java.concurrency.synchronsize;

/**
 * Created by feizi on 2018/5/17.
 */
public class AccountingSync implements Runnable {
    private static AccountingSync instance = new AccountingSync();

    /*共享资源（临界资源）*/
    static int i = 0;

    /**
     * 作用于静态方法，锁是当前class对象，也就是AccountingSync来所对应的class对象
     * 即无论传入多少个实例，使用的都是同一把锁，会发生互斥
     */
    public static synchronized void increaseStatic(){
        i++;
    }

    /**
     * 非静态方法，访问时锁（实例）不一样不会发生互斥（即如果传入的是同一个实例会发生互斥，不会产生线程安全问题，否则
     * 如果传入的是不同的实例，则不会发生互斥）
     */
    public synchronized void increaseNostatic(){
        i++;
    }

    /**
     * 使用this作为对象锁，锁住的是当前传入的实例对象，如果传入的是同一个实例，则不会有线程安全问题，否则会有线程安全问题
     */
    public void increaseThis(){
        //this,当前实例对象锁
        synchronized (this){
            i++;
        }
    }

    /**
     * 静态实例对象锁, 这种写法一般比较推荐，因为静态实例是属于类的，在JVM启动的时候就已经被加载了，
     * 所以无论传入多少个实例，使用的都是同一把对象锁
     */
    public void increaseStaticInstance(){
        synchronized (instance){
            i++;
        }
    }

    /**
     * class对象锁， 锁住的是当前的class对象, 这种方式同上面的静态实例对象锁的方式，无论传入多少个实例，使用的
     * 都是同一把对象锁
     */
    public void increaseClass(){
        synchronized (AccountingSync.class){
            i++;
        }
    }

    @Override
    public void run() {
        for (int j = 0; j < 2000000; j++){
            increaseStatic();
//            increaseNostatic();
//            increaseThis();
//            increaseStaticInstance();
//            increaseClass();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        /*AccountingSync increase = new AccountingSync();

        Thread t1 = new Thread(increase);
        Thread t2 = new Thread(increase);
        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("结果i=" + i);*/

        Thread t1 = new Thread(new AccountingSync());
        Thread t2 = new Thread(new AccountingSync());

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("结果i=" + i);
    }
}

控制台输出结果：

结果i=4000000

Process finished with exit code 0

试了几种不同的同步方式，结论如下：

1. 作用于静态方法
   锁是当前class对象，也就是AccountingSync来所对应的class对象，即无论传入多少个实例，使用的都是同一把锁，会发生互斥。

2. 作用于非静态（普通）方法
   访问时锁（实例）不一样不会发生互斥，即如果传入的是同一个实例会发生互斥，不会产生线程安全问题，否则如果传入的是不同的实例，则不会发生互斥。

3. 使用this作为对象锁
   锁住的是当前传入的实例对象，如果传入的是同一个实例，则不会有线程安全问题，否则会有线程安全问题

4. 使用静态实例作为对象锁
   这种写法一般比较推荐，因为静态实例是属于类的，在JVM启动的时候就已经被加载了，所以无论传入多少个实例，使用的都是同一把对象锁

5. 使用class对象锁
   锁住的是当前的class对象, 这种方式同上面的静态实例对象锁的方式，无论传入多少个实例，使用的都是同一把对象锁