JAVA从入门到精通之多线程并发编程之Synchronized关键字
小职 2018-03-01 来源 :网络 阅读 197 评论 0

摘要:本次将讲解JAVA从入门到精通之Java多线程并发编程之Synchronized关键字!同步锁依赖于对象,每个对象都有一个同步锁。

synchronized 关键字解析

本次将讲解JAVA从入门到精通之Java多线程并发编程之Synchronized关键字!

同步锁依赖于对象,每个对象都有一个同步锁。

现有一成员变量 Test,当线程 A 调用 Test 的 synchronized 方法,线程 A 获得 Test 的同步锁,同时,线程 B 也去调用 Test 的 synchronized 方法,此时线程 B 无法获得 Test 的同步锁,必须等待线程 A 释放 Test 的同步锁才能获得从而执行对应方法的代码。

综上,正确使用 synchronized 关键字可确保原子性。

synchronized 关键字的特性应用

特性 1:

当线程 A 调用某对象的synchronized 方法 或者 synchronized 代码块时,若同步锁未释放,其他线程调用同一对象的synchronized 方法 或者 synchronized 代码块时将被阻塞,直至线程 A 释放该对象的同步锁。

DEMO1,synchronized 方法:

public class Test {


    private static class Counter {


        public synchronized void count() {

            for (int i = 0; i < 6; i++) {

                System.out.println(Thread.currentThread().getName() + ", i = " + i);

            }

        }


    }


    private static class MyThread extends Thread {


        private Counter mCounter;


        public MyThread(Counter counter) {

            mCounter = counter;

        }


        @Override

        public void run() {

            super.run();

            mCounter.count();

        }

    }


    public static void main(String[] var0) {

        Counter counter = new Counter();

        // 注:myThread1 和 myThread2 是调用同一个对象 counter

        MyThread myThread1 = new MyThread(counter);

        MyThread myThread2 = new MyThread(counter);

        myThread1.start();

        myThread2.start();

    }


}

DEMO1 输出:

Thread-0, i = 0

Thread-0, i = 1

Thread-0, i = 2

Thread-0, i = 3

Thread-0, i = 4

Thread-0, i = 5

Thread-1, i = 0

Thread-1, i = 1

Thread-1, i = 2

Thread-1, i = 3

Thread-1, i = 4

Thread-1, i = 5

DEMO2,synchronized 代码块:

public class Test {


    private static class Counter {


        public void count() {

            synchronized (this) {

                for (int i = 0; i < 6; i++) {

                    System.out.println(Thread.currentThread().getName() + ", i = " + i);

                }

            }

        }

    }


    private static class MyThread extends Thread {


        private Counter mCounter;


        public MyThread(Counter counter) {

            mCounter = counter;

        }


        @Override

        public void run() {

            super.run();

            mCounter.count();

        }

    }


    public static void main(String[] var0) {

        Counter counter = new Counter();

        MyThread myThread1 = new MyThread(counter);

        MyThread myThread2 = new MyThread(counter);

        myThread1.start();

        myThread2.start();

    }

}

DEMO2 输出:

Thread-0, i = 0

Thread-0, i = 1

Thread-0, i = 2

Thread-0, i = 3

Thread-0, i = 4

Thread-0, i = 5

Thread-1, i = 0

Thread-1, i = 1

Thread-1, i = 2

Thread-1, i = 3

Thread-1, i = 4

Thread-1, i = 5

可见,当同步锁未释放时,其他线程将被阻塞,直至获得同步锁。

而且 DEMO1 和 DEMO2 的输出结果是一样的,synchronized 方法 和 synchronized 代码块的不同之处在于 synchronized 方法 作用域较大,作用于整个方法,而 synchronized 代码块 可控制具体的作用域,更精准控制提高效率。(毕竟阻塞的都是时间啊)

DEMO3,仅修改 main 方法:

    public static void main(String[] var0) {

        // 注意:myThread1 和 myThread2 传入的 Counter 是两个不同的对象

        MyThread myThread1 = new MyThread(new Counter());

        MyThread myThread2 = new MyThread(new Counter());

        myThread1.start();

        myThread2.start();

    }

DEMO3 输出:

