面试系列-高并发之synchronized

-----概要--------------------

1、synchronized原理

2、synchronized基本规则

3、synchronized方法和synchronized代码块

4、实例锁和全局锁

-----synchronized原理---------------------

在java中,每一个对象有且仅有一个同步锁,这也意味着,同步锁是依赖于对象而存在。

当我们调用某对象的synchronized方法时,就获取了该对象的同步锁。如:synchronized(obj)就获取了"obj这个对象"的同步锁。

不同线程对同步锁访问时互斥的,也就是锁,在某个时间点,对象的同步锁只能被一个线程获取到,通过同步锁,我们就能在多线程中,实现对"对象/方法"的互斥访问。如:现在有俩个线程A和线程B,他们都会访问"对象obj的同步锁"。假设,某一个时刻,线程A获取到"obj的同步锁"并在执行一些操作,而此时,线程B也企图获取"obj"的同步锁,线程B会获取失败,它必须等待,知道线程A释放了"该对象的同步锁之后线程B才能获取到"obj的同步锁",从而可以运行。

-----synchronized基本规则---------------------

我们将synchronized的基本规则归结为下面三条,病痛难过实例对他们进行说明

第一条:

当一个线程访问"某对象"的"synchronized方法"或者"synchronized代码块"时,其他线程对"该对象"的该"synchronized方法"或者"synchronized代码块"的访问将被阻塞。

演示代码:

public class SynchronizedTest implements Runnable{


    @Override
    public void run() {
        synchronized(this){
            try {
                for (int i = 0; i < 5; i++){
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + " loop " + i);
                }
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Runnable runnable = new SynchronizedTest();
        Thread thread1 = new Thread(runnable,"t1");
        Thread thread2 = new Thread(runnable,"t2");
        thread1.start();
        thread2.start();
    }
}

运行结果:

t1 loop 0
t1 loop 1
t1 loop 2
t1 loop 3
t1 loop 4
t2 loop 0
t2 loop 1
t2 loop 2
t2 loop 3
t2 loop 4

结果说明:

run()方法中存在"synchronized(this)代码块",而且t1和t2都是基于main中的这个"Runnable对象"创建的线程。这就意味着,我们可以将synchronized(this)中的this看做是"main中这个Runnable对象",因此,线程t1和t2共享"Runnable对象的同步锁"。所以,当一个线程运行的时候,另一个线程必须等待"运行线程"释放"Runnable的同步锁"之后才可以运行。

再看下面一块代码:

public class SynchronizedTest extends Thread{

    public SynchronizedTest(String name){
        super(name);
    }


    @Override
    public void run() {
        synchronized(this){
            try {
                for (int i = 0; i < 5; i++){
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + " loop " + i);
                }
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Thread thread1 = new SynchronizedTest("t1");
        Thread thread2 = new SynchronizedTest("t2");
        thread1.start();
        thread2.start();
    }
}

运行结果:

t2 loop 0
t1 loop 0
t1 loop 1
t2 loop 1
t2 loop 2
t1 loop 2
t2 loop 3
t1 loop 3
t2 loop 4
t1 loop 4

代码说明:

synchronized(this)中的this是指"当前的类对象",即synchronized(this)所在的类对应的当前对象,它的作用是获取"当前对象的同步锁"。

第二条:

当一个线程访问"某对象"的"synchronized方法"或者"synchronized代码块"时,其他线程任认识你可以告诉你个人"该对象"的非同步代码块。

演示代码:

public class NoSynchronizedTest {

    //含有synchronized同步代码块方法
    public void synMethod(){
        synchronized (this){
            try {
                for (int i = 0; i < 5; i++){
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + " synMethod loop " + i);
                }
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }

    //非同步方法
    public void nonSynchronized(){
        try{
            for (int i = 0; i < 5; i++){
                Thread.sleep(100);
                System.out.println(Thread.currentThread().getName() + " nonSynMethod loop " + i);
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args){
        final NoSynchronizedTest noSynchronizedTest = new NoSynchronizedTest();
        Thread t1 = new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        noSynchronizedTest.synMethod();
                    }
                },"t1");
        Thread t2 = new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        noSynchronizedTest.nonSynchronized();
                    }
                },"t2");
        t1.start();
        t2.start();
    }
}

运行结果:

t2 nonSynMethod loop 0
t1 synMethod loop 0
t2 nonSynMethod loop 1
t1 synMethod loop 1
t1 synMethod loop 2
t2 nonSynMethod loop 2
t2 nonSynMethod loop 3
t1 synMethod loop 3
t2 nonSynMethod loop 4
t1 synMethod loop 4
主线程中新建了两字子线程t1和t2,t1会调用NoSynchronizedTest对象的synMethod()方法,该发放内还有同步快,而t2则会调用NoSynchronized对象的nonSynMethon()方法,该方法不是同步方法,t1运行时,虽然调用synchronized(this)获取"NoSynchronizedTest的同步锁",但是并没有造成t2的阻塞,因为t2没有用到"NoSynchronizedTest"同步锁。

