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对象, 这种方式同上面的静态实例对象锁的方式,无论传入多少个实例,使用的都是同一把对象锁

推荐阅读更多精彩内容

  • pdf下载地址:Java面试宝典 第一章内容介绍 20 第二章JavaSE基础 21 一、Java面向对象 21 ...
    王震阳阅读 73,748评论 25 504
  • 线程同步 在大多数实际的多线程应用中, 两个或两个以上的线程需要共享对同一数据的存取。多个线程或者进程在读写一个共...
    Steven1997阅读 639评论 0 1
  • 进程和线程 进程 所有运行中的任务通常对应一个进程,当一个程序进入内存运行时,即变成一个进程.进程是处于运行过程中...
    小徐andorid阅读 1,952评论 3 53
  • 因缘巧合之下,终于于香港回归二十周年这天,即我十九周岁生日的这天,即2017年7月1日。我来到了西桥村。 妈妈告诉...
    花漵阅读 58评论 10 2
  • 作为3D技术的发展趋势,浏览器端3D技术越来越被一些技术公司重视。由此,Threejs非常注重3D渲染效果的真实性...
    sakatayui酱阅读 315评论 0 1