Thread-0, i = 0

Thread-1, i = 0

Thread-0, i = 1

Thread-1, i = 1

Thread-1, i = 2

Thread-1, i = 3

Thread-0, i = 2

Thread-1, i = 4

Thread-0, i = 3

Thread-1, i = 5

Thread-0, i = 4

Thread-0, i = 5

同步锁基于对象,只要锁的来源一致,即可达到同步的作用。所以,但对象不一样,则不能达到同步效果。

特性 2:

当线程 A 调用某对象的synchronized 方法 或者 synchronized 代码块时,若同步锁未释放,其他线程调用同一对象的其他synchronized 方法 或者 synchronized 代码块时将被阻塞,直至线程 A 释放该对象的同步锁。(注意:重点是其他)

DEMO4,仅修改 doOtherThings 方法的修饰:

public class Test {


    private static class Counter {


        public synchronized void count() {

            System.out.println(Thread.currentThread().getName() + " sleep");

            try {

                Thread.sleep(3000);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            System.out.println(Thread.currentThread().getName() + " awake");

        }


        public synchronized void doOtherThings(){

            System.out.println(Thread.currentThread().getName() + " doOtherThings");

        }

    }


    public static void main(String[] var0) {

        final Counter counter = new Counter();

        new Thread(new Runnable() {

            @Override

            public void run() {

                counter.count();

            }

        }).start();

        new Thread(new Runnable() {

            @Override

            public void run() {

                counter.doOtherThings();

            }

        }).start();

    }

}

DEMO4 输出:

Thread-0 sleep

Thread-0 awake

Thread-1 doOtherThings

可见,synchronized 获得的同步锁并非仅仅锁住代码,而是锁住整个对象。

此时应提及 happens-before 原则,正因 happens-before 原则的存在才有此现象的发生。

happens-before 原则的其中一条:

管理锁定原则:一个 unLock 操作先行发生于后面对同一个锁的 lock 操作。

(此处暂不作过多解释,解释起来能再写一篇文章了)

DEMO5,仅修改 doOtherThings 方法:

        public void doOtherThings(){

            synchronized (this){

                System.out.println(Thread.currentThread().getName() + " doOtherThings");

            }

        }

DEMO5 输出:

Thread-0 sleep

Thread-0 awake

Thread-1 doOtherThings

DEMO4 和 DEMO5 的输出结果竟然一致!没错,因为他们的同步锁来源一致(都是本实例自己),所以可以达到同步效果。

// 这两个 synchronized 锁的是同一个对象public synchronized void count(){};public void doOtherThings(){

       synchronized (this){}

}

DEMO6,去掉 doOtherThings 方法的同步关键字:

public void doOtherThings(){

            System.out.println(Thread.currentThread().getName() + " doOtherThings");

        }

DEMO6 输出:

Thread-0 sleep

Thread-1 doOtherThings

Thread-0 awake

当线程 A 调用某对象的synchronized 方法 或者 synchronized 代码块时,无论同步锁是否释放,其他线程调用同一对象的其他 非 synchronized 方法 或者 非 synchronized 代码块时可立即调用。

实例锁和全局锁

以上 DEMO 实现的都是实例锁。锁住(作用域)的是具体某一对象实例。

什么是全局锁?

锁住整个 Class,而非某个对象或实例。

注:单例型的实例锁不属于全局锁。

全局锁的实现:

静态 synchronized 方法

DEMO7:

public class Test {


    private static class Counter {


        public static synchronized void count() {

            System.out.println(Thread.currentThread().getName() + " sleep");

            try {

                Thread.sleep(3000);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            System.out.println(Thread.currentThread().getName() + " awake");

        }


        public static synchronized void doOtherThings(){

            System.out.println(Thread.currentThread().getName() + " doOtherThings");

        }

    }


    public static void main(String[] var0) {

        new Thread(new Runnable() {

            @Override

            public void run() {

                Counter.count();

            }

        }).start();

        new Thread(new Runnable() {

            @Override

            public void run() {

                Counter.doOtherThings();

            }

        }).start();

    }

}

DEMO7 输出:

Thread-0 sleep

Thread-0 awake

Thread-1 doOtherThings

static 声明的方法为全局方法,与对象实例化无关,所以 static synchronized 方法为全局同步方法,与对象实例化无关。

synchronized 具体 Class 的代码块

DEMO8:

public class Test {