第三条:

当一个线程访问"某对象"的"synchronized方法"或者"synchronized代码块"时,其他线程对"该对象"的其他的"synchronized方法"或者"synchronized代码块"的访问将被阻塞。

演示代码:

public class NoSynchronizedTest {

    //含有synchronized同步代码块方法
    public void synMethod(){
        synchronized (this){
            try {
                for (int i = 0; i < 5; i++){
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + " synMethod loop " + i);
                }
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }

    //非同步方法
    public void nonSynchronized(){
        synchronized (this){
            try{
                for (int i = 0; i < 5; i++){
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + " nonSynMethod loop " + i);
                }
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args){
        final NoSynchronizedTest noSynchronizedTest = new NoSynchronizedTest();
        Thread t1 = new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        noSynchronizedTest.synMethod();
                    }
                },"t1");
        Thread t2 = new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        noSynchronizedTest.nonSynchronized();
                    }
                },"t2");
        t1.start();
        t2.start();
    }
}

运行结果:

t1 synMethod loop 0
t1 synMethod loop 1
t1 synMethod loop 2
t1 synMethod loop 3
t1 synMethod loop 4
t2 nonSynMethod loop 0
t2 nonSynMethod loop 1
t2 nonSynMethod loop 2
t2 nonSynMethod loop 3
t2 nonSynMethod loop 4

结果说明:

主线程中新建了两个子线程t1和t2,t1和t2运行时都调用synchronized(this),这个this是NoSynchronized对象,而t1和t2共用NoSynchronized,因此,在t1运行时,t2会被阻塞,等待t1运行释放"NoSynchronized对象的同步锁",t2才可以运行。

-----synchronized方法和synchronized代码块--------------------

"synchronized方法"使用synchronized修饰方法,而"synchronized代码块"则是用synchronized修饰代码块。

synchronized方法事例:

public synchronized void test1() {
    System.out.println("synchronized methoed");
}

synchronized代码块事例:

public void test() {
    synchronized (this) {
        System.out.println("synchronized methoed");
    }
}

synchronized代码块中的this是指当前对象,也可以将this替换成其他对象,例如:将this替换成obj,则test2()在执行synchronized(obj)时就获取的时obj的同步锁。

synchronized代码块可以更精确的控制冲突限制访问区域,有时候变现的更高效率,以下为事例:

public class SynchronizedDemo {

    public synchronized void synMethon(){
        for (int i = 0; i < 1000000; i++){
            ;
        }
    }

    public void synBlock(){
        synchronized (this){
            for (int i = 0; i < 1000000; i++){
                ;
            }
        }
    }

    public static void main(String[] args){
        SynchronizedDemo demo  = new SynchronizedDemo();
        long start,diff;
        start = System.currentTimeMillis();
        demo.synMethon();
        diff = System.currentTimeMillis() - start;
        System.out.println("synMethon(): " + diff);

        start = System.currentTimeMillis();
        demo.synBlock();
        diff = System.currentTimeMillis() - start;
        System.out.println("synBlock():" + diff);
    }
}

某一次运行结果:

synMethon(): 4
synBlock():3

-----实例所和全局锁----------------------

实例锁 -- 锁在某一个实例对象上,如果该类是单利,那么该所也是全局锁的概念。实例锁对应的就是synchronized关键字。

全局锁 -- 该锁针对的是类,无论实例多少个对象,那么线程都共享该锁,全局锁对应的就是static synchronized(或者是锁在该类的class或者classloader对象上),

如下为"实例锁"和"全局锁"有一个很形象的例子

pulbic class Something {
    public synchronized void isSyncA(){}
    public synchronized void isSyncB(){}
    public static synchronized void cSyncA(){}
    public static synchronized void cSyncB(){}
}

假设,Something有两个实例x和y,分析下面4组表达式获取锁的情况

(01) x.isSyncA()与x.isSyncB() 
(02) x.isSyncA()与y.isSyncA()
(03) x.cSyncA()与y.cSyncB()
(04) x.isSyncA()与Something.cSyncA()

(01) 不能被同时访问。因为isSyncA()和isSyncB()都是访问同一个对象(对象x)的同步锁!

(02) 可以同时被访问。因为访问的不是同一个对象的同步锁,x.isSyncA()访问的是x的同步锁,而y.isSyncA()访问的是y的同步锁。

(03) 不能被同时访问。因为cSyncA()和cSyncB()都是static类型,x.cSyncA()相当于Something.isSyncA(),y.cSyncB()相当于Something.isSyncB(),因此它们共用一个同步锁,不能被同时反问。

(04) 可以被同时访问。因为isSyncA()是实例方法,x.isSyncA()使用的是对象x的锁;而cSyncA()是静态方法,Something.cSyncA()可以理解对使用的是“类的锁”。因此,它们是可以被同时访问的。



----------------------------------------------备注--------------------------------------

此篇文章来自java架构师之路


多多指教!!!

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值