    private static class Counter {


        public static synchronized void count() {

            System.out.println(Thread.currentThread().getName() + " sleep");

            try {

                Thread.sleep(3000);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            System.out.println(Thread.currentThread().getName() + " awake");

        }


        public void doOtherThings(){

            synchronized (Counter.class){

                System.out.println(Thread.currentThread().getName() + " doOtherThings");

            }

        }

    }


    public static void main(String[] var0) {

        new Thread(new Runnable() {

            @Override

            public void run() {

                Counter.count();

            }

        }).start();

        new Thread(new Runnable() {

            @Override

            public void run() {

                Counter counter = new Counter();

                counter.doOtherThings();

            }

        }).start();

    }

}

DEMO8 输出:

Thread-0 sleep

Thread-0 awake

Thread-1 doOtherThings

synchronized (Counter.class) 获得的同步锁是全局的,static synchronized 获得的同步锁也是全局的,同一个锁,所以达到同步效果。

区分 synchronized (this) 与 synchronized (Class.class)

DEMO9:

public class Test {


    private static class Counter {


        public void count() {

            synchronized (this){

                System.out.println(Thread.currentThread().getName() + " sleep");

                try {

                    Thread.sleep(3000);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

                System.out.println(Thread.currentThread().getName() + " awake");

            }

        }


        public void doOtherThings(){

            synchronized (Counter.class){

                System.out.println(Thread.currentThread().getName() + " doOtherThings");

            }

        }

    }


    public static void main(String[] var0) {

        final Counter counter = new Counter();

        new Thread(new Runnable() {

            @Override

            public void run() {

                counter.count();

            }

        }).start();

        new Thread(new Runnable() {

            @Override

            public void run() {

                counter.doOtherThings();

            }

        }).start();

    }

}

DEMO9 输出:

Thread-0 sleep

Thread-1 doOtherThings

Thread-0 awake

synchronized (this) 获得的是具体对象实例 counter 的锁,而 synchronized (Counter.class) 获得的是全局锁,两把不同的锁,所以不能达到同步效果。


希望这篇文章可以帮助到你。总之,同学们,你想要的职坐标IT频道都能找到!


本文由 @小职 发布于职坐标。未经许可,禁止转载。
喜欢 | 0 不喜欢 | 0
看完这篇文章有何感觉?已经有0人表态,0%的人喜欢 快给朋友分享吧~
评论(0)
后参与评论
加入IT交流圈
JAVA工程师交流群 +加入
大数据架构师交流群 +加入
人工智能Python交流群 +加入
WEB/H5前端交流群 +加入
大数据岗位高薪定向就业名额  提前锁定高薪职位
编程语言直通车

  • 资料索取

  • 答疑解惑

  • 技术交流

  • 职业测评

  • 面试技巧

  • 高薪秘籍
海同名师推荐 更多>>
张军 联系TA
10年项目开发经验,精通pc、mobile平台软件开发主流技术和框架
杨成江 联系TA
青春为马 不负韶华
翟健 联系TA
熟悉系大型项目开发业务流程,精通C、Java语言
黄骈 联系TA
认证System Analyst,System Architect
程光淼 联系TA
精通C、C++等语言、智能芯片开发
热门就业培训班 更多>>
【零基础】人工智能+Python全栈开发课程
登顶技术风口浪潮巅峰 年薪百万不是梦
【零基础】JavaEE高级开发工程师课程
小白0基础入学 8000起薪轻松进名企
【零基础】大数据与分布式架构师课程
掌握大数据分布式架构 冲击年薪50W+
JAVA30天热搜词 更多>>
X
免费获取海同IT培训资料
验证码手机号,获得海同独家IT培训资料
获取验证码
提交

版权所有 职坐标-一站式IT培训就业服务领导者 沪ICP备13042190号-4
上海海同信息科技有限公司 Copyright ©2015 www.zhizuobiao.com,All Rights Reserved.
沪公网安备 31011502005948号